home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_328 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  41.0 KB  |  1,399 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from compiler.ast import *
  5. import parser
  6. import symbol
  7. import token
  8.  
  9. class WalkerError(StandardError):
  10.     pass
  11.  
  12. from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
  13. from compiler.consts import OP_ASSIGN, OP_DELETE, OP_APPLY
  14.  
  15. def parseFile(path):
  16.     f = open(path, 'U')
  17.     src = f.read() + '\n'
  18.     f.close()
  19.     return parse(src)
  20.  
  21.  
  22. def parse(buf, mode = 'exec'):
  23.     if mode == 'exec' or mode == 'single':
  24.         return Transformer().parsesuite(buf)
  25.     if mode == 'eval':
  26.         return Transformer().parseexpr(buf)
  27.     raise ValueError("compile() arg 3 must be 'exec' or 'eval' or 'single'")
  28.  
  29.  
  30. def asList(nodes):
  31.     l = []
  32.     for item in nodes:
  33.         if hasattr(item, 'asList'):
  34.             l.append(item.asList())
  35.             continue
  36.         if type(item) is type((None, None)):
  37.             l.append(tuple(asList(item)))
  38.             continue
  39.         if type(item) is type([]):
  40.             l.append(asList(item))
  41.             continue
  42.         l.append(item)
  43.     
  44.     return l
  45.  
  46.  
  47. def extractLineNo(ast):
  48.     if not isinstance(ast[1], tuple):
  49.         return ast[2]
  50.     for child in ast[1:]:
  51.         if isinstance(child, tuple):
  52.             lineno = extractLineNo(child)
  53.             if lineno is not None:
  54.                 return lineno
  55.             continue
  56.         lineno is not None
  57.     
  58.  
  59.  
  60. def Node(*args):
  61.     kind = args[0]
  62.     if kind in nodes:
  63.         
  64.         try:
  65.             return nodes[kind](*args[1:])
  66.         except TypeError:
  67.             print nodes[kind], len(args), args
  68.             raise 
  69.         except:
  70.             None<EXCEPTION MATCH>TypeError
  71.         
  72.  
  73.     None<EXCEPTION MATCH>TypeError
  74.     raise WalkerError, "Can't find appropriate Node type: %s" % str(args)
  75.  
  76.  
  77. class Transformer:
  78.     
  79.     def __init__(self):
  80.         self._dispatch = { }
  81.         for value, name in symbol.sym_name.items():
  82.             if hasattr(self, name):
  83.                 self._dispatch[value] = getattr(self, name)
  84.                 continue
  85.         
  86.         self._dispatch[token.NEWLINE] = self.com_NEWLINE
  87.         self._atom_dispatch = {
  88.             token.LPAR: self.atom_lpar,
  89.             token.LSQB: self.atom_lsqb,
  90.             token.LBRACE: self.atom_lbrace,
  91.             token.BACKQUOTE: self.atom_backquote,
  92.             token.NUMBER: self.atom_number,
  93.             token.STRING: self.atom_string,
  94.             token.NAME: self.atom_name }
  95.         self.encoding = None
  96.  
  97.     
  98.     def transform(self, tree):
  99.         if not isinstance(tree, tuple) or isinstance(tree, list):
  100.             tree = parser.st2tuple(tree, line_info = 1)
  101.         
  102.         return self.compile_node(tree)
  103.  
  104.     
  105.     def parsesuite(self, text):
  106.         return self.transform(parser.suite(text))
  107.  
  108.     
  109.     def parseexpr(self, text):
  110.         return self.transform(parser.expr(text))
  111.  
  112.     
  113.     def parsefile(self, file):
  114.         if type(file) == type(''):
  115.             file = open(file)
  116.         
  117.         return self.parsesuite(file.read())
  118.  
  119.     
  120.     def compile_node(self, node):
  121.         n = node[0]
  122.         if n == symbol.encoding_decl:
  123.             self.encoding = node[2]
  124.             node = node[1]
  125.             n = node[0]
  126.         
  127.         if n == symbol.single_input:
  128.             return self.single_input(node[1:])
  129.         if n == symbol.file_input:
  130.             return self.file_input(node[1:])
  131.         if n == symbol.eval_input:
  132.             return self.eval_input(node[1:])
  133.         if n == symbol.lambdef:
  134.             return self.lambdef(node[1:])
  135.         if n == symbol.funcdef:
  136.             return self.funcdef(node[1:])
  137.         if n == symbol.classdef:
  138.             return self.classdef(node[1:])
  139.         raise WalkerError, ('unexpected node type', n)
  140.  
  141.     
  142.     def single_input(self, node):
  143.         n = node[0][0]
  144.         if n != token.NEWLINE:
  145.             return self.com_stmt(node[0])
  146.         return Pass()
  147.  
  148.     
  149.     def file_input(self, nodelist):
  150.         doc = self.get_docstring(nodelist, symbol.file_input)
  151.         if doc is not None:
  152.             i = 1
  153.         else:
  154.             i = 0
  155.         stmts = []
  156.         for node in nodelist[i:]:
  157.             if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:
  158.                 self.com_append_stmt(stmts, node)
  159.                 continue
  160.         
  161.         return Module(doc, Stmt(stmts))
  162.  
  163.     
  164.     def eval_input(self, nodelist):
  165.         return Expression(self.com_node(nodelist[0]))
  166.  
  167.     
  168.     def decorator_name(self, nodelist):
  169.         listlen = len(nodelist)
  170.         item = self.atom_name(nodelist)
  171.         i = 1
  172.         while i < listlen:
  173.             item = Getattr(item, nodelist[i + 1][1])
  174.             i += 2
  175.         return item
  176.  
  177.     
  178.     def decorator(self, nodelist):
  179.         funcname = self.decorator_name(nodelist[1][1:])
  180.         if len(nodelist) > 3:
  181.             expr = self.com_call_function(funcname, nodelist[3])
  182.         else:
  183.             expr = funcname
  184.         return expr
  185.  
  186.     
  187.     def decorators(self, nodelist):
  188.         items = []
  189.         for dec_nodelist in nodelist:
  190.             items.append(self.decorator(dec_nodelist[1:]))
  191.         
  192.         return Decorators(items)
  193.  
  194.     
  195.     def decorated(self, nodelist):
  196.         if nodelist[1][0] == symbol.funcdef:
  197.             n = [
  198.                 nodelist[0]] + list(nodelist[1][1:])
  199.             return self.funcdef(n)
  200.         if nodelist[1][0] == symbol.classdef:
  201.             decorators = self.decorators(nodelist[0][1:])
  202.             cls = self.classdef(nodelist[1][1:])
  203.             cls.decorators = decorators
  204.             return cls
  205.         raise WalkerError()
  206.  
  207.     
  208.     def funcdef(self, nodelist):
  209.         if len(nodelist) == 6:
  210.             decorators = self.decorators(nodelist[0][1:])
  211.         else:
  212.             decorators = None
  213.         lineno = nodelist[-4][2]
  214.         name = nodelist[-4][1]
  215.         args = nodelist[-3][2]
  216.         if args[0] == symbol.varargslist:
  217.             (names, defaults, flags) = self.com_arglist(args[1:])
  218.         else:
  219.             names = defaults = ()
  220.             flags = 0
  221.         doc = self.get_docstring(nodelist[-1])
  222.         code = self.com_node(nodelist[-1])
  223.         if doc is not None:
  224.             del code.nodes[0]
  225.         
  226.         return Function(decorators, name, names, defaults, flags, doc, code, lineno = lineno)
  227.  
  228.     
  229.     def lambdef(self, nodelist):
  230.         if nodelist[2][0] == symbol.varargslist:
  231.             (names, defaults, flags) = self.com_arglist(nodelist[2][1:])
  232.         else:
  233.             names = defaults = ()
  234.             flags = 0
  235.         code = self.com_node(nodelist[-1])
  236.         return Lambda(names, defaults, flags, code, lineno = nodelist[1][2])
  237.  
  238.     old_lambdef = lambdef
  239.     
  240.     def classdef(self, nodelist):
  241.         name = nodelist[1][1]
  242.         doc = self.get_docstring(nodelist[-1])
  243.         if nodelist[2][0] == token.COLON:
  244.             bases = []
  245.         elif nodelist[3][0] == token.RPAR:
  246.             bases = []
  247.         else:
  248.             bases = self.com_bases(nodelist[3])
  249.         code = self.com_node(nodelist[-1])
  250.         if doc is not None:
  251.             del code.nodes[0]
  252.         
  253.         return Class(name, bases, doc, code, lineno = nodelist[1][2])
  254.  
  255.     
  256.     def stmt(self, nodelist):
  257.         return self.com_stmt(nodelist[0])
  258.  
  259.     small_stmt = stmt
  260.     flow_stmt = stmt
  261.     compound_stmt = stmt
  262.     
  263.     def simple_stmt(self, nodelist):
  264.         stmts = []
  265.         for i in range(0, len(nodelist), 2):
  266.             self.com_append_stmt(stmts, nodelist[i])
  267.         
  268.         return Stmt(stmts)
  269.  
  270.     
  271.     def parameters(self, nodelist):
  272.         raise WalkerError
  273.  
  274.     
  275.     def varargslist(self, nodelist):
  276.         raise WalkerError
  277.  
  278.     
  279.     def fpdef(self, nodelist):
  280.         raise WalkerError
  281.  
  282.     
  283.     def fplist(self, nodelist):
  284.         raise WalkerError
  285.  
  286.     
  287.     def dotted_name(self, nodelist):
  288.         raise WalkerError
  289.  
  290.     
  291.     def comp_op(self, nodelist):
  292.         raise WalkerError
  293.  
  294.     
  295.     def trailer(self, nodelist):
  296.         raise WalkerError
  297.  
  298.     
  299.     def sliceop(self, nodelist):
  300.         raise WalkerError
  301.  
  302.     
  303.     def argument(self, nodelist):
  304.         raise WalkerError
  305.  
  306.     
  307.     def expr_stmt(self, nodelist):
  308.         en = nodelist[-1]
  309.         exprNode = self.lookup_node(en)(en[1:])
  310.         if len(nodelist) == 1:
  311.             return Discard(exprNode, lineno = exprNode.lineno)
  312.         if nodelist[1][0] == token.EQUAL:
  313.             nodesl = []
  314.             for i in range(0, len(nodelist) - 2, 2):
  315.                 nodesl.append(self.com_assign(nodelist[i], OP_ASSIGN))
  316.             
  317.             return Assign(nodesl, exprNode, lineno = nodelist[1][2])
  318.         lval = self.com_augassign(nodelist[0])
  319.         op = self.com_augassign_op(nodelist[1])
  320.         return AugAssign(lval, op[1], exprNode, lineno = op[2])
  321.         raise WalkerError, "can't get here"
  322.  
  323.     
  324.     def print_stmt(self, nodelist):
  325.         items = []
  326.         if len(nodelist) == 1:
  327.             start = 1
  328.             dest = None
  329.         elif nodelist[1][0] == token.RIGHTSHIFT:
  330.             dest = self.com_node(nodelist[2])
  331.             start = 4
  332.         else:
  333.             dest = None
  334.             start = 1
  335.         for i in range(start, len(nodelist), 2):
  336.             items.append(self.com_node(nodelist[i]))
  337.         
  338.         if nodelist[-1][0] == token.COMMA:
  339.             return Print(items, dest, lineno = nodelist[0][2])
  340.         return Printnl(items, dest, lineno = nodelist[0][2])
  341.  
  342.     
  343.     def del_stmt(self, nodelist):
  344.         return self.com_assign(nodelist[1], OP_DELETE)
  345.  
  346.     
  347.     def pass_stmt(self, nodelist):
  348.         return Pass(lineno = nodelist[0][2])
  349.  
  350.     
  351.     def break_stmt(self, nodelist):
  352.         return Break(lineno = nodelist[0][2])
  353.  
  354.     
  355.     def continue_stmt(self, nodelist):
  356.         return Continue(lineno = nodelist[0][2])
  357.  
  358.     
  359.     def return_stmt(self, nodelist):
  360.         if len(nodelist) < 2:
  361.             return Return(Const(None), lineno = nodelist[0][2])
  362.         return Return(self.com_node(nodelist[1]), lineno = nodelist[0][2])
  363.  
  364.     
  365.     def yield_stmt(self, nodelist):
  366.         expr = self.com_node(nodelist[0])
  367.         return Discard(expr, lineno = expr.lineno)
  368.  
  369.     
  370.     def yield_expr(self, nodelist):
  371.         if len(nodelist) > 1:
  372.             value = self.com_node(nodelist[1])
  373.         else:
  374.             value = Const(None)
  375.         return Yield(value, lineno = nodelist[0][2])
  376.  
  377.     
  378.     def raise_stmt(self, nodelist):
  379.         if len(nodelist) > 5:
  380.             expr3 = self.com_node(nodelist[5])
  381.         else:
  382.             expr3 = None
  383.         if len(nodelist) > 3:
  384.             expr2 = self.com_node(nodelist[3])
  385.         else:
  386.             expr2 = None
  387.         if len(nodelist) > 1:
  388.             expr1 = self.com_node(nodelist[1])
  389.         else:
  390.             expr1 = None
  391.         return Raise(expr1, expr2, expr3, lineno = nodelist[0][2])
  392.  
  393.     
  394.     def import_stmt(self, nodelist):
  395.         return self.com_node(nodelist[0])
  396.  
  397.     
  398.     def import_name(self, nodelist):
  399.         return Import(self.com_dotted_as_names(nodelist[1]), lineno = nodelist[0][2])
  400.  
  401.     
  402.     def import_from(self, nodelist):
  403.         idx = 1
  404.         while nodelist[idx][1] == '.':
  405.             idx += 1
  406.         level = idx - 1
  407.         if nodelist[idx][0] == symbol.dotted_name:
  408.             fromname = self.com_dotted_name(nodelist[idx])
  409.             idx += 1
  410.         else:
  411.             fromname = ''
  412.         if nodelist[idx + 1][0] == token.STAR:
  413.             return From(fromname, [
  414.                 ('*', None)], level, lineno = nodelist[0][2])
  415.         node = nodelist[idx + 1 + (nodelist[idx + 1][0] == token.LPAR)]
  416.         return From(fromname, self.com_import_as_names(node), level, lineno = nodelist[0][2])
  417.  
  418.     
  419.     def global_stmt(self, nodelist):
  420.         names = []
  421.         for i in range(1, len(nodelist), 2):
  422.             names.append(nodelist[i][1])
  423.         
  424.         return Global(names, lineno = nodelist[0][2])
  425.  
  426.     
  427.     def exec_stmt(self, nodelist):
  428.         expr1 = self.com_node(nodelist[1])
  429.         if len(nodelist) >= 4:
  430.             expr2 = self.com_node(nodelist[3])
  431.             if len(nodelist) >= 6:
  432.                 expr3 = self.com_node(nodelist[5])
  433.             else:
  434.                 expr3 = None
  435.         else:
  436.             expr2 = None
  437.             expr3 = None
  438.         return Exec(expr1, expr2, expr3, lineno = nodelist[0][2])
  439.  
  440.     
  441.     def assert_stmt(self, nodelist):
  442.         expr1 = self.com_node(nodelist[1])
  443.         if len(nodelist) == 4:
  444.             expr2 = self.com_node(nodelist[3])
  445.         else:
  446.             expr2 = None
  447.         return Assert(expr1, expr2, lineno = nodelist[0][2])
  448.  
  449.     
  450.     def if_stmt(self, nodelist):
  451.         tests = []
  452.         for i in range(0, len(nodelist) - 3, 4):
  453.             testNode = self.com_node(nodelist[i + 1])
  454.             suiteNode = self.com_node(nodelist[i + 3])
  455.             tests.append((testNode, suiteNode))
  456.         
  457.         if len(nodelist) % 4 == 3:
  458.             elseNode = self.com_node(nodelist[-1])
  459.         else:
  460.             elseNode = None
  461.         return If(tests, elseNode, lineno = nodelist[0][2])
  462.  
  463.     
  464.     def while_stmt(self, nodelist):
  465.         testNode = self.com_node(nodelist[1])
  466.         bodyNode = self.com_node(nodelist[3])
  467.         if len(nodelist) > 4:
  468.             elseNode = self.com_node(nodelist[6])
  469.         else:
  470.             elseNode = None
  471.         return While(testNode, bodyNode, elseNode, lineno = nodelist[0][2])
  472.  
  473.     
  474.     def for_stmt(self, nodelist):
  475.         assignNode = self.com_assign(nodelist[1], OP_ASSIGN)
  476.         listNode = self.com_node(nodelist[3])
  477.         bodyNode = self.com_node(nodelist[5])
  478.         if len(nodelist) > 8:
  479.             elseNode = self.com_node(nodelist[8])
  480.         else:
  481.             elseNode = None
  482.         return For(assignNode, listNode, bodyNode, elseNode, lineno = nodelist[0][2])
  483.  
  484.     
  485.     def try_stmt(self, nodelist):
  486.         return self.com_try_except_finally(nodelist)
  487.  
  488.     
  489.     def with_stmt(self, nodelist):
  490.         return self.com_with(nodelist)
  491.  
  492.     
  493.     def with_var(self, nodelist):
  494.         return self.com_with_var(nodelist)
  495.  
  496.     
  497.     def suite(self, nodelist):
  498.         if len(nodelist) == 1:
  499.             return self.com_stmt(nodelist[0])
  500.         stmts = []
  501.         for node in nodelist:
  502.             if node[0] == symbol.stmt:
  503.                 self.com_append_stmt(stmts, node)
  504.                 continue
  505.             len(nodelist) == 1
  506.         
  507.         return Stmt(stmts)
  508.  
  509.     
  510.     def testlist(self, nodelist):
  511.         return self.com_binary(Tuple, nodelist)
  512.  
  513.     testlist_safe = testlist
  514.     testlist1 = testlist
  515.     exprlist = testlist
  516.     
  517.     def testlist_gexp(self, nodelist):
  518.         if len(nodelist) == 2 and nodelist[1][0] == symbol.gen_for:
  519.             test = self.com_node(nodelist[0])
  520.             return self.com_generator_expression(test, nodelist[1])
  521.         return self.testlist(nodelist)
  522.  
  523.     
  524.     def test(self, nodelist):
  525.         if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
  526.             return self.lambdef(nodelist[0])
  527.         then = self.com_node(nodelist[0])
  528.         if len(nodelist) > 1:
  529.             test = self.com_node(nodelist[2])
  530.             else_ = self.com_node(nodelist[4])
  531.             return IfExp(test, then, else_, lineno = nodelist[1][2])
  532.         return then
  533.  
  534.     
  535.     def or_test(self, nodelist):
  536.         if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
  537.             return self.lambdef(nodelist[0])
  538.         return self.com_binary(Or, nodelist)
  539.  
  540.     old_test = or_test
  541.     
  542.     def and_test(self, nodelist):
  543.         return self.com_binary(And, nodelist)
  544.  
  545.     
  546.     def not_test(self, nodelist):
  547.         result = self.com_node(nodelist[-1])
  548.         if len(nodelist) == 2:
  549.             return Not(result, lineno = nodelist[0][2])
  550.         return result
  551.  
  552.     
  553.     def comparison(self, nodelist):
  554.         node = self.com_node(nodelist[0])
  555.         if len(nodelist) == 1:
  556.             return node
  557.         results = []
  558.         for i in range(2, len(nodelist), 2):
  559.             nl = nodelist[i - 1]
  560.             n = nl[1]
  561.             if n[0] == token.NAME:
  562.                 type = n[1]
  563.                 if len(nl) == 3:
  564.                     if type == 'not':
  565.                         type = 'not in'
  566.                     else:
  567.                         type = 'is not'
  568.                 
  569.             else:
  570.                 type = _cmp_types[n[0]]
  571.             lineno = nl[1][2]
  572.             results.append((type, self.com_node(nodelist[i])))
  573.         
  574.         return Compare(node, results, lineno = lineno)
  575.  
  576.     
  577.     def expr(self, nodelist):
  578.         return self.com_binary(Bitor, nodelist)
  579.  
  580.     
  581.     def xor_expr(self, nodelist):
  582.         return self.com_binary(Bitxor, nodelist)
  583.  
  584.     
  585.     def and_expr(self, nodelist):
  586.         return self.com_binary(Bitand, nodelist)
  587.  
  588.     
  589.     def shift_expr(self, nodelist):
  590.         node = self.com_node(nodelist[0])
  591.         for i in range(2, len(nodelist), 2):
  592.             right = self.com_node(nodelist[i])
  593.             if nodelist[i - 1][0] == token.LEFTSHIFT:
  594.                 node = LeftShift([
  595.                     node,
  596.                     right], lineno = nodelist[1][2])
  597.                 continue
  598.             if nodelist[i - 1][0] == token.RIGHTSHIFT:
  599.                 node = RightShift([
  600.                     node,
  601.                     right], lineno = nodelist[1][2])
  602.                 continue
  603.             raise ValueError, 'unexpected token: %s' % nodelist[i - 1][0]
  604.         
  605.         return node
  606.  
  607.     
  608.     def arith_expr(self, nodelist):
  609.         node = self.com_node(nodelist[0])
  610.         for i in range(2, len(nodelist), 2):
  611.             right = self.com_node(nodelist[i])
  612.             if nodelist[i - 1][0] == token.PLUS:
  613.                 node = Add([
  614.                     node,
  615.                     right], lineno = nodelist[1][2])
  616.                 continue
  617.             if nodelist[i - 1][0] == token.MINUS:
  618.                 node = Sub([
  619.                     node,
  620.                     right], lineno = nodelist[1][2])
  621.                 continue
  622.             raise ValueError, 'unexpected token: %s' % nodelist[i - 1][0]
  623.         
  624.         return node
  625.  
  626.     
  627.     def term(self, nodelist):
  628.         node = self.com_node(nodelist[0])
  629.         for i in range(2, len(nodelist), 2):
  630.             right = self.com_node(nodelist[i])
  631.             t = nodelist[i - 1][0]
  632.             if t == token.STAR:
  633.                 node = Mul([
  634.                     node,
  635.                     right])
  636.             elif t == token.SLASH:
  637.                 node = Div([
  638.                     node,
  639.                     right])
  640.             elif t == token.PERCENT:
  641.                 node = Mod([
  642.                     node,
  643.                     right])
  644.             elif t == token.DOUBLESLASH:
  645.                 node = FloorDiv([
  646.                     node,
  647.                     right])
  648.             else:
  649.                 raise ValueError, 'unexpected token: %s' % t
  650.             node.lineno = t == token.STAR[1][2]
  651.         
  652.         return node
  653.  
  654.     
  655.     def factor(self, nodelist):
  656.         elt = nodelist[0]
  657.         t = elt[0]
  658.         node = self.lookup_node(nodelist[-1])(nodelist[-1][1:])
  659.         if t == token.PLUS:
  660.             return UnaryAdd(node, lineno = elt[2])
  661.         if t == token.MINUS:
  662.             return UnarySub(node, lineno = elt[2])
  663.         return node
  664.  
  665.     
  666.     def power(self, nodelist):
  667.         node = self.com_node(nodelist[0])
  668.         for i in range(1, len(nodelist)):
  669.             elt = nodelist[i]
  670.             if elt[0] == token.DOUBLESTAR:
  671.                 return Power([
  672.                     node,
  673.                     self.com_node(nodelist[i + 1])], lineno = elt[2])
  674.             node = self.com_apply_trailer(node, elt)
  675.         
  676.         return node
  677.  
  678.     
  679.     def atom(self, nodelist):
  680.         return self._atom_dispatch[nodelist[0][0]](nodelist)
  681.  
  682.     
  683.     def atom_lpar(self, nodelist):
  684.         if nodelist[1][0] == token.RPAR:
  685.             return Tuple((), lineno = nodelist[0][2])
  686.         return self.com_node(nodelist[1])
  687.  
  688.     
  689.     def atom_lsqb(self, nodelist):
  690.         if nodelist[1][0] == token.RSQB:
  691.             return List((), lineno = nodelist[0][2])
  692.         return self.com_list_constructor(nodelist[1])
  693.  
  694.     
  695.     def atom_lbrace(self, nodelist):
  696.         if nodelist[1][0] == token.RBRACE:
  697.             return Dict((), lineno = nodelist[0][2])
  698.         return self.com_dictmaker(nodelist[1])
  699.  
  700.     
  701.     def atom_backquote(self, nodelist):
  702.         return Backquote(self.com_node(nodelist[1]))
  703.  
  704.     
  705.     def atom_number(self, nodelist):
  706.         k = eval(nodelist[0][1])
  707.         return Const(k, lineno = nodelist[0][2])
  708.  
  709.     
  710.     def decode_literal(self, lit):
  711.         if self.encoding:
  712.             if self.encoding not in ('utf-8', 'iso-8859-1'):
  713.                 lit = unicode(lit, 'utf-8').encode(self.encoding)
  714.             
  715.             return eval('# coding: %s\n%s' % (self.encoding, lit))
  716.         return eval(lit)
  717.  
  718.     
  719.     def atom_string(self, nodelist):
  720.         k = ''
  721.         for node in nodelist:
  722.             k += self.decode_literal(node[1])
  723.         
  724.         return Const(k, lineno = nodelist[0][2])
  725.  
  726.     
  727.     def atom_name(self, nodelist):
  728.         return Name(nodelist[0][1], lineno = nodelist[0][2])
  729.  
  730.     
  731.     def lookup_node(self, node):
  732.         return self._dispatch[node[0]]
  733.  
  734.     
  735.     def com_node(self, node):
  736.         return self._dispatch[node[0]](node[1:])
  737.  
  738.     
  739.     def com_NEWLINE(self, *args):
  740.         return Discard(Const(None))
  741.  
  742.     
  743.     def com_arglist(self, nodelist):
  744.         names = []
  745.         defaults = []
  746.         flags = 0
  747.         i = 0
  748.         while i < len(nodelist):
  749.             node = nodelist[i]
  750.             if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
  751.                 if node[0] == token.STAR:
  752.                     node = nodelist[i + 1]
  753.                     if node[0] == token.NAME:
  754.                         names.append(node[1])
  755.                         flags = flags | CO_VARARGS
  756.                         i = i + 3
  757.                     
  758.                 
  759.                 if i < len(nodelist):
  760.                     t = nodelist[i][0]
  761.                     if t == token.DOUBLESTAR:
  762.                         node = nodelist[i + 1]
  763.                     else:
  764.                         raise ValueError, 'unexpected token: %s' % t
  765.                     (t == token.DOUBLESTAR).append(node[1])
  766.                     flags = flags | CO_VARKEYWORDS
  767.                 
  768.                 break
  769.             
  770.             names.append(self.com_fpdef(node))
  771.             i = i + 1
  772.             if i < len(nodelist) and nodelist[i][0] == token.EQUAL:
  773.                 defaults.append(self.com_node(nodelist[i + 1]))
  774.                 i = i + 2
  775.             elif len(defaults):
  776.                 raise SyntaxError, 'non-default argument follows default argument'
  777.             
  778.             i = i + 1
  779.         return (names, defaults, flags)
  780.  
  781.     
  782.     def com_fpdef(self, node):
  783.         if node[1][0] == token.LPAR:
  784.             return self.com_fplist(node[2])
  785.         return node[1][1]
  786.  
  787.     
  788.     def com_fplist(self, node):
  789.         if len(node) == 2:
  790.             return self.com_fpdef(node[1])
  791.         list = []
  792.         for i in range(1, len(node), 2):
  793.             list.append(self.com_fpdef(node[i]))
  794.         
  795.         return tuple(list)
  796.  
  797.     
  798.     def com_dotted_name(self, node):
  799.         name = ''
  800.         for n in node:
  801.             if type(n) == type(()) and n[0] == 1:
  802.                 name = name + n[1] + '.'
  803.                 continue
  804.         
  805.         return name[:-1]
  806.  
  807.     
  808.     def com_dotted_as_name(self, node):
  809.         node = node[1:]
  810.         dot = self.com_dotted_name(node[0][1:])
  811.         if len(node) == 1:
  812.             return (dot, None)
  813.         return (dot, node[2][1])
  814.  
  815.     
  816.     def com_dotted_as_names(self, node):
  817.         node = node[1:]
  818.         names = [
  819.             self.com_dotted_as_name(node[0])]
  820.         for i in range(2, len(node), 2):
  821.             names.append(self.com_dotted_as_name(node[i]))
  822.         
  823.         return names
  824.  
  825.     
  826.     def com_import_as_name(self, node):
  827.         node = node[1:]
  828.         if len(node) == 1:
  829.             return (node[0][1], None)
  830.         return (node[0][1], node[2][1])
  831.  
  832.     
  833.     def com_import_as_names(self, node):
  834.         node = node[1:]
  835.         names = [
  836.             self.com_import_as_name(node[0])]
  837.         for i in range(2, len(node), 2):
  838.             names.append(self.com_import_as_name(node[i]))
  839.         
  840.         return names
  841.  
  842.     
  843.     def com_bases(self, node):
  844.         bases = []
  845.         for i in range(1, len(node), 2):
  846.             bases.append(self.com_node(node[i]))
  847.         
  848.         return bases
  849.  
  850.     
  851.     def com_try_except_finally(self, nodelist):
  852.         if nodelist[3][0] == token.NAME:
  853.             return TryFinally(self.com_node(nodelist[2]), self.com_node(nodelist[5]), lineno = nodelist[0][2])
  854.         clauses = []
  855.         elseNode = None
  856.         finallyNode = None
  857.         for i in range(3, len(nodelist), 3):
  858.             node = nodelist[i]
  859.             if node[0] == token.NAME:
  860.                 if node[1] == 'else':
  861.                     elseNode = self.com_node(nodelist[i + 2])
  862.                 elif node[1] == 'finally':
  863.                     finallyNode = self.com_node(nodelist[i + 2])
  864.                 
  865.             node[1] == 'else'
  866.         
  867.         try_except = TryExcept(self.com_node(nodelist[2]), clauses, elseNode, lineno = nodelist[0][2])
  868.         if finallyNode:
  869.             return TryFinally(try_except, finallyNode, lineno = nodelist[0][2])
  870.         return try_except
  871.  
  872.     
  873.     def com_with(self, nodelist):
  874.         expr = self.com_node(nodelist[1])
  875.         body = self.com_node(nodelist[-1])
  876.         if nodelist[2][0] == token.COLON:
  877.             var = None
  878.         else:
  879.             var = self.com_assign(nodelist[2][2], OP_ASSIGN)
  880.         return With(expr, var, body, lineno = nodelist[0][2])
  881.  
  882.     
  883.     def com_with_var(self, nodelist):
  884.         return self.com_node(nodelist[1])
  885.  
  886.     
  887.     def com_augassign_op(self, node):
  888.         return node[1]
  889.  
  890.     
  891.     def com_augassign(self, node):
  892.         l = self.com_node(node)
  893.         if l.__class__ in (Name, Slice, Subscript, Getattr):
  894.             return l
  895.         raise SyntaxError, "can't assign to %s" % l.__class__.__name__
  896.  
  897.     
  898.     def com_assign(self, node, assigning):
  899.         while None:
  900.             t = node[0]
  901.             if t in (symbol.exprlist, symbol.testlist, symbol.testlist_safe, symbol.testlist_gexp):
  902.                 if len(node) > 2:
  903.                     return self.com_assign_tuple(node, assigning)
  904.                 node = node[1]
  905.                 continue
  906.             if t in _assign_types:
  907.                 if len(node) > 2:
  908.                     raise SyntaxError, "can't assign to operator"
  909.                 len(node) > 2
  910.                 node = node[1]
  911.                 continue
  912.             if t == symbol.power:
  913.                 if node[1][0] != symbol.atom:
  914.                     raise SyntaxError, "can't assign to operator"
  915.                 node[1][0] != symbol.atom
  916.                 if len(node) > 2:
  917.                     primary = self.com_node(node[1])
  918.                     for i in range(2, len(node) - 1):
  919.                         ch = node[i]
  920.                         if ch[0] == token.DOUBLESTAR:
  921.                             raise SyntaxError, "can't assign to operator"
  922.                         ch[0] == token.DOUBLESTAR
  923.                         primary = self.com_apply_trailer(primary, ch)
  924.                     
  925.                     return self.com_assign_trailer(primary, node[-1], assigning)
  926.                 node = node[1]
  927.                 continue
  928.             len(node) > 2
  929.             if t == symbol.atom:
  930.                 t = node[1][0]
  931.                 if t == token.LPAR:
  932.                     node = node[2]
  933.                     if node[0] == token.RPAR:
  934.                         raise SyntaxError, "can't assign to ()"
  935.                     node[0] == token.RPAR
  936.                 elif t == token.LSQB:
  937.                     node = node[2]
  938.                     if node[0] == token.RSQB:
  939.                         raise SyntaxError, "can't assign to []"
  940.                     node[0] == token.RSQB
  941.                     return self.com_assign_list(node, assigning)
  942.                 if t == token.NAME:
  943.                     return self.com_assign_name(node[1], assigning)
  944.                 raise SyntaxError, "can't assign to literal"
  945.             t == symbol.atom
  946.             raise SyntaxError, 'bad assignment (%s)' % t
  947.             continue
  948.             return None
  949.  
  950.     
  951.     def com_assign_tuple(self, node, assigning):
  952.         assigns = []
  953.         for i in range(1, len(node), 2):
  954.             assigns.append(self.com_assign(node[i], assigning))
  955.         
  956.         return AssTuple(assigns, lineno = extractLineNo(node))
  957.  
  958.     
  959.     def com_assign_list(self, node, assigning):
  960.         assigns = []
  961.         for i in range(1, len(node), 2):
  962.             if i + 1 < len(node):
  963.                 if node[i + 1][0] == symbol.list_for:
  964.                     raise SyntaxError, "can't assign to list comprehension"
  965.                 node[i + 1][0] == symbol.list_for
  966.             
  967.             assigns.append(self.com_assign(node[i], assigning))
  968.         
  969.         return AssList(assigns, lineno = extractLineNo(node))
  970.  
  971.     
  972.     def com_assign_name(self, node, assigning):
  973.         return AssName(node[1], assigning, lineno = node[2])
  974.  
  975.     
  976.     def com_assign_trailer(self, primary, node, assigning):
  977.         t = node[1][0]
  978.         if t == token.DOT:
  979.             return self.com_assign_attr(primary, node[2], assigning)
  980.         if t == token.LSQB:
  981.             return self.com_subscriptlist(primary, node[2], assigning)
  982.         if t == token.LPAR:
  983.             raise SyntaxError, "can't assign to function call"
  984.         t == token.LPAR
  985.         raise SyntaxError, 'unknown trailer type: %s' % t
  986.  
  987.     
  988.     def com_assign_attr(self, primary, node, assigning):
  989.         return AssAttr(primary, node[1], assigning, lineno = node[-1])
  990.  
  991.     
  992.     def com_binary(self, constructor, nodelist):
  993.         l = len(nodelist)
  994.         if l == 1:
  995.             n = nodelist[0]
  996.             return self.lookup_node(n)(n[1:])
  997.         items = []
  998.         for i in range(0, l, 2):
  999.             n = nodelist[i]
  1000.             items.append(self.lookup_node(n)(n[1:]))
  1001.         
  1002.         return constructor(items, lineno = extractLineNo(nodelist))
  1003.  
  1004.     
  1005.     def com_stmt(self, node):
  1006.         result = self.lookup_node(node)(node[1:])
  1007.         if isinstance(result, Stmt):
  1008.             return result
  1009.         return Stmt([
  1010.             result])
  1011.  
  1012.     
  1013.     def com_append_stmt(self, stmts, node):
  1014.         result = self.lookup_node(node)(node[1:])
  1015.         if isinstance(result, Stmt):
  1016.             stmts.extend(result.nodes)
  1017.         else:
  1018.             stmts.append(result)
  1019.  
  1020.     if hasattr(symbol, 'list_for'):
  1021.         
  1022.         def com_list_constructor(self, nodelist):
  1023.             values = []
  1024.             for i in range(1, len(nodelist)):
  1025.                 if nodelist[i][0] == symbol.list_for:
  1026.                     return self.com_list_comprehension(values[0], nodelist[i])
  1027.                 if nodelist[i][0] == token.COMMA:
  1028.                     continue
  1029.                 
  1030.                 values.append(self.com_node(nodelist[i]))
  1031.             
  1032.             return List(values, lineno = values[0].lineno)
  1033.  
  1034.         
  1035.         def com_list_comprehension(self, expr, node):
  1036.             lineno = node[1][2]
  1037.             fors = []
  1038.             while node:
  1039.                 t = node[1][1]
  1040.                 if t == 'for':
  1041.                     assignNode = self.com_assign(node[2], OP_ASSIGN)
  1042.                     listNode = self.com_node(node[4])
  1043.                     newfor = ListCompFor(assignNode, listNode, [])
  1044.                     newfor.lineno = node[1][2]
  1045.                     fors.append(newfor)
  1046.                     if len(node) == 5:
  1047.                         node = None
  1048.                     else:
  1049.                         node = self.com_list_iter(node[5])
  1050.                 len(node) == 5
  1051.                 if t == 'if':
  1052.                     test = self.com_node(node[2])
  1053.                     newif = ListCompIf(test, lineno = node[1][2])
  1054.                     newfor.ifs.append(newif)
  1055.                     if len(node) == 3:
  1056.                         node = None
  1057.                     else:
  1058.                         node = self.com_list_iter(node[3])
  1059.                 len(node) == 3
  1060.                 raise SyntaxError, 'unexpected list comprehension element: %s %d' % (node, lineno)
  1061.             return ListComp(expr, fors, lineno = lineno)
  1062.  
  1063.         
  1064.         def com_list_iter(self, node):
  1065.             return node[1]
  1066.  
  1067.     else:
  1068.         
  1069.         def com_list_constructor(self, nodelist):
  1070.             values = []
  1071.             for i in range(1, len(nodelist), 2):
  1072.                 values.append(self.com_node(nodelist[i]))
  1073.             
  1074.             return List(values, lineno = values[0].lineno)
  1075.  
  1076.     if hasattr(symbol, 'gen_for'):
  1077.         
  1078.         def com_generator_expression(self, expr, node):
  1079.             lineno = node[1][2]
  1080.             fors = []
  1081.             while node:
  1082.                 t = node[1][1]
  1083.                 if t == 'for':
  1084.                     assignNode = self.com_assign(node[2], OP_ASSIGN)
  1085.                     genNode = self.com_node(node[4])
  1086.                     newfor = GenExprFor(assignNode, genNode, [], lineno = node[1][2])
  1087.                     fors.append(newfor)
  1088.                     if len(node) == 5:
  1089.                         node = None
  1090.                     else:
  1091.                         node = self.com_gen_iter(node[5])
  1092.                 len(node) == 5
  1093.                 if t == 'if':
  1094.                     test = self.com_node(node[2])
  1095.                     newif = GenExprIf(test, lineno = node[1][2])
  1096.                     newfor.ifs.append(newif)
  1097.                     if len(node) == 3:
  1098.                         node = None
  1099.                     else:
  1100.                         node = self.com_gen_iter(node[3])
  1101.                 len(node) == 3
  1102.                 raise SyntaxError, 'unexpected generator expression element: %s %d' % (node, lineno)
  1103.             fors[0].is_outmost = True
  1104.             return GenExpr(GenExprInner(expr, fors), lineno = lineno)
  1105.  
  1106.         
  1107.         def com_gen_iter(self, node):
  1108.             return node[1]
  1109.  
  1110.     
  1111.     
  1112.     def com_dictmaker(self, nodelist):
  1113.         items = []
  1114.         for i in range(1, len(nodelist), 4):
  1115.             items.append((self.com_node(nodelist[i]), self.com_node(nodelist[i + 2])))
  1116.         
  1117.         return Dict(items, lineno = items[0][0].lineno)
  1118.  
  1119.     
  1120.     def com_apply_trailer(self, primaryNode, nodelist):
  1121.         t = nodelist[1][0]
  1122.         if t == token.LPAR:
  1123.             return self.com_call_function(primaryNode, nodelist[2])
  1124.         if t == token.DOT:
  1125.             return self.com_select_member(primaryNode, nodelist[2])
  1126.         if t == token.LSQB:
  1127.             return self.com_subscriptlist(primaryNode, nodelist[2], OP_APPLY)
  1128.         raise SyntaxError, 'unknown node type: %s' % t
  1129.  
  1130.     
  1131.     def com_select_member(self, primaryNode, nodelist):
  1132.         if nodelist[0] != token.NAME:
  1133.             raise SyntaxError, 'member must be a name'
  1134.         nodelist[0] != token.NAME
  1135.         return Getattr(primaryNode, nodelist[1], lineno = nodelist[2])
  1136.  
  1137.     
  1138.     def com_call_function(self, primaryNode, nodelist):
  1139.         if nodelist[0] == token.RPAR:
  1140.             return CallFunc(primaryNode, [], lineno = extractLineNo(nodelist))
  1141.         args = []
  1142.         kw = 0
  1143.         star_node = None
  1144.         dstar_node = None
  1145.         len_nodelist = len(nodelist)
  1146.         i = 1
  1147.         while i < len_nodelist:
  1148.             node = nodelist[i]
  1149.             if node[0] == token.STAR:
  1150.                 if star_node is not None:
  1151.                     raise SyntaxError, 'already have the varargs indentifier'
  1152.                 star_node is not None
  1153.                 star_node = self.com_node(nodelist[i + 1])
  1154.                 i = i + 3
  1155.                 continue
  1156.             elif node[0] == token.DOUBLESTAR:
  1157.                 if dstar_node is not None:
  1158.                     raise SyntaxError, 'already have the kwargs indentifier'
  1159.                 dstar_node is not None
  1160.                 dstar_node = self.com_node(nodelist[i + 1])
  1161.                 i = i + 3
  1162.                 continue
  1163.             
  1164.             (kw, result) = self.com_argument(node, kw, star_node)
  1165.             if len_nodelist != 2 and isinstance(result, GenExpr) and len(node) == 3 and node[2][0] == symbol.gen_for:
  1166.                 raise SyntaxError, 'generator expression needs parenthesis'
  1167.             node[2][0] == symbol.gen_for
  1168.             args.append(result)
  1169.             i = i + 2
  1170.         return CallFunc(primaryNode, args, star_node, dstar_node, lineno = extractLineNo(nodelist))
  1171.  
  1172.     
  1173.     def com_argument(self, nodelist, kw, star_node):
  1174.         if len(nodelist) == 3 and nodelist[2][0] == symbol.gen_for:
  1175.             test = self.com_node(nodelist[1])
  1176.             return (0, self.com_generator_expression(test, nodelist[2]))
  1177.         if len(nodelist) == 2:
  1178.             if kw:
  1179.                 raise SyntaxError, 'non-keyword arg after keyword arg'
  1180.             kw
  1181.             if star_node:
  1182.                 raise SyntaxError, 'only named arguments may follow *expression'
  1183.             star_node
  1184.             return (0, self.com_node(nodelist[1]))
  1185.         result = self.com_node(nodelist[3])
  1186.         n = nodelist[1]
  1187.         while len(n) == 2 and n[0] != token.NAME:
  1188.             n = n[1]
  1189.             continue
  1190.             len(nodelist) == 2
  1191.         if n[0] != token.NAME:
  1192.             raise SyntaxError, "keyword can't be an expression (%s)" % n[0]
  1193.         n[0] != token.NAME
  1194.         node = Keyword(n[1], result, lineno = n[2])
  1195.         return (1, node)
  1196.  
  1197.     
  1198.     def com_subscriptlist(self, primary, nodelist, assigning):
  1199.         if len(nodelist) == 2:
  1200.             sub = nodelist[1]
  1201.             if (sub[1][0] == token.COLON or len(sub) > 2 or sub[2][0] == token.COLON) and sub[-1][0] != symbol.sliceop:
  1202.                 return self.com_slice(primary, sub, assigning)
  1203.         
  1204.         subscripts = []
  1205.         for i in range(1, len(nodelist), 2):
  1206.             subscripts.append(self.com_subscript(nodelist[i]))
  1207.         
  1208.         return Subscript(primary, assigning, subscripts, lineno = extractLineNo(nodelist))
  1209.  
  1210.     
  1211.     def com_subscript(self, node):
  1212.         ch = node[1]
  1213.         t = ch[0]
  1214.         if t == token.DOT and node[2][0] == token.DOT:
  1215.             return Ellipsis()
  1216.         if t == token.COLON or len(node) > 2:
  1217.             return self.com_sliceobj(node)
  1218.         return self.com_node(ch)
  1219.  
  1220.     
  1221.     def com_sliceobj(self, node):
  1222.         items = []
  1223.         if node[1][0] == token.COLON:
  1224.             items.append(Const(None))
  1225.             i = 2
  1226.         else:
  1227.             items.append(self.com_node(node[1]))
  1228.             i = 3
  1229.         if i < len(node) and node[i][0] == symbol.test:
  1230.             items.append(self.com_node(node[i]))
  1231.             i = i + 1
  1232.         else:
  1233.             items.append(Const(None))
  1234.         for j in range(i, len(node)):
  1235.             ch = node[j]
  1236.             if len(ch) == 2:
  1237.                 items.append(Const(None))
  1238.                 continue
  1239.             items.append(self.com_node(ch[2]))
  1240.         
  1241.         return Sliceobj(items, lineno = extractLineNo(node))
  1242.  
  1243.     
  1244.     def com_slice(self, primary, node, assigning):
  1245.         lower = None
  1246.         upper = None
  1247.         if len(node) == 3:
  1248.             if node[1][0] == token.COLON:
  1249.                 upper = self.com_node(node[2])
  1250.             else:
  1251.                 lower = self.com_node(node[1])
  1252.         elif len(node) == 4:
  1253.             lower = self.com_node(node[1])
  1254.             upper = self.com_node(node[3])
  1255.         
  1256.         return Slice(primary, assigning, lower, upper, lineno = extractLineNo(node))
  1257.  
  1258.     
  1259.     def get_docstring(self, node, n = None):
  1260.         if n is None:
  1261.             n = node[0]
  1262.             node = node[1:]
  1263.         
  1264.         if n == symbol.suite:
  1265.             if len(node) == 1:
  1266.                 return self.get_docstring(node[0])
  1267.             for sub in node:
  1268.                 if sub[0] == symbol.stmt:
  1269.                     return self.get_docstring(sub)
  1270.             
  1271.             return None
  1272.         if n == symbol.file_input:
  1273.             for sub in node:
  1274.                 if sub[0] == symbol.stmt:
  1275.                     return self.get_docstring(sub)
  1276.             
  1277.             return None
  1278.         if n == symbol.atom:
  1279.             if node[0][0] == token.STRING:
  1280.                 s = ''
  1281.                 for t in node:
  1282.                     s = s + eval(t[1])
  1283.                 
  1284.                 return s
  1285.             return None
  1286.         if n == symbol.stmt and n == symbol.simple_stmt or n == symbol.small_stmt:
  1287.             return self.get_docstring(node[0])
  1288.         if n in _doc_nodes and len(node) == 1:
  1289.             return self.get_docstring(node[0])
  1290.  
  1291.  
  1292. _doc_nodes = [
  1293.     symbol.expr_stmt,
  1294.     symbol.testlist,
  1295.     symbol.testlist_safe,
  1296.     symbol.test,
  1297.     symbol.or_test,
  1298.     symbol.and_test,
  1299.     symbol.not_test,
  1300.     symbol.comparison,
  1301.     symbol.expr,
  1302.     symbol.xor_expr,
  1303.     symbol.and_expr,
  1304.     symbol.shift_expr,
  1305.     symbol.arith_expr,
  1306.     symbol.term,
  1307.     symbol.factor,
  1308.     symbol.power]
  1309. _cmp_types = {
  1310.     token.LESS: '<',
  1311.     token.GREATER: '>',
  1312.     token.EQEQUAL: '==',
  1313.     token.EQUAL: '==',
  1314.     token.LESSEQUAL: '<=',
  1315.     token.GREATEREQUAL: '>=',
  1316.     token.NOTEQUAL: '!=' }
  1317. _legal_node_types = [
  1318.     symbol.funcdef,
  1319.     symbol.classdef,
  1320.     symbol.stmt,
  1321.     symbol.small_stmt,
  1322.     symbol.flow_stmt,
  1323.     symbol.simple_stmt,
  1324.     symbol.compound_stmt,
  1325.     symbol.expr_stmt,
  1326.     symbol.print_stmt,
  1327.     symbol.del_stmt,
  1328.     symbol.pass_stmt,
  1329.     symbol.break_stmt,
  1330.     symbol.continue_stmt,
  1331.     symbol.return_stmt,
  1332.     symbol.raise_stmt,
  1333.     symbol.import_stmt,
  1334.     symbol.global_stmt,
  1335.     symbol.exec_stmt,
  1336.     symbol.assert_stmt,
  1337.     symbol.if_stmt,
  1338.     symbol.while_stmt,
  1339.     symbol.for_stmt,
  1340.     symbol.try_stmt,
  1341.     symbol.with_stmt,
  1342.     symbol.suite,
  1343.     symbol.testlist,
  1344.     symbol.testlist_safe,
  1345.     symbol.test,
  1346.     symbol.and_test,
  1347.     symbol.not_test,
  1348.     symbol.comparison,
  1349.     symbol.exprlist,
  1350.     symbol.expr,
  1351.     symbol.xor_expr,
  1352.     symbol.and_expr,
  1353.     symbol.shift_expr,
  1354.     symbol.arith_expr,
  1355.     symbol.term,
  1356.     symbol.factor,
  1357.     symbol.power,
  1358.     symbol.atom]
  1359. if hasattr(symbol, 'yield_stmt'):
  1360.     _legal_node_types.append(symbol.yield_stmt)
  1361.  
  1362. if hasattr(symbol, 'yield_expr'):
  1363.     _legal_node_types.append(symbol.yield_expr)
  1364.  
  1365. _assign_types = [
  1366.     symbol.test,
  1367.     symbol.or_test,
  1368.     symbol.and_test,
  1369.     symbol.not_test,
  1370.     symbol.comparison,
  1371.     symbol.expr,
  1372.     symbol.xor_expr,
  1373.     symbol.and_expr,
  1374.     symbol.shift_expr,
  1375.     symbol.arith_expr,
  1376.     symbol.term,
  1377.     symbol.factor]
  1378. _names = { }
  1379. for k, v in symbol.sym_name.items():
  1380.     _names[k] = v
  1381.  
  1382. for k, v in token.tok_name.items():
  1383.     _names[k] = v
  1384.  
  1385.  
  1386. def debug_tree(tree):
  1387.     l = []
  1388.     for elt in tree:
  1389.         if isinstance(elt, int):
  1390.             l.append(_names.get(elt, elt))
  1391.             continue
  1392.         if isinstance(elt, str):
  1393.             l.append(elt)
  1394.             continue
  1395.         l.append(debug_tree(elt))
  1396.     
  1397.     return l
  1398.  
  1399.