# free = [ unmangle(name) for name in (co.co_cellvars + co.co_freevars) ]

# names = [ unmangle(name) for name in co.co_names ]

# varnames = [ unmangle(name) for name in co.co_varnames ]

# free = co.co_cellvars + co.co_freevars

# names = co.co_names

# varnames = co.co_varnames

# FIXME: merge with scanner3 code

def detect_structure(self, offset):

"""

code = self.code

op = code[offset]

# Detect parent structure

parent = self.structs[0]

start = parent['start']

end = parent['end']

# Pick inner-most parent for our offset

for struct in self.structs:

curent_start = struct['start']

curent_end = struct['end']

if (curent_start <= offset < curent_end) and (curent_start >= start and curent_end <= end):

start = curent_start

end = curent_end

parent = struct

pass

if op in (POP_JUMP_IF_FALSE, POP_JUMP_IF_TRUE):

start = offset + self.op_size(op)

target = self.get_target(offset)

rtarget = self.restrict_to_parent(target, parent)

prev_op = self.prev_op

# Do not let jump to go out of parent struct bounds

if target != rtarget and parent['type'] == 'and/or':

self.fixed_jumps[offset] = rtarget

return

# Does this jump to right after another cond jump?

# If so, it's part of a larger conditional

if (code[prev_op[target]] in (JUMP_IF_FALSE_OR_POP, JUMP_IF_TRUE_OR_POP,

POP_JUMP_IF_FALSE, POP_JUMP_IF_TRUE)) and (target > offset):

self.fixed_jumps[offset] = prev_op[target]

self.structs.append({'type': 'and/or',

'start': start,

'end': prev_op[target]})

return

# Is it an and inside if block

if op == POP_JUMP_IF_FALSE:

# Search for other POP_JUMP_IF_FALSE targetting the same op,

# in current statement, starting from current offset, and filter

# everything inside inner 'or' jumps and midline ifs

match = self.rem_or(start, self.next_stmt[offset], POP_JUMP_IF_FALSE, target)

match = self.remove_mid_line_ifs(match)

# If we still have any offsets in set, start working on it

if match:

if (code[prev_op[rtarget]] in (JUMP_FORWARD, JUMP_ABSOLUTE) and prev_op[rtarget] not in self.stmts and

self.restrict_to_parent(self.get_target(prev_op[rtarget]), parent) == rtarget):

if (code[prev_op[prev_op[rtarget]]] == JUMP_ABSOLUTE and self.remove_mid_line_ifs([offset]) and

target == self.get_target(prev_op[prev_op[rtarget]]) and

(prev_op[prev_op[rtarget]] not in self.stmts or self.get_target(prev_op[prev_op[rtarget]]) > prev_op[prev_op[rtarget]]) and

1 == len(self.remove_mid_line_ifs(self.rem_or(start, prev_op[prev_op[rtarget]], (POP_JUMP_IF_FALSE, POP_JUMP_IF_TRUE), target)))):

pass

elif (code[prev_op[prev_op[rtarget]]] == RETURN_VALUE and self.remove_mid_line_ifs([offset]) and

1 == (len(set(self.remove_mid_line_ifs(self.rem_or(start, prev_op[prev_op[rtarget]],

(POP_JUMP_IF_FALSE, POP_JUMP_IF_TRUE), target))) |

set(self.remove_mid_line_ifs(self.rem_or(start, prev_op[prev_op[rtarget]],

(POP_JUMP_IF_FALSE, POP_JUMP_IF_TRUE, JUMP_ABSOLUTE),

prev_op[rtarget], True)))))):

pass

else:

fix = None

jump_ifs = self.all_instr(start, self.next_stmt[offset], POP_JUMP_IF_FALSE)

last_jump_good = True

for j in jump_ifs:

if target == self.get_target(j):

if self.lines[j].next == j + 3 and last_jump_good:

fix = j

break

else:

last_jump_good = False

self.fixed_jumps[offset] = fix or match[-1]

return

else:

self.fixed_jumps[offset] = match[-1]

return

# op == POP_JUMP_IF_TRUE

else:

next = self.next_stmt[offset]

if prev_op[next] == offset:

pass

elif code[next] in (JUMP_FORWARD, JUMP_ABSOLUTE) and target == self.get_target(next):

if code[prev_op[next]] == POP_JUMP_IF_FALSE:

if code[next] == JUMP_FORWARD or target != rtarget or code[prev_op[prev_op[rtarget]]] not in (JUMP_ABSOLUTE, RETURN_VALUE):

self.fixed_jumps[offset] = prev_op[next]

return

elif (code[next] == JUMP_ABSOLUTE and code[target] in (JUMP_ABSOLUTE, JUMP_FORWARD) and

self.get_target(target) == self.get_target(next)):

self.fixed_jumps[offset] = prev_op[next]

return

# Don't add a struct for a while test, it's already taken care of

if offset in self.ignore_if:

return

if (code[prev_op[rtarget]] == JUMP_ABSOLUTE and prev_op[rtarget] in self.stmts and

prev_op[rtarget] != offset and prev_op[prev_op[rtarget]] != offset and

not (code[rtarget] == JUMP_ABSOLUTE and code[rtarget+3] == POP_BLOCK and code[prev_op[prev_op[rtarget]]] != JUMP_ABSOLUTE)):

rtarget = prev_op[rtarget]

# Does the if jump just beyond a jump op, then this is probably an if statement

if code[prev_op[rtarget]] in (JUMP_ABSOLUTE, JUMP_FORWARD):

if_end = self.get_target(prev_op[rtarget])

# Is this a loop not an if?

if (if_end < prev_op[rtarget]) and (code[prev_op[if_end]] == SETUP_LOOP):

if(if_end > start):

return

end = self.restrict_to_parent(if_end, parent)

self.structs.append({'type': 'if-then',

'start': start,

'end': prev_op[rtarget]})

self.not_continue.add(prev_op[rtarget])

if rtarget < end:

self.structs.append({'type': 'if-else',

'start': rtarget,

'end': end})

elif code[prev_op[rtarget]] == RETURN_VALUE:

self.structs.append({'type': 'if-then',

'start': start,

'end': rtarget})

self.return_end_ifs.add(prev_op[rtarget])

elif op in (JUMP_IF_FALSE_OR_POP, JUMP_IF_TRUE_OR_POP):

target = self.get_target(offset)

if target > offset:

unop_target = self.last_instr(offset, target, JUMP_FORWARD, target)

if unop_target and code[unop_target+3] != ROT_TWO:

self.fixed_jumps[offset] = unop_target

else:

self.fixed_jumps[offset] = self.restrict_to_parent(target, parent)