try:

return (node[0][0].kind == 'assign' and

node[0][0][1][0].pattr == '__doc__')

except:

def __init__(self, errmsg):

self.errmsg = errmsg

def __str__(self):

stacked_params = ('f', 'indent', 'is_lambda', '_globals')

def __init__(self, version, out, scanner, showast=False,

debug_parser=PARSER_DEFAULT_DEBUG,

compile_mode='exec', is_pypy=IS_PYPY,

linestarts={}, tolerate_errors=False):

"""`version' is the Python version (a float) of the Python dialect

GenericASTTraversal.__init__(self, ast=None)

self.scanner = scanner

params = {

'f': out,

'indent': '',

}

self.version = version

self.p = get_python_parser(version, debug_parser=dict(debug_parser),

compile_mode=compile_mode, is_pypy=is_pypy)

self.debug_parser = dict(debug_parser)

self.showast = showast

self.params = params

self.param_stack = []

self.ERROR = None

self.prec = 100

self.return_none = False

self.mod_globs = set()

self.currentclass = None

self.classes = []

self.pending_newlines = 0

self.linestarts = linestarts

self.line_number = 1

self.ast_errors = []

# FIXME: have p.insts update in a better way

# modularity is broken here

self.p.insts = scanner.insts

# This is in Python 2.6 on. It changes the way

# strings get interpreted. See n_LOAD_CONST

self.FUTURE_UNICODE_LITERALS = False

# Sometimes we may want to continue decompiling when there are errors

# and sometimes not

self.tolerate_errors = tolerate_errors

# hide_internal suppresses displaying the additional instructions that sometimes

# exist in code but but were not written in the source code.

# An example is:

# __module__ = __name__

self.hide_internal = True

self.name = None

self.version = version

self.is_pypy = is_pypy

customize_for_version(self, is_pypy, version)

return

def str_with_template(self, ast):

stream = sys.stdout

stream.write(self.str_with_template1(ast, '', None))

stream.write('\n')

def str_with_template1(self, ast, indent, sibNum=None):

rv = str(ast.kind)

if sibNum is not None:

rv = "%2d. %s" % (sibNum, rv)

enumerate_children = False

if len(ast) > 1:

rv += " (%d)" % (len(ast))

enumerate_children = True

mapping = self._get_mapping(ast)

table = mapping[0]

key = ast

for i in mapping[1:]:

key = key[i]

pass

if key.kind in table:

rv += ": %s" % str(table[key.kind])

rv = indent + rv

indent += ' '

i = 0

for node in ast:

if hasattr(node, '__repr1__'):

if enumerate_children:

child = self.str_with_template1(node, indent, i)

else:

child = self.str_with_template1(node, indent, None)

else:

inst = node.format(line_prefix='L.')

if inst.startswith("\n"):

# Nuke leading \n

inst = inst[1:]

if enumerate_children:

child = indent + "%2d. %s" % (i, inst)

else:

child = indent + inst

pass

rv += "\n" + child

i += 1

return rv

def indent_if_source_nl(self, line_number, indent):

if (line_number != self.line_number):

self.write("\n" + self.indent + INDENT_PER_LEVEL[:-1])

return self.line_number

f = property(lambda s: s.params['f'],

lambda s, x: s.params.__setitem__('f', x),

lambda s: s.params.__delitem__('f'),

None)

indent = property(lambda s: s.params['indent'],

lambda s, x: s.params.__setitem__('indent', x),

lambda s: s.params.__delitem__('indent'),

None)

is_lambda = property(lambda s: s.params['is_lambda'],

lambda s, x: s.params.__setitem__('is_lambda', x),

lambda s: s.params.__delitem__('is_lambda'),

None)

_globals = property(lambda s: s.params['_globals'],

lambda s, x: s.params.__setitem__('_globals', x),

lambda s: s.params.__delitem__('_globals'),

None)

def set_pos_info(self, node):

if hasattr(node, 'linestart') and node.linestart:

self.line_number = node.linestart

def preorder(self, node=None):

super(SourceWalker, self).preorder(node)

self.set_pos_info(node)

def indent_more(self, indent=TAB):

self.indent += indent

def indent_less(self, indent=TAB):

self.indent = self.indent[:-len(indent)]

def traverse(self, node, indent=None, is_lambda=False):

self.param_stack.append(self.params)

if indent is None: indent = self.indent

p = self.pending_newlines

self.pending_newlines = 0

self.params = {

'_globals': {},

'_nonlocals': {}, # Python 3 has nonlocal

'f': StringIO(),

'indent': indent,

'is_lambda': is_lambda,

}

self.preorder(node)

self.f.write('\n'*self.pending_newlines)

result = self.f.getvalue()

self.params = self.param_stack.pop()

self.pending_newlines = p

return result

def write(self, *data):

if (len(data) == 0) or (len(data) == 1 and data[0] == ''):

return

if not PYTHON3:

out = ''.join((unicode(j) for j in data))

else:

out = ''.join((str(j) for j in data))

n = 0

for i in out:

if i == '\n':

n += 1

if n == len(out):

self.pending_newlines = max(self.pending_newlines, n)

return

elif n:

self.pending_newlines = max(self.pending_newlines, n)

out = out[n:]

break

else:

break

if self.pending_newlines > 0:

self.f.write('\n'*self.pending_newlines)

self.pending_newlines = 0

for i in out[::-1]:

if i == '\n':

self.pending_newlines += 1

else:

break

if self.pending_newlines:

out = out[:-self.pending_newlines]

if (isinstance(out, str) and

not (PYTHON3 or self.FUTURE_UNICODE_LITERALS)):

out = unicode(out, 'utf-8')

self.f.write(out)

def println(self, *data):

if data and not(len(data) == 1 and data[0] == ''):

self.write(*data)

self.pending_newlines = max(self.pending_newlines, 1)

def is_return_none(self, node):

# Is there a better way?

ret = (node[0] == 'ret_expr'

and node[0][0] == 'expr'

and node[0][0][0] == 'LOAD_CONST'

and node[0][0][0].pattr is None)

if self.version <= 2.6:

return ret

else:

# FIXME: should the SyntaxTree expression be folded into

# the global RETURN_NONE constant?

return (ret or

node == SyntaxTree('return',

[SyntaxTree('ret_expr', [NONE]), Token('RETURN_VALUE')]))

# Python 3.x can have be dead code as a result of its optimization?

# So we'll add a # at the end of the return lambda so the rest is ignored

def n_return_lambda(self, node):

if 1 <= len(node) <= 2:

self.preorder(node[0])

self.write(' # Avoid dead code: ')

self.prune()

else:

# We can't comment out like above because there may be a trailing ')'

# that needs to be written

assert len(node) == 3 and node[2] == 'LAMBDA_MARKER'

self.preorder(node[0])

self.prune()

def n_return(self, node):

if self.params['is_lambda']:

self.preorder(node[0])

self.prune()

else:

self.write(self.indent, 'return')

# One reason we worry over whether we use "return None" or "return"

# is that inside a generator, "return None" is illegal.

# Thank you, Python!

if (self.return_none or not self.is_return_none(node)):

self.write(' ')

self.preorder(node[0])

self.println()

self.prune() # stop recursing

def n_return_if_stmt(self, node):

if self.params['is_lambda']:

self.write(' return ')

self.preorder(node[0])

self.prune()

else:

self.write(self.indent, 'return')

if self.return_none or not self.is_return_none(node):

self.write(' ')

self.preorder(node[0])

self.println()

self.prune() # stop recursing

def n_yield(self, node):

if node != SyntaxTree('yield', [NONE, Token('YIELD_VALUE')]):

self.template_engine(( 'yield %c', 0), node)

elif self.version <= 2.4:

# Early versions of Python don't allow a plain "yield"

self.write('yield None')

else:

self.write('yield')

self.prune() # stop recursing

def n_build_slice3(self, node):

p = self.prec

self.prec = 100

if not node[0].isNone():

self.preorder(node[0])

self.write(':')

if not node[1].isNone():

self.preorder(node[1])

self.write(':')

if not node[2].isNone():

self.preorder(node[2])

self.prec = p

self.prune() # stop recursing

def n_build_slice2(self, node):

p = self.prec

self.prec = 100

if not node[0].isNone():

self.preorder(node[0])

self.write(':')

if not node[1].isNone():

self.preorder(node[1])

self.prec = p

self.prune() # stop recursing

def n_expr(self, node):

p = self.prec

if node[0].kind.startswith('binary_expr'):

n = node[0][-1][0]

else:

n = node[0]

# if (hasattr(n, 'linestart') and n.linestart and

# hasattr(self, 'current_line_number')):

# self.source_linemap[self.current_line_number] = n.linestart

self.prec = PRECEDENCE.get(n.kind, -2)

if n == 'LOAD_CONST' and repr(n.pattr)[0] == '-':

self.prec = 6

if p < self.prec:

self.write('(')

self.preorder(node[0])

self.write(')')

else:

self.preorder(node[0])

self.prec = p

self.prune()

def n_ret_expr(self, node):

if len(node) == 1 and node[0] == 'expr':

self.n_expr(node[0])

else:

self.n_expr(node)

n_ret_expr_or_cond = n_expr

def n_binary_expr(self, node):

self.preorder(node[0])

self.write(' ')

self.preorder(node[-1])

self.write(' ')

self.prec -= 1

self.preorder(node[1])

self.prec += 1

self.prune()

def n_str(self, node):

self.write(node[0].pattr)

self.prune()

def pp_tuple(self, tup):

"""Pretty print a tuple"""

last_line = self.f.getvalue().split("\n")[-1]

l = len(last_line)+1

indent = ' ' * l

self.write('(')

sep = ''

for item in tup:

self.write(sep)

l += len(sep)

s = repr(item)

l += len(s)

self.write(s)

sep = ','

if l > LINE_LENGTH:

l = 0

sep += '\n' + indent

else:

sep += ' '

pass

pass

if len(tup) == 1:

self.write(", ")

self.write(')')

def n_LOAD_CONST(self, node):

attr = node.attr

data = node.pattr; datatype = type(data)

if isinstance(data, float) and str(data) in frozenset(['nan', '-nan', 'inf', '-inf']):

# float values 'nan' and 'inf' are not directly representable in Python at least

# before 3.5 and even there it is via a library constant.

# So we will canonicalize their representation as float('nan') and float('inf')

self.write("float('%s')" % data)

elif isinstance(datatype, int) and data == minint:

# convert to hex, since decimal representation

# would result in 'LOAD_CONST; UNARY_NEGATIVE'

# change:hG/2002-02-07: this was done for all negative integers

# todo: check whether this is necessary in Python 2.1

self.write( hex(data) )

elif datatype is type(Ellipsis):

self.write('...')

elif attr is None:

# LOAD_CONST 'None' only occurs, when None is

# implicit eg. in 'return' w/o params

# pass

self.write('None')

elif isinstance(data, tuple):

self.pp_tuple(data)

elif isinstance(attr, bool):

self.write(repr(attr))

elif self.FUTURE_UNICODE_LITERALS:

# The FUTURE_UNICODE_LITERALS compiler flag

# in 2.6 on change the way

# strings are interpreted:

# u'xxx' -> 'xxx'

# xxx' -> b'xxx'

if not PYTHON3 and isinstance(data, unicode):

try:

data = str(data)

except UnicodeEncodeError:

# Have to keep data as it is: in Unicode.

pass

self.write(repr(data))

elif isinstance(data, str):

self.write('b'+repr(data))

else:

self.write(repr(data))

else:

if not PYTHON3:

try:

repr(data).encode("ascii")

except UnicodeEncodeError:

self.write('u')

self.write(repr(data))

# LOAD_CONST is a terminal, so stop processing/recursing early

self.prune()

def n_delete_subscript(self, node):

if node[-2][0] == 'build_list' and node[-2][0][-1].kind.startswith('BUILD_TUPLE'):

if node[-2][0][-1] != 'BUILD_TUPLE_0':

node[-2][0].kind = 'build_tuple2'

self.default(node)

n_store_subscript = n_subscript = n_delete_subscript

# Note: this node is only in Python 2.x

# FIXME: figure out how to get this into customization

# put so that we can get access via super from

# the fragments routine.

def n_exec_stmt(self, node):

"""

self.write(self.indent, 'exec ')

self.preorder(node[0])

if not node[1][0].isNone():

sep = ' in '

for subnode in node[1]:

self.write(sep); sep = ", "

self.preorder(subnode)

self.println()

self.prune() # stop recursing

def n_ifelsestmt(self, node, preprocess=False):

else_suite = node[3]

n = else_suite[0]

if len(n) == 1 == len(n[0]) and n[0] == '_stmts':

n = n[0][0][0]

elif n[0].kind in ('lastc_stmt', 'lastl_stmt'):

n = n[0][0]

else:

if not preprocess:

self.default(node)

return

if n.kind in ('ifstmt', 'iflaststmt', 'iflaststmtl'):

node.kind = 'ifelifstmt'

n.kind = 'elifstmt'

elif n.kind in ('ifelsestmtr',):

node.kind = 'ifelifstmt'

n.kind = 'elifelsestmtr'

elif n.kind in ('ifelsestmt', 'ifelsestmtc', 'ifelsestmtl'):

node.kind = 'ifelifstmt'

self.n_ifelsestmt(n, preprocess=True)

if n == 'ifelifstmt':

n.kind = 'elifelifstmt'

elif n.kind in ('ifelsestmt', 'ifelsestmtc', 'ifelsestmtl'):

n.kind = 'elifelsestmt'

if not preprocess:

self.default(node)

n_ifelsestmtc = n_ifelsestmtl = n_ifelsestmt

def n_ifelsestmtr(self, node):

if node[2] == 'COME_FROM':

return_stmts_node = node[3]

node.kind = 'ifelsestmtr2'

else:

return_stmts_node = node[2]

if len(return_stmts_node) != 2:

self.default(node)

if (not (return_stmts_node[0][0][0] == 'ifstmt'

and return_stmts_node[0][0][0][1][0] == 'return_if_stmts')

and not (return_stmts_node[0][-1][0] == 'ifstmt'

and return_stmts_node[0][-1][0][1][0] == 'return_if_stmts')):

self.default(node)

return

self.write(self.indent, 'if ')

self.preorder(node[0])

self.println(':')

self.indent_more()

self.preorder(node[1])

self.indent_less()

if_ret_at_end = False

if len(return_stmts_node[0]) >= 3:

if (return_stmts_node[0][-1][0] == 'ifstmt'

and return_stmts_node[0][-1][0][1][0] == 'return_if_stmts'):

if_ret_at_end = True

past_else = False

prev_stmt_is_if_ret = True

for n in return_stmts_node[0]:

if (n[0] == 'ifstmt' and n[0][1][0] == 'return_if_stmts'):

if prev_stmt_is_if_ret:

n[0].kind = 'elifstmt'

prev_stmt_is_if_ret = True

else:

prev_stmt_is_if_ret = False

if not past_else and not if_ret_at_end:

self.println(self.indent, 'else:')

self.indent_more()

past_else = True

self.preorder(n)

if not past_else or if_ret_at_end:

self.println(self.indent, 'else:')

self.indent_more()

self.preorder(return_stmts_node[1])

self.indent_less()

self.prune()

n_ifelsestmtr2 = n_ifelsestmtr

def n_elifelsestmtr(self, node):

if node[2] == 'COME_FROM':

return_stmts_node = node[3]

node.kind = 'elifelsestmtr2'

else:

return_stmts_node = node[2]

if len(return_stmts_node) != 2:

self.default(node)

for n in return_stmts_node[0]:

if not (n[0] == 'ifstmt' and n[0][1][0] == 'return_if_stmts'):

self.default(node)

return

self.write(self.indent, 'elif ')

self.preorder(node[0])

self.println(':')

self.indent_more()

self.preorder(node[1])

self.indent_less()

for n in return_stmts_node[0]:

n[0].kind = 'elifstmt'

self.preorder(n)

self.println(self.indent, 'else:')

self.indent_more()

self.preorder(return_stmts_node[1])

self.indent_less()

self.prune()

def n_alias(self, node):

if self.version <= 2.1:

if len(node) == 2:

store = node[1]

assert store == 'store'

if store[0].pattr == node[0].pattr:

self.write("import %s\n" % node[0].pattr)

else:

self.write("import %s as %s\n" %

(node[0].pattr, store[0].pattr))

pass

pass

self.prune() # stop recursing

store_node = node[-1][-1]

assert store_node.kind.startswith('STORE_')

iname = node[0].pattr # import name

sname = store_node.pattr # store_name

if iname and iname == sname or iname.startswith(sname + '.'):

self.write(iname)

else:

self.write(iname, ' as ', sname)

self.prune() # stop recursing

def n_import_from(self, node):

relative_path_index = 0

if self.version >= 2.5:

if node[relative_path_index].pattr > 0:

node[2].pattr = ('.' * node[relative_path_index].pattr) + node[2].pattr

if self.version > 2.7:

if isinstance(node[1].pattr, tuple):

imports = node[1].pattr

for pattr in imports:

node[1].pattr = pattr

self.default(node)

return

pass

self.default(node)

n_import_from_star = n_import_from

def n_mkfunc(self, node):

if self.version >= 3.3 or node[-2] in ('kwargs', 'no_kwargs'):

# LOAD_CONST code object ..

# LOAD_CONST 'x0' if >= 3.3

# MAKE_FUNCTION ..

code_node = node[-3]

elif node[-2] == 'expr':

code_node = node[-2][0]

else:

# LOAD_CONST code object ..

# MAKE_FUNCTION ..

code_node = node[-2]

func_name = code_node.attr.co_name

self.write(func_name)

self.indent_more()

self.make_function(node, is_lambda=False, code_node=code_node)

if len(self.param_stack) > 1:

self.write('\n\n')

else:

self.write('\n\n\n')

self.indent_less()

self.prune() # stop recursing

def make_function(self, node, is_lambda, nested=1,

code_node=None, annotate=None):

if self.version >= 3.0:

make_function3(self, node, is_lambda, nested, code_node)

else:

make_function2(self, node, is_lambda, nested, code_node)

def n_mklambda(self, node):

self.make_function(node, is_lambda=True, code_node=node[-2])

self.prune() # stop recursing

def n_list_comp(self, node):

"""List comprehensions"""

p = self.prec

self.prec = 100

if self.version >= 2.7:

if self.is_pypy:

self.n_list_comp_pypy27(node)

return

n = node[-1]

elif node[-1] == 'del_stmt':

if node[-2] == 'JUMP_BACK':

n = node[-3]

else:

n = node[-2]

assert n == 'list_iter'

# Find the list comprehension body. It is the inner-most

# node that is not list_.. .

# FIXME: DRY with other use

while n == 'list_iter':

n = n[0] # iterate one nesting deeper

if n == 'list_for': n = n[3]

elif n == 'list_if': n = n[2]

elif n == 'list_if_not': n = n[2]

assert n == 'lc_body'

self.write( '[ ')

if self.version >= 2.7:

expr = n[0]

list_iter = node[-1]

else:

expr = n[1]

if node[-2] == 'JUMP_BACK':

list_iter = node[-3]

else:

list_iter = node[-2]

assert expr == 'expr'

assert list_iter == 'list_iter'

# FIXME: use source line numbers for directing line breaks

line_number = self.line_number

last_line = self.f.getvalue().split("\n")[-1]

l = len(last_line)

indent = ' ' * (l-1)

self.preorder(expr)

line_number = self.indent_if_source_nl(line_number, indent)

self.preorder(list_iter)

l2 = self.indent_if_source_nl(line_number, indent)

if l2 != line_number:

self.write(' ' * (len(indent) - len(self.indent) - 1) + ']')

else:

self.write( ' ]')

self.prec = p

self.prune() # stop recursing

def n_list_comp_pypy27(self, node):

"""List comprehensions in PYPY."""

p = self.prec

self.prec = 27

if node[-1].kind == 'list_iter':

n = node[-1]

elif self.is_pypy and node[-1] == 'JUMP_BACK':

n = node[-2]

list_expr = node[1]

if len(node) >= 3:

store = node[3]

elif self.is_pypy and n[0] == 'list_for':

store = n[0][2]

assert n == 'list_iter'

assert store == 'store'

# Find the list comprehension body. It is the inner-most

# node.

# FIXME: DRY with other use

while n == 'list_iter':

n = n[0] # iterate one nesting deeper

if n == 'list_for': n = n[3]

elif n == 'list_if': n = n[2]

elif n == 'list_if_not': n = n[2]

assert n == 'lc_body'

self.write( '[ ')

expr = n[0]

if self.is_pypy and node[-1] == 'JUMP_BACK':

list_iter = node[-2]

else:

list_iter = node[-1]

assert expr == 'expr'

assert list_iter == 'list_iter'

# FIXME: use source line numbers for directing line breaks

self.preorder(expr)

self.preorder(list_expr)

self.write( ' ]')

self.prec = p

self.prune() # stop recursing

def comprehension_walk(self, node, iter_index, code_index=-5):

p = self.prec

self.prec = 27

# FIXME: clean this up

if self.version >= 3.0 and node == 'dict_comp':

cn = node[1]

elif self.version <= 2.7 and node == 'generator_exp':

if node[0] == 'LOAD_GENEXPR':

cn = node[0]

elif node[0] == 'load_closure':

cn = node[1]

elif self.version >= 3.0 and node == 'generator_exp':

if node[0] == 'load_genexpr':

load_genexpr = node[0]

elif node[1] == 'load_genexpr':

load_genexpr = node[1]

cn = load_genexpr[0]

elif hasattr(node[code_index], 'attr'):

# Python 2.5+ (and earlier?) does this

cn = node[code_index]

else:

if len(node[1]) > 1 and hasattr(node[1][1], 'attr'):

# Python 3.3+ does this

cn = node[1][1]

elif hasattr(node[1][0], 'attr'):

# Python 3.2 does this

cn = node[1][0]

else:

assert False, "Can't find code for comprehension"

assert iscode(cn.attr)

code = Code(cn.attr, self.scanner, self.currentclass)

ast = self.build_ast(code._tokens, code._customize)

self.customize(code._customize)

ast = ast[0][0][0]

n = ast[iter_index]

assert n == 'comp_iter', n

# Find the comprehension body. It is the inner-most

# node that is not list_.. .

while n == 'comp_iter': # list_iter

n = n[0] # recurse one step

if n == 'comp_for':

if n[0] == 'SETUP_LOOP':

n = n[4]

else:

n = n[3]

elif n == 'comp_if':