'break_stmt': ( '%|%rbreak\n', ),

'continue_stmt': ( '%|%rcontinue\n', ),

'passstmt': ( '%|%rpass\n', ),

'raise_stmt0': ( '%|%rraise\n', ),

'importstmt': ( '%|import %c%x\n', 2, (2, (0, 1)), ),

'importfrom': ( '%|from %[2]{pattr}%x import %c\n', (2, (0, 1)), 3),

'importmultiple': ( '%|import%b %c%c\n', 0, 2, 3 ),

'list_for': (' for %c%x in %c%c', 2, (2, (1, )), 0, 3 ),

'forstmt': ( '%|for%b %c%x in %c:\n%+%c%-\n\n', 0, 3, (3, (2, )), 1, 4 ),

'forelsestmt': (

'%|for %c in %c%x:\n%+%c%-%|else:\n%+%c%-\n\n', 3, (3, (2,)), 1, 4, -2),

'forelselaststmt': (

'%|for %c%x in %c:\n%+%c%-%|else:\n%+%c%-', 3, (3, (2,)), 1, 4, -2),

'forelselaststmtl': (

'%|for %c%x in %c:\n%+%c%-%|else:\n%+%c%-\n\n', 3, (3, (2, )), 1, 4, -2),

'whilestmt': ( '%|while%b %c:\n%+%c%-\n\n', 0, 1, 2 ),

'whileelsestmt': ( '%|while%b %c:\n%+%c%-%|else:\n%+%c%-\n\n', 0, 1, 2, -2 ),

'whileelselaststmt': ( '%|while%b %c:\n%+%c%-%|else:\n%+%c%-', 0, 1, 2, -2 ),

'forstmt': ( '%|for%b %c in %c:\n%+%c%-\n\n', 0, 3, 1, 4 ),

MAP_DIRECT_FRAGMENT = ()

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

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

debug_parser=PARSER_DEFAULT_DEBUG,

compile_mode='exec', is_pypy=False):

pysource.SourceWalker.__init__(self, version=version, out=StringIO(),

scanner=scanner,

showast=showast, debug_parser=debug_parser,

compile_mode=compile_mode, is_pypy=is_pypy)

# 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__

# If showing source code we generally don't want to show this. However in fragment

# deparsing we generally do need to see these instructions since we may be stopped

# at one. So here we do not want to suppress showing such instructions.

self.hide_internal = False

self.offsets = {}

self.last_finish = -1

# FIXME: is there a better way?

global MAP_DIRECT_FRAGMENT

MAP_DIRECT_FRAGMENT = dict(TABLE_DIRECT, **TABLE_DIRECT_FRAGMENT),

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)

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

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

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

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, start, finish, name=None):

if name is None: name = self.name

if hasattr(node, 'offset'):

self.offsets[name, node.offset] = \

NodeInfo(node = node, start = start, finish = finish)

if hasattr(node, 'parent'):

assert node.parent != node

node.start = start

node.finish = finish

self.last_finish = finish

def preorder(self, node=None):

start = len(self.f.getvalue())

super(pysource.SourceWalker, self).preorder(node)

self.set_pos_info(node, start, len(self.f.getvalue()))

return

def n_return_stmt(self, node):

start = len(self.f.getvalue()) + len(self.indent)

if self.params['isLambda']:

self.preorder(node[0])

if hasattr(node[-1], 'offset'):

self.set_pos_info(node[-1], start,

len(self.f.getvalue()))

self.prune()

else:

start = len(self.f.getvalue()) + len(self.indent)

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

if self.return_none or node != AST('return_stmt', [AST('ret_expr', [NONE]), Token('RETURN_VALUE')]):

self.write(' ')

self.last_finish = len(self.f.getvalue())

self.preorder(node[0])

if hasattr(node[-1], 'offset'):

self.set_pos_info(node[-1], start, len(self.f.getvalue()))

pass

pass

else:

for n in node:

self.set_pos_info_recurse(n, start, len(self.f.getvalue()))

pass

pass

self.set_pos_info(node, start, len(self.f.getvalue()))

self.println()

self.prune() # stop recursing

def n_return_if_stmt(self, node):

start = len(self.f.getvalue()) + len(self.indent)

if self.params['isLambda']:

node[0].parent = node

self.preorder(node[0])

else:

start = len(self.f.getvalue()) + len(self.indent)

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

if self.return_none or node != AST('return_stmt', [AST('ret_expr', [NONE]), Token('RETURN_END_IF')]):

self.write(' ')

self.preorder(node[0])

if hasattr(node[-1], 'offset'):

self.set_pos_info(node[-1], start, len(self.f.getvalue()))

self.println()

self.set_pos_info(node, start, len(self.f.getvalue()))

self.prune() # stop recursing

def n_yield(self, node):

start = len(self.f.getvalue())

self.write('yield')

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

self.write(' ')

node[0].parent = node

self.preorder(node[0])

self.set_pos_info(node, start, len(self.f.getvalue()))

self.prune() # stop recursing

# In Python 3.3+ only

def n_yield_from(self, node):

start = len(self.f.getvalue())

self.write('yield from')

self.write(' ')

node[0].parent = node

self.preorder(node[0])

self.set_pos_info(node, start, len(self.f.getvalue()))

self.prune() # stop recursing

def n_buildslice3(self, node):

start = len(self.f.getvalue())

p = self.prec

self.prec = 100

if node[0] != NONE:

self.preorder(node[0])

self.write(':')

if node[1] != NONE:

self.preorder(node[1])

self.write(':')

if node[2] != NONE:

self.preorder(node[2])

self.prec = p

self.set_pos_info(node, start, len(self.f.getvalue()))

self.prune() # stop recursing

def n_buildslice2(self, node):

start = len(self.f.getvalue())

p = self.prec

self.prec = 100

if node[0] != NONE:

node[0].parent = node

self.preorder(node[0])

self.write(':')

if node[1] != NONE:

node[1].parent = node

self.preorder(node[1])

self.prec = p

self.set_pos_info(node, start, len(self.f.getvalue()))

self.prune() # stop recursing

def n_expr(self, node):

start = len(self.f.getvalue())

p = self.prec

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

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

else:

n = node[0]

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

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

n.parent = node

self.set_pos_info(n, start, len(self.f.getvalue()))

self.prec = 6

if p < self.prec:

self.write('(')

node[0].parent = node

self.last_finish = len(self.f.getvalue())

self.preorder(node[0])

finish = len(self.f.getvalue())

if hasattr(node[0], 'offset'):

self.set_pos_info(node[0], start, len(self.f.getvalue()))

self.write(')')

self.last_finish = finish + 1

else:

node[0].parent = node

start = len(self.f.getvalue())

self.preorder(node[0])

if hasattr(node[0], 'offset'):

self.set_pos_info(node[0], start, len(self.f.getvalue()))

self.prec = p

self.set_pos_info(node, start, len(self.f.getvalue()))

self.prune()

def n_ret_expr(self, node):

start = len(self.f.getvalue())

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

node[0].parent = node

self.n_expr(node[0])

else:

self.n_expr(node)

self.set_pos_info(node, start, len(self.f.getvalue()))

def n_binary_expr(self, node):

start = len(self.f.getvalue())

node[0].parent = node

self.last_finish = len(self.f.getvalue())

self.preorder(node[0])

self.write(' ')

node[-1].parent = node

self.preorder(node[-1])

self.write(' ')

self.prec -= 1

node[1].parent = node

self.preorder(node[1])

self.prec += 1

self.set_pos_info(node, start, len(self.f.getvalue()))

self.prune()

def n_LOAD_CONST(self, node):

start = len(self.f.getvalue())

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

if 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 data is None:

# LOAD_CONST 'None' only occurs, when None is

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

# pass

self.write('None')

else:

self.write(repr(data))

self.set_pos_info(node, start, len(self.f.getvalue()))

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

self.prune()

def n_exec_stmt(self, node):

"""

start = len(self.f.getvalue()) + len(self.indent)

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

self.preorder(node[0])

if node[1][0] != NONE:

sep = ' in '

for subnode in node[1]:

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

self.preorder(subnode)

self.set_pos_info(node, start, len(self.f.getvalue()))

self.println()

self.prune() # stop recursing

def n_ifelsestmtr(self, node):

if len(node[2]) != 2:

self.default(node)

if not (node[2][0][0][0] == 'ifstmt' and node[2][0][0][0][1][0] == 'return_if_stmts') \

and not (node[2][0][-1][0] == 'ifstmt' and node[2][0][-1][0][1][0] == 'return_if_stmts'):

self.default(node)

return

start = len(self.f.getvalue()) + len(self.indent)

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

self.preorder(node[0])

self.println(':')

self.indentMore()

node[1].parent = node

self.preorder(node[1])

self.indentLess()

if_ret_at_end = False

if len(node[2][0]) >= 3:

node[2][0].parent = node

if node[2][0][-1][0] == 'ifstmt' and node[2][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 node[2][0]:

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

if prev_stmt_is_if_ret:

n[0].type = '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.indentMore()

past_else = True

n.parent = node

self.preorder(n)

if not past_else or if_ret_at_end:

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

self.indentMore()

node[2][1].parent = node

self.preorder(node[2][1])

self.set_pos_info(node, start, len(self.f.getvalue()))

self.indentLess()

self.prune()

def n_elifelsestmtr(self, node):

if len(node[2]) != 2:

self.default(node)

for n in node[2][0]:

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

self.default(node)

return

start = len(self.f.getvalue() + self.indent)

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

node[0].parent = node

self.preorder(node[0])

self.println(':')

self.indentMore()

node[1].parent = node

self.preorder(node[1])

self.indentLess()

for n in node[2][0]:

n[0].type = 'elifstmt'

n.parent = node

self.preorder(n)

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

self.indentMore()

node[2][1].parent = node

self.preorder(node[2][1])

self.indentLess()

self.set_pos_info(node, start, len(self.f.getvalue()))

self.prune()

def n_import_as(self, node):

start = len(self.f.getvalue())

iname = node[0].pattr

store_import_node = node[-1][-1]

assert store_import_node.type.startswith('STORE_')

sname = store_import_node.pattr

self.write(iname)

finish = len(self.f.getvalue())

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

self.set_pos_info_recurse(node, start, finish)

else:

self.write(' as ')

sname_start = len(self.f.getvalue())

self.write(sname)

finish = len(self.f.getvalue())

for n in node[-1]:

self.set_pos_info_recurse(n, sname_start, finish)

self.set_pos_info(node, start, finish)

self.prune() # stop recursing

def n_mkfunc(self, node):

start = len(self.f.getvalue())

if self.version >= 3.3 or node[-2] == 'kwargs':

# LOAD_CONST code object ..

# LOAD_CONST 'x0' if >= 3.3

# MAKE_FUNCTION ..

code_index = -3

else:

# LOAD_CONST code object ..

# MAKE_FUNCTION ..

code_index = -2

code = node[code_index]

func_name = code.attr.co_name

self.write(func_name)

self.indentMore()

self.make_function(node, isLambda=False, code=code)

self.set_pos_info(node, start, len(self.f.getvalue()))

if len(self.param_stack) > 1:

self.write('\n\n')

else:

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

self.indentLess()

self.prune() # stop recursing

def n_list_compr(self, node):

"""List comprehensions the way they are done in Python 2."""

p = self.prec

self.prec = 27

n = node[-1]

assert n == 'list_iter'

# find innermost node

while n == 'list_iter':

n = n[0] # recurse one step

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'

if node[0].type.startswith('BUILD_LIST'):

start = len(self.f.getvalue())

self.set_pos_info(node[0], start, start+1)

self.write( '[ ')

self.preorder(n[0]) # lc_body

self.preorder(node[-1]) # for/if parts

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 == 'dictcomp':

cn = node[1]

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

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'

# find innermost node

while n == 'comp_iter':

n = n[0] # recurse one step

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

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

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

assert n == 'comp_body', ast

self.preorder(n[0])

self.write(' for ')

start = len(self.f.getvalue())

designator = ast[iter_index-1]

self.preorder(designator)

self.set_pos_info(ast[iter_index-1], start, len(self.f.getvalue()))

self.write(' in ')

start = len(self.f.getvalue())

node[-3].parent = node

self.preorder(node[-3])

self.set_pos_info(node[-3], start, len(self.f.getvalue()))

start = len(self.f.getvalue())

self.preorder(ast[iter_index])

self.set_pos_info(ast[iter_index], start, len(self.f.getvalue()))

self.prec = p

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

"""

p = self.prec

self.prec = 27

code = node[code_index].attr

assert iscode(code)

code_name = code.co_name

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

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

self.customize(code._customize)

# skip over stmts sstmt smt

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

designator = None

if ast in ['setcomp_func', 'dictcomp_func']:

# Offset 0: BUILD_SET should have the span

# of '{'

self.gen_source(ast, code_name, {})

for k in ast:

if k == 'comp_iter':

n = k

elif k == 'designator':

designator = k

pass

pass

pass

else:

ast = ast[0][0]

n = ast[iter_index]

assert n == 'list_iter'

# FIXME: I'm not totally sure this is right.

# find innermost node

if_node = None

comp_for = None

comp_designator = None

if n == 'comp_iter':

comp_for = n

comp_designator = ast[3]

have_not = False

while n in ('list_iter', 'comp_iter'):

n = n[0] # recurse one step

if n == 'list_for':

if n[2] == 'designator':

designator = n[2]

n = n[3]

elif n in ['list_if', 'list_if_not', 'comp_if']:

have_not = n in ('list_if_not', 'comp_ifnot')

if_node = n[0]

if n[1] == 'designator':

designator = n[1]

n = n[2]

pass

pass

# Python 2.7+ starts including set_comp_body

# Python 3.5+ starts including setcomp_func

assert n.type in ('lc_body', 'comp_body', 'setcomp_func', 'set_comp_body'), ast

assert designator, "Couldn't find designator in list/set comprehension"

old_name = self.name

self.name = code_name

self.preorder(n[0])

gen_start = len(self.f.getvalue()) + 1

self.write(' for ')

start = len(self.f.getvalue())

self.preorder(designator)

self.set_pos_info(designator, start, len(self.f.getvalue()))

self.write(' in ')

start = len(self.f.getvalue())

node[-3].parent = node

self.preorder(node[-3])

fin = len(self.f.getvalue())

self.set_pos_info(node[-3], start, fin, old_name)

if comp_designator:

self.preorder(comp_for)

elif if_node:

self.write(' if ')

if have_not:

self.write('not ')

self.preorder(if_node)

self.prec = p

self.name = old_name

if node[-1].type.startswith('CALL_FUNCTION'):

self.set_pos_info(node[-1], gen_start, len(self.f.getvalue()))

def listcomprehension_walk2(self, node):

"""List comprehensions the way they are done in Python3.

p = self.prec

self.prec = 27

code = Code(node[1].attr, self.scanner, self.currentclass)

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

self.customize(code._customize)

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

n = ast[1]

collection = node[-3]

list_if = None

assert n == 'list_iter'

# find innermost node

while n == 'list_iter':

n = n[0] # recurse one step

if n == 'list_for':

designator = n[2]

n = n[3]

elif n in ('list_if', 'list_if_not'):

# FIXME: just a guess

if n[0].type == 'expr':

list_if = n

else:

list_if = n[1]

n = n[2]

pass

pass

assert n == 'lc_body', ast

self.preorder(n[0])

self.write(' for ')

start = len(self.f.getvalue())

self.preorder(designator)

self.set_pos_info(designator, start, len(self.f.getvalue()))

self.write(' in ')

start = len(self.f.getvalue())

node[-3].parent = node

self.preorder(collection)

self.set_pos_info(collection, start, len(self.f.getvalue()))

if list_if:

start = len(self.f.getvalue())

self.preorder(list_if)

self.set_pos_info(list_if, start, len(self.f.getvalue()))

self.prec = p

def n_genexpr(self, node):

start = len(self.f.getvalue())

self.write('(')

code_index = -6 if self.version > 3.2 else -5

self.comprehension_walk(node, iter_index=3, code_index=code_index)

self.write(')')

self.set_pos_info(node, start, len(self.f.getvalue()))

self.prune()

def n_setcomp(self, node):

start = len(self.f.getvalue())

self.write('{')

if node[0] in ['LOAD_SETCOMP', 'LOAD_DICTCOMP']:

start = len(self.f.getvalue())

self.set_pos_info(node[0], start-1, start)

self.comprehension_walk3(node, 1, 0)

elif node[0].type == 'load_closure':

self.setcomprehension_walk3(node, collection_index=4)

else:

self.comprehension_walk(node, iter_index=4)

self.write('}')

self.set_pos_info(node, start, len(self.f.getvalue()))

self.prune()

# FIXME: Not sure if below is general. Also, add dictcomp_func.

# 'setcomp_func': ("%|lambda %c: {%c for %c in %c%c}\n", 1, 3, 3, 1, 4)

def n_setcomp_func(self, node):

setcomp_start = len(self.f.getvalue())

self.write(self.indent, "lambda ")

param_node = node[1]

start = len(self.f.getvalue())

self.preorder(param_node)

self.set_pos_info(node[0], start, len(self.f.getvalue()))

self.write(': {')

start = len(self.f.getvalue())

assert node[0].type.startswith('BUILD_SET')

self.set_pos_info(node[0], start-1, start)

designator = node[3]

assert designator == 'designator'

start = len(self.f.getvalue())

self.preorder(designator)

fin = len(self.f.getvalue())

self.set_pos_info(designator, start, fin)

for_iter_node = node[2]

assert for_iter_node.type == 'FOR_ITER'

self.set_pos_info(for_iter_node, start, fin)

self.write(" for ")

self.preorder(designator)

self.write(" in ")

self.preorder(param_node)

start = len(self.f.getvalue())

self.preorder(node[4])

self.set_pos_info(node[4], start, len(self.f.getvalue()))

self.write("}")

fin = len(self.f.getvalue())

self.set_pos_info(node, setcomp_start, fin)

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

self.set_pos_info(node[-2], setcomp_start, fin)

self.prune()

def n_listcomp(self, node):

self.write('[')

if node[0].type == 'load_closure':

self.listcomprehension_walk2(node)

else:

if node[0] == 'LOAD_LISTCOMP':

start = len(self.f.getvalue())

self.set_pos_info(node[0], start-1, start)

self.comprehension_walk3(node, 1, 0)

self.write(']')

self.prune()

def n__ifstmts_jump_exit(self, node):

if len(node) > 1:

if (node[0] == 'c_stmts_opt' and

node[0][0] == 'passstmt' and

node[1].type.startswith('JUMP_FORWARD')):

self.set_pos_info(node[1], node[0][0].start, node[0][0].finish)

def setcomprehension_walk3(self, node, collection_index):

"""List comprehensions the way they are done in Python3.

p = self.prec

self.prec = 27

code = Code(node[1].attr, self.scanner, self.currentclass)

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

self.customize(code._customize)

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

designator = ast[3]

collection = node[collection_index]

n = ast[4]

list_if = None

assert n == 'comp_iter'

# find innermost node

while n == 'comp_iter':

n = n[0] # recurse one step

# FIXME: adjust for set comprehension

if n == 'list_for':

designator = n[2]

n = n[3]

elif n in ('list_if', 'list_if_not', 'comp_if', 'comp_if_not'):

# FIXME: just a guess

if n[0].type == 'expr':

list_if = n

else:

list_if = n[1]

n = n[2]

pass

pass

assert n == 'comp_body', ast

self.preorder(n[0])

self.write(' for ')

start = len(self.f.getvalue())

self.preorder(designator)

self.set_pos_info(designator, start, len(self.f.getvalue()))

self.write(' in ')

start = len(self.f.getvalue())

self.preorder(collection)

self.set_pos_info(collection, start, len(self.f.getvalue()))

if list_if:

start = len(self.f.getvalue())

self.preorder(list_if)

self.set_pos_info(list_if, start, len(self.f.getvalue()))

self.prec = p

def n_classdef(self, node):

# class definition ('class X(A,B,C):')

cclass = self.currentclass

if self.version > 3.0:

if node == 'classdefdeco2':

currentclass = node[1][2].pattr

buildclass = node

else:

currentclass = node[1][0].pattr

buildclass = node[0]

if buildclass[0] == 'LOAD_BUILD_CLASS':

start = len(self.f.getvalue())

self.set_pos_info(buildclass[0], start, start + len('class')+2)

assert 'mkfunc' == buildclass[1]

mkfunc = buildclass[1]

if mkfunc[0] == 'kwargs':

for n in mkfunc:

if hasattr(n, 'attr') and iscode(n.attr):

subclass = n.attr

break

pass

subclass_info = node if node == 'classdefdeco2' else node[0]

elif buildclass[1][0] == 'load_closure':

# Python 3 with closures not functions

load_closure = buildclass[1]

if hasattr(load_closure[-3], 'attr'):

# Python 3.3 classes with closures work like this.

# Note have to test before 3.2 case because

# index -2 also has an attr.

subclass = load_closure[-3].attr

elif hasattr(load_closure[-2], 'attr'):

# Python 3.2 works like this

subclass = load_closure[-2].attr

else:

raise 'Internal Error n_classdef: cannot find class body'

if hasattr(buildclass[3], '__len__'):

subclass_info = buildclass[3]

elif hasattr(buildclass[2], '__len__'):

subclass_info = buildclass[2]

else:

raise 'Internal Error n_classdef: cannot superclass name'

else:

subclass = buildclass[1][0].attr

subclass_info = node[0]

else:

buildclass = node if (node == 'classdefdeco2') else node[0]

build_list = buildclass[1][0]

if hasattr(buildclass[-3][0], 'attr'):

subclass = buildclass[-3][0].attr

currentclass = buildclass[0].pattr

elif hasattr(node[0][0], 'pattr'):

subclass = buildclass[-3][1].attr

currentclass = node[0][0].pattr

else:

raise 'Internal Error n_classdef: cannot find class name'

if (node == 'classdefdeco2'):

self.write('\n')

else:

self.write('\n\n')

self.currentclass = str(currentclass)

start = len(self.f.getvalue())

self.write(self.indent, 'class ', self.currentclass)

if self.version > 3.0:

self.print_super_classes3(subclass_info)

else:

self.print_super_classes(build_list)

self.println(':')

# class body

self.indentMore()

self.build_class(subclass)

self.indentLess()

self.currentclass = cclass

self.set_pos_info(node, start, len(self.f.getvalue()))

if len(self.param_stack) > 1:

self.write('\n\n')

else:

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

self.prune()

n_classdefdeco2 = n_classdef

def gen_source(self, ast, name, customize, isLambda=False, returnNone=False):

"""convert AST to Python source code"""

rn = self.return_none

self.return_none = returnNone

old_name = self.name