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