diff --git a/Lib/compiler/transformer.py b/Lib/compiler/transformer.py
index 9562aa6..91d4b5b 100644
--- a/Lib/compiler/transformer.py
+++ b/Lib/compiler/transformer.py
@@ -118,1135 +118,1133 @@
     return Transformer().parsesuite(buf)
 
 def asList(nodes):
-  l = []
-  for item in nodes:
-    if hasattr(item, "asList"):
-      l.append(item.asList())
-    else:
-      if type(item) is type( (None, None) ):
-        l.append(tuple(asList(item)))
-      elif type(item) is type( [] ):
-        l.append(asList(item))
-      else:
-        l.append(item)
-  return l
+    l = []
+    for item in nodes:
+        if hasattr(item, "asList"):
+            l.append(item.asList())
+        else:
+            if type(item) is type( (None, None) ):
+                l.append(tuple(asList(item)))
+            elif type(item) is type( [] ):
+                l.append(asList(item))
+            else:
+                l.append(item)
+    return l
 
 def Node(*args):
-  kind = args[0]
-  if ast.nodes.has_key(kind):
-    try:
-      return apply(ast.nodes[kind], args[1:])
-    except TypeError:
-      print ast.nodes[kind], len(args), args
-      raise
-  else:
-    raise error, "Can't find appropriate Node type."
-    #return apply(ast.Node, args)
+    kind = args[0]
+    if ast.nodes.has_key(kind):
+        try:
+            return apply(ast.nodes[kind], args[1:])
+        except TypeError:
+            print ast.nodes[kind], len(args), args
+            raise
+    else:
+        raise error, "Can't find appropriate Node type."
+        #return apply(ast.Node, args)
 
 class Transformer:
-  """Utility object for transforming Python parse trees.
+    """Utility object for transforming Python parse trees.
 
-  Exposes the following methods:
-    tree = transform(ast_tree)
-    tree = parsesuite(text)
-    tree = parseexpr(text)
-    tree = parsefile(fileob | filename)
-  """
+    Exposes the following methods:
+        tree = transform(ast_tree)
+        tree = parsesuite(text)
+        tree = parseexpr(text)
+        tree = parsefile(fileob | filename)
+    """
 
-  def __init__(self):
-    self._dispatch = { }
-    for value, name in symbol.sym_name.items():
-      if hasattr(self, name):
-        self._dispatch[value] = getattr(self, name)
+    def __init__(self):
+        self._dispatch = { }
+        for value, name in symbol.sym_name.items():
+            if hasattr(self, name):
+                self._dispatch[value] = getattr(self, name)
 
-  def transform(self, tree):
-    """Transform an AST into a modified parse tree."""
-    if type(tree) != type(()) and type(tree) != type([]):
-      tree = parser.ast2tuple(tree,1)
-    return self.compile_node(tree)
+    def transform(self, tree):
+        """Transform an AST into a modified parse tree."""
+        if type(tree) != type(()) and type(tree) != type([]):
+            tree = parser.ast2tuple(tree,1)
+        return self.compile_node(tree)
 
-  def parsesuite(self, text):
-    """Return a modified parse tree for the given suite text."""
-    # Hack for handling non-native line endings on non-DOS like OSs.
-    text = string.replace(text, '\x0d', '')
-    return self.transform(parser.suite(text))
+    def parsesuite(self, text):
+        """Return a modified parse tree for the given suite text."""
+        # Hack for handling non-native line endings on non-DOS like OSs.
+        text = string.replace(text, '\x0d', '')
+        return self.transform(parser.suite(text))
 
-  def parseexpr(self, text):
-    """Return a modified parse tree for the given expression text."""
-    return self.transform(parser.expr(text))
+    def parseexpr(self, text):
+        """Return a modified parse tree for the given expression text."""
+        return self.transform(parser.expr(text))
 
-  def parsefile(self, file):
-    """Return a modified parse tree for the contents of the given file."""
-    if type(file) == type(''):
-      file = open(file)
-    return self.parsesuite(file.read())
+    def parsefile(self, file):
+        """Return a modified parse tree for the contents of the given file."""
+        if type(file) == type(''):
+            file = open(file)
+        return self.parsesuite(file.read())
 
-  # --------------------------------------------------------------
-  #
-  # PRIVATE METHODS
-  #
-
-  def compile_node(self, node):
-    ### emit a line-number node?
-    n = node[0]
-    if n == symbol.single_input:
-      return self.single_input(node[1:])
-    if n == symbol.file_input:
-      return self.file_input(node[1:])
-    if n == symbol.eval_input:
-      return self.eval_input(node[1:])
-    if n == symbol.lambdef:
-      return self.lambdef(node[1:])
-    if n == symbol.funcdef:
-      return self.funcdef(node[1:])
-    if n == symbol.classdef:
-      return self.classdef(node[1:])
-
-    raise error, ('unexpected node type', n)
-
-  def single_input(self, node):
-    ### do we want to do anything about being "interactive" ?
-
-    # NEWLINE | simple_stmt | compound_stmt NEWLINE
-    n = node[0][0]
-    if n != token.NEWLINE:
-      return self.com_stmt(node[0])
-
-    return Node('pass')
-
-  def file_input(self, nodelist):
-    doc = self.get_docstring(nodelist, symbol.file_input)
-    stmts = [ ]
-    for node in nodelist:
-      if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:
-        self.com_append_stmt(stmts, node)
-    return Node('module', doc, Node('stmt', stmts))
-
-  def eval_input(self, nodelist):
-    # from the built-in function input()
-    ### is this sufficient?
-    return self.com_node(nodelist[0])
-
-  def funcdef(self, nodelist):
-    # funcdef: 'def' NAME parameters ':' suite
-    # parameters: '(' [varargslist] ')'
-
-    lineno = nodelist[1][2]
-    name   = nodelist[1][1]
-    args   = nodelist[2][2]
-
-    if args[0] == symbol.varargslist:
-      names, defaults, flags = self.com_arglist(args[1:])
-    else:
-      names = defaults = ()
-      flags = 0
-    doc = self.get_docstring(nodelist[4])
-
-    # code for function
-    code = self.com_node(nodelist[4])
-
-    n = Node('function', name, names, defaults, flags, doc, code)
-    n.lineno = lineno
-    return n
-
-  def lambdef(self, nodelist):
-    # lambdef: 'lambda' [varargslist] ':' test
-    if nodelist[2][0] == symbol.varargslist:
-      names, defaults, flags = self.com_arglist(nodelist[2][1:])
-    else:
-      names = defaults = ()
-      flags = 0
-
-    # code for lambda
-    code = self.com_node(nodelist[-1])
-
-    n = Node('lambda', names, defaults, flags, code)
-    n.lineno = nodelist[1][2]
-    return n
-
-  def classdef(self, nodelist):
-    # classdef: 'class' NAME ['(' testlist ')'] ':' suite
-
-    name = nodelist[1][1]
-    doc = self.get_docstring(nodelist[-1])
-    if nodelist[2][0] == token.COLON:
-      bases = []
-    else:
-      bases = self.com_bases(nodelist[3])
-
-    # code for class
-    code = self.com_node(nodelist[-1])
-
-    n = Node('class', name, bases, doc, code)
-    n.lineno = nodelist[1][2]
-    return n
-
-  def stmt(self, nodelist):
-    return self.com_stmt(nodelist[0])
-
-  small_stmt = stmt
-  flow_stmt = stmt
-  compound_stmt = stmt
-
-  def simple_stmt(self, nodelist):
-    # small_stmt (';' small_stmt)* [';'] NEWLINE
-    stmts = [ ]
-    for i in range(0, len(nodelist), 2):
-      self.com_append_stmt(stmts, nodelist[i])
-    return Node('stmt', stmts)
-
-  def parameters(self, nodelist):
-    raise error
-
-  def varargslist(self, nodelist):
-    raise error
-
-  def fpdef(self, nodelist):
-    raise error
-
-  def fplist(self, nodelist):
-    raise error
-
-  def dotted_name(self, nodelist):
-    raise error
-
-  def comp_op(self, nodelist):
-    raise error
-
-  def trailer(self, nodelist):
-    raise error
-
-  def sliceop(self, nodelist):
-    raise error
-
-  def argument(self, nodelist):
-    raise error
-
-  # --------------------------------------------------------------
-  #
-  # STATEMENT NODES  (invoked by com_node())
-  #
-
-  def expr_stmt(self, nodelist):
-    # testlist ('=' testlist)*
-    exprNode = self.com_node(nodelist[-1])
-    if len(nodelist) == 1:
-      return Node('discard', exprNode)
-    nodes = [ ]
-    for i in range(0, len(nodelist) - 2, 2):
-      nodes.append(self.com_assign(nodelist[i], OP_ASSIGN))
-    n = Node('assign', nodes, exprNode)
-    n.lineno = nodelist[1][2]
-    return n
-
-  def print_stmt(self, nodelist):
-    # print: (test ',')* [test]
-    items = [ ]
-    for i in range(1, len(nodelist), 2):
-      items.append(self.com_node(nodelist[i]))
-    if nodelist[-1][0] == token.COMMA:
-      n = Node('print', items)
-      n.lineno = nodelist[0][2]
-      return n
-    n = Node('printnl', items)
-    n.lineno = nodelist[0][2]
-    return n
-
-  def del_stmt(self, nodelist):
-    return self.com_assign(nodelist[1], OP_DELETE)
-
-  def pass_stmt(self, nodelist):
-    # pass:
-    n = Node('pass')
-    n.lineno = nodelist[0][2]
-    return n
-
-  def break_stmt(self, nodelist):
-    # break:
-    n = Node('break')
-    n.lineno = nodelist[0][2]
-    return n
-
-  def continue_stmt(self, nodelist):
-    # continue
-    n = Node('continue')
-    n.lineno = nodelist[0][2]
-    return n
-
-  def return_stmt(self, nodelist):
-    # return: [testlist]
-    if len(nodelist) < 2:
-      n = Node('return', Node('const', None))
-      n.lineno = nodelist[0][2]
-      return n
-    n = Node('return', self.com_node(nodelist[1]))
-    n.lineno = nodelist[0][2]
-    return n
-
-  def raise_stmt(self, nodelist):
-    # raise: [test [',' test [',' test]]]
-    if len(nodelist) > 5:
-      expr3 = self.com_node(nodelist[5])
-    else:
-      expr3 = None
-    if len(nodelist) > 3:
-      expr2 = self.com_node(nodelist[3])
-    else:
-      expr2 = None
-    if len(nodelist) > 1:
-      expr1 = self.com_node(nodelist[1])
-    else:
-      expr1 = None
-    n = Node('raise', expr1, expr2, expr3)
-    n.lineno = nodelist[0][2]
-    return n
-
-  def import_stmt(self, nodelist):
-    # import_stmt: 'import' dotted_as_name (',' dotted_as_name)* |
-    # from: 'from' dotted_name 'import'
-    #                        ('*' | import_as_name (',' import_as_name)*)
-    names = []
-    is_as = 0
-    if nodelist[0][1] == 'from':
-      for i in range(3, len(nodelist), 2):
-        names.append(self.com_import_as_name(nodelist[i][1]))
-      n = Node('from', self.com_dotted_name(nodelist[1]), names)
-      n.lineno = nodelist[0][2]
-      return n
-
-    for i in range(1, len(nodelist), 2):
-      names.append(self.com_dotted_as_name(nodelist[i]))
-    n = Node('import', names)
-    n.lineno = nodelist[0][2]
-    return n
-
-  def global_stmt(self, nodelist):
-    # global: NAME (',' NAME)*
-    names = [ ]
-    for i in range(1, len(nodelist), 2):
-      names.append(nodelist[i][1])
-    n = Node('global', names)
-    n.lineno = nodelist[0][2]
-    return n
-
-  def exec_stmt(self, nodelist):
-    # exec_stmt: 'exec' expr ['in' expr [',' expr]]
-    expr1 = self.com_node(nodelist[1])
-    if len(nodelist) >= 4:
-      expr2 = self.com_node(nodelist[3])
-      if len(nodelist) >= 6:
-        expr3 = self.com_node(nodelist[5])
-      else:
-        expr3 = None
-    else:
-      expr2 = expr3 = None
-
-    n = Node('exec', expr1, expr2, expr3)
-    n.lineno = nodelist[0][2]
-    return n
-
-  def assert_stmt(self, nodelist):
-    # 'assert': test, [',' test]
-    expr1 = self.com_node(nodelist[1])
-    if (len(nodelist) == 4):
-      expr2 = self.com_node(nodelist[3])
-    else:
-      expr2 = Node('name', 'None')
-    n = Node('assert', expr1, expr2)
-    n.lineno = nodelist[0][2]
-    return n
-
-  def if_stmt(self, nodelist):
-    # if: test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
-    tests = [ ]
-    for i in range(0, len(nodelist) - 3, 4):
-      testNode = self.com_node(nodelist[i + 1])
-      suiteNode = self.com_node(nodelist[i + 3])
-      tests.append((testNode, suiteNode))
-
-    if len(nodelist) % 4 == 3:
-      elseNode = self.com_node(nodelist[-1])
-##      elseNode.lineno = nodelist[-1][1][2]
-    else:
-      elseNode = None
-    n = Node('if', tests, elseNode)
-    n.lineno = nodelist[0][2]
-    return n
-
-  def while_stmt(self, nodelist):
-    # 'while' test ':' suite ['else' ':' suite]
-
-    testNode = self.com_node(nodelist[1])
-    bodyNode = self.com_node(nodelist[3])
-
-    if len(nodelist) > 4:
-      elseNode = self.com_node(nodelist[6])
-    else:
-      elseNode = None
-
-    n = Node('while', testNode, bodyNode, elseNode)
-    n.lineno = nodelist[0][2]
-    return n
-
-  def for_stmt(self, nodelist):
-    # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
-
-    assignNode = self.com_assign(nodelist[1], OP_ASSIGN)
-    listNode = self.com_node(nodelist[3])
-    bodyNode = self.com_node(nodelist[5])
-
-    if len(nodelist) > 8:
-      elseNode = self.com_node(nodelist[8])
-    else:
-      elseNode = None
-
-    n = Node('for', assignNode, listNode, bodyNode, elseNode)
-    n.lineno = nodelist[0][2]
-    return n
-
-  def try_stmt(self, nodelist):
-    # 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite]
-    # | 'try' ':' suite 'finally' ':' suite
-    if nodelist[3][0] != symbol.except_clause:
-      return self.com_try_finally(nodelist)
-
-    return self.com_try_except(nodelist)
-
-  def suite(self, nodelist):
-    # simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT
-    if len(nodelist) == 1:
-      return self.com_stmt(nodelist[0])
-
-    stmts = [ ]
-    for node in nodelist:
-      if node[0] == symbol.stmt:
-        self.com_append_stmt(stmts, node)
-    return Node('stmt', stmts)
-
-  # --------------------------------------------------------------
-  #
-  # EXPRESSION NODES  (invoked by com_node())
-  #
-
-  def testlist(self, nodelist):
-    # testlist: expr (',' expr)* [',']
-    # exprlist: expr (',' expr)* [',']
-    return self.com_binary('tuple', nodelist)
-
-  exprlist = testlist
-
-  def test(self, nodelist):
-    # and_test ('or' and_test)* | lambdef
-    if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
-      return self.lambdef(nodelist[0])
-    return self.com_binary('or', nodelist)
-
-  def and_test(self, nodelist):
-    # not_test ('and' not_test)*
-    return self.com_binary('and', nodelist)
-
-  def not_test(self, nodelist):
-    # 'not' not_test | comparison
-    result = self.com_node(nodelist[-1])
-    if len(nodelist) == 2:
-      n = Node('not', result)
-      n.lineno = nodelist[0][2]
-      return n
-    return result
-
-  def comparison(self, nodelist):
-    # comparison: expr (comp_op expr)*
-    node = self.com_node(nodelist[0])
-    if len(nodelist) == 1:
-      return node
-
-    results = [ ]
-    for i in range(2, len(nodelist), 2):
-      nl = nodelist[i-1]
-
-      # comp_op: '<' | '>' | '=' | '>=' | '<=' | '<>' | '!=' | '=='
-      #          | 'in' | 'not' 'in' | 'is' | 'is' 'not'
-      n = nl[1]
-      if n[0] == token.NAME:
-        type = n[1]
-        if len(nl) == 3:
-          if type == 'not':
-            type = 'not in'
-          else:
-            type = 'is not'
-      else:
-        type = _cmp_types[n[0]]
-
-      lineno = nl[1][2]
-      results.append((type, self.com_node(nodelist[i])))
-
-    # we need a special "compare" node so that we can distinguish
-    #   3 < x < 5   from    (3 < x) < 5
-    # the two have very different semantics and results (note that the
-    # latter form is always true)
-
-    n = Node('compare', node, results)
-    n.lineno = lineno
-    return n
-
-  def expr(self, nodelist):
-    # xor_expr ('|' xor_expr)*
-    return self.com_binary('bitor', nodelist)
-
-  def xor_expr(self, nodelist):
-    # xor_expr ('^' xor_expr)*
-    return self.com_binary('bitxor', nodelist)
-
-  def and_expr(self, nodelist):
-    # xor_expr ('&' xor_expr)*
-    return self.com_binary('bitand', nodelist)
-
-  def shift_expr(self, nodelist):
-    # shift_expr ('<<'|'>>' shift_expr)*
-    node = self.com_node(nodelist[0])
-    for i in range(2, len(nodelist), 2):
-      right = self.com_node(nodelist[i])
-      if nodelist[i-1][0] == token.LEFTSHIFT:
-        node = Node('<<', [node, right])
-        node.lineno = nodelist[1][2]
-      else:
-        node = Node('>>', [node, right])
-        node.lineno = nodelist[1][2]
-    return node
-
-  def arith_expr(self, nodelist):
-    node = self.com_node(nodelist[0])
-    for i in range(2, len(nodelist), 2):
-      right = self.com_node(nodelist[i])
-      if nodelist[i-1][0] == token.PLUS:
-        node = Node('+', [node, right])
-        node.lineno = nodelist[1][2]
-      else:
-        node = Node('-', [node, right])
-        node.lineno = nodelist[1][2]
-    return node
-
-  def term(self, nodelist):
-    node = self.com_node(nodelist[0])
-    for i in range(2, len(nodelist), 2):
-      right = self.com_node(nodelist[i])
-      if nodelist[i-1][0] == token.STAR:
-        node = Node('*', [node, right])
-        node.lineno = nodelist[1][2]
-      elif nodelist[i-1][0] == token.SLASH:
-        node = Node('/', [node, right])
-        node.lineno = nodelist[1][2]
-      else:
-        node = Node('%', [node, right])
-        node.lineno = nodelist[1][2]
-    return node
-
-  def factor(self, nodelist):
-    t = nodelist[0][0]
-    node = self.com_node(nodelist[-1])
-    if t == token.PLUS:
-      node = Node('unary+', node)
-      node.lineno = nodelist[0][2]
-    elif t == token.MINUS:
-      node = Node('unary-', node)
-      node.lineno = nodelist[0][2]
-    elif t == token.TILDE:
-      node = Node('invert', node)
-      node.lineno = nodelist[0][2]
-    return node
-
-  def power(self, nodelist):
-    # power: atom trailer* ('**' factor)*
-    node = self.com_node(nodelist[0])
-    for i in range(1, len(nodelist)):
-      if nodelist[i][0] == token.DOUBLESTAR:
-        n = Node('power', [node, self.com_node(nodelist[i+1])])
-        n.lineno = nodelist[i][2]
-        return n
-
-      node = self.com_apply_trailer(node, nodelist[i])
-
-    return node
-
-  def atom(self, nodelist):
-    t = nodelist[0][0]
-    if t == token.LPAR:
-      if nodelist[1][0] == token.RPAR:
-        n = Node('tuple', ())
-        n.lineno = nodelist[0][2]
-        return n
-      return self.com_node(nodelist[1])
-
-    if t == token.LSQB:
-      if nodelist[1][0] == token.RSQB:
-        n = Node('list', ())
-        n.lineno = nodelist[0][2]
-        return n
-      return self.com_list_constructor(nodelist[1])
-
-    if t == token.LBRACE:
-      if nodelist[1][0] == token.RBRACE:
-        return Node('dict', ())
-      return self.com_dictmaker(nodelist[1])
-
-    if t == token.BACKQUOTE:
-      n = Node('backquote', self.com_node(nodelist[1]))
-      n.lineno = nodelist[0][2]
-      return n
-
-    if t == token.NUMBER:
-      ### need to verify this matches compile.c
-      k = eval(nodelist[0][1])
-      n = Node('const', k)
-      n.lineno = nodelist[0][2]
-      return n
-
-    if t == token.STRING:
-      ### need to verify this matches compile.c
-      k = ''
-      for node in nodelist:
-        k = k + eval(node[1])
-      n = Node('const', k)
-      n.lineno = nodelist[0][2]
-      return n
-
-    if t == token.NAME:
-      ### any processing to do?
-      n = Node('name', nodelist[0][1])
-      n.lineno = nodelist[0][2]
-      return n
-
-    raise error, "unknown node type"
-
-  # --------------------------------------------------------------
-  #
-  # INTERNAL PARSING UTILITIES
-  #
-
-  def com_node(self, node):
-    # Note: compile.c has handling in com_node for del_stmt, pass_stmt,
-    #       break_stmt, stmt, small_stmt, flow_stmt, simple_stmt,
-    #       and compound_stmt.
-    #       We'll just dispatch them.
-
+    # --------------------------------------------------------------
     #
-    # A ';' at the end of a line can make a NEWLINE token appear here,
-    # Render it harmless. (genc discards ('discard', ('const', xxxx)) Nodes)
-    # 
-    if node[0] == token.NEWLINE:
-      return Node('discard', Node('const', None))
+    # PRIVATE METHODS
+    #
 
-    if node[0] not in _legal_node_types:
-      raise error, 'illegal node passed to com_node: %s' % node[0]
+    def compile_node(self, node):
+        ### emit a line-number node?
+        n = node[0]
+        if n == symbol.single_input:
+            return self.single_input(node[1:])
+        if n == symbol.file_input:
+            return self.file_input(node[1:])
+        if n == symbol.eval_input:
+            return self.eval_input(node[1:])
+        if n == symbol.lambdef:
+            return self.lambdef(node[1:])
+        if n == symbol.funcdef:
+            return self.funcdef(node[1:])
+        if n == symbol.classdef:
+            return self.classdef(node[1:])
+
+        raise error, ('unexpected node type', n)
+
+    def single_input(self, node):
+        ### do we want to do anything about being "interactive" ?
+
+        # NEWLINE | simple_stmt | compound_stmt NEWLINE
+        n = node[0][0]
+        if n != token.NEWLINE:
+            return self.com_stmt(node[0])
+
+        return Node('pass')
+
+    def file_input(self, nodelist):
+        doc = self.get_docstring(nodelist, symbol.file_input)
+        stmts = [ ]
+        for node in nodelist:
+            if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:
+                self.com_append_stmt(stmts, node)
+        return Node('module', doc, Node('stmt', stmts))
+
+    def eval_input(self, nodelist):
+        # from the built-in function input()
+        ### is this sufficient?
+        return self.com_node(nodelist[0])
+
+    def funcdef(self, nodelist):
+        # funcdef: 'def' NAME parameters ':' suite
+        # parameters: '(' [varargslist] ')'
+
+        lineno = nodelist[1][2]
+        name   = nodelist[1][1]
+        args   = nodelist[2][2]
+
+        if args[0] == symbol.varargslist:
+            names, defaults, flags = self.com_arglist(args[1:])
+        else:
+            names = defaults = ()
+            flags = 0
+        doc = self.get_docstring(nodelist[4])
+
+        # code for function
+        code = self.com_node(nodelist[4])
+
+        n = Node('function', name, names, defaults, flags, doc, code)
+        n.lineno = lineno
+        return n
+
+    def lambdef(self, nodelist):
+        # lambdef: 'lambda' [varargslist] ':' test
+        if nodelist[2][0] == symbol.varargslist:
+            names, defaults, flags = self.com_arglist(nodelist[2][1:])
+        else:
+            names = defaults = ()
+            flags = 0
+
+        # code for lambda
+        code = self.com_node(nodelist[-1])
+
+        n = Node('lambda', names, defaults, flags, code)
+        n.lineno = nodelist[1][2]
+        return n
+
+    def classdef(self, nodelist):
+        # classdef: 'class' NAME ['(' testlist ')'] ':' suite
+
+        name = nodelist[1][1]
+        doc = self.get_docstring(nodelist[-1])
+        if nodelist[2][0] == token.COLON:
+            bases = []
+        else:
+            bases = self.com_bases(nodelist[3])
+
+        # code for class
+        code = self.com_node(nodelist[-1])
+
+        n = Node('class', name, bases, doc, code)
+        n.lineno = nodelist[1][2]
+        return n
+
+    def stmt(self, nodelist):
+        return self.com_stmt(nodelist[0])
+
+    small_stmt = stmt
+    flow_stmt = stmt
+    compound_stmt = stmt
+
+    def simple_stmt(self, nodelist):
+        # small_stmt (';' small_stmt)* [';'] NEWLINE
+        stmts = [ ]
+        for i in range(0, len(nodelist), 2):
+            self.com_append_stmt(stmts, nodelist[i])
+        return Node('stmt', stmts)
+
+    def parameters(self, nodelist):
+        raise error
+
+    def varargslist(self, nodelist):
+        raise error
+
+    def fpdef(self, nodelist):
+        raise error
+
+    def fplist(self, nodelist):
+        raise error
+
+    def dotted_name(self, nodelist):
+        raise error
+
+    def comp_op(self, nodelist):
+        raise error
+
+    def trailer(self, nodelist):
+        raise error
+
+    def sliceop(self, nodelist):
+        raise error
+
+    def argument(self, nodelist):
+        raise error
+
+    # --------------------------------------------------------------
+    #
+    # STATEMENT NODES  (invoked by com_node())
+    #
+
+    def expr_stmt(self, nodelist):
+        # testlist ('=' testlist)*
+        exprNode = self.com_node(nodelist[-1])
+        if len(nodelist) == 1:
+            return Node('discard', exprNode)
+        nodes = [ ]
+        for i in range(0, len(nodelist) - 2, 2):
+            nodes.append(self.com_assign(nodelist[i], OP_ASSIGN))
+        n = Node('assign', nodes, exprNode)
+        n.lineno = nodelist[1][2]
+        return n
+
+    def print_stmt(self, nodelist):
+        # print: (test ',')* [test]
+        items = [ ]
+        for i in range(1, len(nodelist), 2):
+            items.append(self.com_node(nodelist[i]))
+        if nodelist[-1][0] == token.COMMA:
+            n = Node('print', items)
+            n.lineno = nodelist[0][2]
+            return n
+        n = Node('printnl', items)
+        n.lineno = nodelist[0][2]
+        return n
+
+    def del_stmt(self, nodelist):
+        return self.com_assign(nodelist[1], OP_DELETE)
+
+    def pass_stmt(self, nodelist):
+        # pass:
+        n = Node('pass')
+        n.lineno = nodelist[0][2]
+        return n
+
+    def break_stmt(self, nodelist):
+        # break:
+        n = Node('break')
+        n.lineno = nodelist[0][2]
+        return n
+
+    def continue_stmt(self, nodelist):
+        # continue
+        n = Node('continue')
+        n.lineno = nodelist[0][2]
+        return n
+
+    def return_stmt(self, nodelist):
+        # return: [testlist]
+        if len(nodelist) < 2:
+            n = Node('return', Node('const', None))
+            n.lineno = nodelist[0][2]
+            return n
+        n = Node('return', self.com_node(nodelist[1]))
+        n.lineno = nodelist[0][2]
+        return n
+
+    def raise_stmt(self, nodelist):
+        # raise: [test [',' test [',' test]]]
+        if len(nodelist) > 5:
+            expr3 = self.com_node(nodelist[5])
+        else:
+            expr3 = None
+        if len(nodelist) > 3:
+            expr2 = self.com_node(nodelist[3])
+        else:
+            expr2 = None
+        if len(nodelist) > 1:
+            expr1 = self.com_node(nodelist[1])
+        else:
+            expr1 = None
+        n = Node('raise', expr1, expr2, expr3)
+        n.lineno = nodelist[0][2]
+        return n
+
+    def import_stmt(self, nodelist):
+        # import_stmt: 'import' dotted_as_name (',' dotted_as_name)* |
+        # from: 'from' dotted_name 'import'
+        #                        ('*' | import_as_name (',' import_as_name)*)
+        names = []
+        is_as = 0
+        if nodelist[0][1] == 'from':
+            for i in range(3, len(nodelist), 2):
+                names.append(self.com_import_as_name(nodelist[i][1]))
+            n = Node('from', self.com_dotted_name(nodelist[1]), names)
+            n.lineno = nodelist[0][2]
+            return n
+
+        for i in range(1, len(nodelist), 2):
+            names.append(self.com_dotted_as_name(nodelist[i]))
+        n = Node('import', names)
+        n.lineno = nodelist[0][2]
+        return n
+
+    def global_stmt(self, nodelist):
+        # global: NAME (',' NAME)*
+        names = [ ]
+        for i in range(1, len(nodelist), 2):
+            names.append(nodelist[i][1])
+        n = Node('global', names)
+        n.lineno = nodelist[0][2]
+        return n
+
+    def exec_stmt(self, nodelist):
+        # exec_stmt: 'exec' expr ['in' expr [',' expr]]
+        expr1 = self.com_node(nodelist[1])
+        if len(nodelist) >= 4:
+            expr2 = self.com_node(nodelist[3])
+            if len(nodelist) >= 6:
+                expr3 = self.com_node(nodelist[5])
+            else:
+                expr3 = None
+        else:
+            expr2 = expr3 = None
+
+        n = Node('exec', expr1, expr2, expr3)
+        n.lineno = nodelist[0][2]
+        return n
+
+    def assert_stmt(self, nodelist):
+        # 'assert': test, [',' test]
+        expr1 = self.com_node(nodelist[1])
+        if (len(nodelist) == 4):
+            expr2 = self.com_node(nodelist[3])
+        else:
+            expr2 = Node('name', 'None')
+        n = Node('assert', expr1, expr2)
+        n.lineno = nodelist[0][2]
+        return n
+
+    def if_stmt(self, nodelist):
+        # if: test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
+        tests = [ ]
+        for i in range(0, len(nodelist) - 3, 4):
+            testNode = self.com_node(nodelist[i + 1])
+            suiteNode = self.com_node(nodelist[i + 3])
+            tests.append((testNode, suiteNode))
+
+        if len(nodelist) % 4 == 3:
+            elseNode = self.com_node(nodelist[-1])
+##      elseNode.lineno = nodelist[-1][1][2]
+        else:
+            elseNode = None
+        n = Node('if', tests, elseNode)
+        n.lineno = nodelist[0][2]
+        return n
+
+    def while_stmt(self, nodelist):
+        # 'while' test ':' suite ['else' ':' suite]
+
+        testNode = self.com_node(nodelist[1])
+        bodyNode = self.com_node(nodelist[3])
+
+        if len(nodelist) > 4:
+            elseNode = self.com_node(nodelist[6])
+        else:
+            elseNode = None
+
+        n = Node('while', testNode, bodyNode, elseNode)
+        n.lineno = nodelist[0][2]
+        return n
+
+    def for_stmt(self, nodelist):
+        # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
+
+        assignNode = self.com_assign(nodelist[1], OP_ASSIGN)
+        listNode = self.com_node(nodelist[3])
+        bodyNode = self.com_node(nodelist[5])
+
+        if len(nodelist) > 8:
+            elseNode = self.com_node(nodelist[8])
+        else:
+            elseNode = None
+
+        n = Node('for', assignNode, listNode, bodyNode, elseNode)
+        n.lineno = nodelist[0][2]
+        return n
+
+    def try_stmt(self, nodelist):
+        # 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite]
+        # | 'try' ':' suite 'finally' ':' suite
+        if nodelist[3][0] != symbol.except_clause:
+            return self.com_try_finally(nodelist)
+
+        return self.com_try_except(nodelist)
+
+    def suite(self, nodelist):
+        # simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT
+        if len(nodelist) == 1:
+            return self.com_stmt(nodelist[0])
+
+        stmts = [ ]
+        for node in nodelist:
+            if node[0] == symbol.stmt:
+                self.com_append_stmt(stmts, node)
+        return Node('stmt', stmts)
+
+    # --------------------------------------------------------------
+    #
+    # EXPRESSION NODES  (invoked by com_node())
+    #
+
+    def testlist(self, nodelist):
+        # testlist: expr (',' expr)* [',']
+        # exprlist: expr (',' expr)* [',']
+        return self.com_binary('tuple', nodelist)
+
+    exprlist = testlist
+
+    def test(self, nodelist):
+        # and_test ('or' and_test)* | lambdef
+        if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
+            return self.lambdef(nodelist[0])
+        return self.com_binary('or', nodelist)
+
+    def and_test(self, nodelist):
+        # not_test ('and' not_test)*
+        return self.com_binary('and', nodelist)
+
+    def not_test(self, nodelist):
+        # 'not' not_test | comparison
+        result = self.com_node(nodelist[-1])
+        if len(nodelist) == 2:
+            n = Node('not', result)
+            n.lineno = nodelist[0][2]
+            return n
+        return result
+
+    def comparison(self, nodelist):
+        # comparison: expr (comp_op expr)*
+        node = self.com_node(nodelist[0])
+        if len(nodelist) == 1:
+            return node
+
+        results = [ ]
+        for i in range(2, len(nodelist), 2):
+            nl = nodelist[i-1]
+
+            # comp_op: '<' | '>' | '=' | '>=' | '<=' | '<>' | '!=' | '=='
+            #          | 'in' | 'not' 'in' | 'is' | 'is' 'not'
+            n = nl[1]
+            if n[0] == token.NAME:
+                type = n[1]
+                if len(nl) == 3:
+                    if type == 'not':
+                        type = 'not in'
+                    else:
+                        type = 'is not'
+            else:
+                type = _cmp_types[n[0]]
+
+            lineno = nl[1][2]
+            results.append((type, self.com_node(nodelist[i])))
+
+        # we need a special "compare" node so that we can distinguish
+        #   3 < x < 5   from    (3 < x) < 5
+        # the two have very different semantics and results (note that the
+        # latter form is always true)
+
+        n = Node('compare', node, results)
+        n.lineno = lineno
+        return n
+
+    def expr(self, nodelist):
+        # xor_expr ('|' xor_expr)*
+        return self.com_binary('bitor', nodelist)
+
+    def xor_expr(self, nodelist):
+        # xor_expr ('^' xor_expr)*
+        return self.com_binary('bitxor', nodelist)
+
+    def and_expr(self, nodelist):
+        # xor_expr ('&' xor_expr)*
+        return self.com_binary('bitand', nodelist)
+
+    def shift_expr(self, nodelist):
+        # shift_expr ('<<'|'>>' shift_expr)*
+        node = self.com_node(nodelist[0])
+        for i in range(2, len(nodelist), 2):
+            right = self.com_node(nodelist[i])
+            if nodelist[i-1][0] == token.LEFTSHIFT:
+                node = Node('<<', [node, right])
+                node.lineno = nodelist[1][2]
+            else:
+                node = Node('>>', [node, right])
+                node.lineno = nodelist[1][2]
+        return node
+
+    def arith_expr(self, nodelist):
+        node = self.com_node(nodelist[0])
+        for i in range(2, len(nodelist), 2):
+            right = self.com_node(nodelist[i])
+            if nodelist[i-1][0] == token.PLUS:
+                node = Node('+', [node, right])
+                node.lineno = nodelist[1][2]
+            else:
+                node = Node('-', [node, right])
+                node.lineno = nodelist[1][2]
+        return node
+
+    def term(self, nodelist):
+        node = self.com_node(nodelist[0])
+        for i in range(2, len(nodelist), 2):
+            right = self.com_node(nodelist[i])
+            if nodelist[i-1][0] == token.STAR:
+                node = Node('*', [node, right])
+                node.lineno = nodelist[1][2]
+            elif nodelist[i-1][0] == token.SLASH:
+                node = Node('/', [node, right])
+                node.lineno = nodelist[1][2]
+            else:
+                node = Node('%', [node, right])
+                node.lineno = nodelist[1][2]
+        return node
+
+    def factor(self, nodelist):
+        t = nodelist[0][0]
+        node = self.com_node(nodelist[-1])
+        if t == token.PLUS:
+            node = Node('unary+', node)
+            node.lineno = nodelist[0][2]
+        elif t == token.MINUS:
+            node = Node('unary-', node)
+            node.lineno = nodelist[0][2]
+        elif t == token.TILDE:
+            node = Node('invert', node)
+            node.lineno = nodelist[0][2]
+        return node
+
+    def power(self, nodelist):
+        # power: atom trailer* ('**' factor)*
+        node = self.com_node(nodelist[0])
+        for i in range(1, len(nodelist)):
+            if nodelist[i][0] == token.DOUBLESTAR:
+                n = Node('power', [node, self.com_node(nodelist[i+1])])
+                n.lineno = nodelist[i][2]
+                return n
+
+            node = self.com_apply_trailer(node, nodelist[i])
+
+        return node
+
+    def atom(self, nodelist):
+        t = nodelist[0][0]
+        if t == token.LPAR:
+            if nodelist[1][0] == token.RPAR:
+                n = Node('tuple', ())
+                n.lineno = nodelist[0][2]
+                return n
+            return self.com_node(nodelist[1])
+
+        if t == token.LSQB:
+            if nodelist[1][0] == token.RSQB:
+                n = Node('list', ())
+                n.lineno = nodelist[0][2]
+                return n
+            return self.com_list_constructor(nodelist[1])
+
+        if t == token.LBRACE:
+            if nodelist[1][0] == token.RBRACE:
+                return Node('dict', ())
+            return self.com_dictmaker(nodelist[1])
+
+        if t == token.BACKQUOTE:
+            n = Node('backquote', self.com_node(nodelist[1]))
+            n.lineno = nodelist[0][2]
+            return n
+
+        if t == token.NUMBER:
+            ### need to verify this matches compile.c
+            k = eval(nodelist[0][1])
+            n = Node('const', k)
+            n.lineno = nodelist[0][2]
+            return n
+
+        if t == token.STRING:
+            ### need to verify this matches compile.c
+            k = ''
+            for node in nodelist:
+                k = k + eval(node[1])
+            n = Node('const', k)
+            n.lineno = nodelist[0][2]
+            return n
+
+        if t == token.NAME:
+            ### any processing to do?
+            n = Node('name', nodelist[0][1])
+            n.lineno = nodelist[0][2]
+            return n
+
+        raise error, "unknown node type"
+
+    # --------------------------------------------------------------
+    #
+    # INTERNAL PARSING UTILITIES
+    #
+
+    def com_node(self, node):
+        # Note: compile.c has handling in com_node for del_stmt, pass_stmt,
+        #       break_stmt, stmt, small_stmt, flow_stmt, simple_stmt,
+        #       and compound_stmt.
+        #       We'll just dispatch them.
+
+        #
+        # A ';' at the end of a line can make a NEWLINE token appear here,
+        # Render it harmless. (genc discards ('discard', ('const', xxxx)) Nodes)
+        # 
+        if node[0] == token.NEWLINE:
+            return Node('discard', Node('const', None))
+
+        if node[0] not in _legal_node_types:
+            raise error, 'illegal node passed to com_node: %s' % node[0]
 
 #    print "dispatch", self._dispatch[node[0]].__name__, node
-    return self._dispatch[node[0]](node[1:])
+        return self._dispatch[node[0]](node[1:])
 
-  def com_arglist(self, nodelist):
-    # varargslist:
-    #   (fpdef ['=' test] ',')* ('*' NAME [',' ('**'|'*' '*') NAME]
-    #  | fpdef ['=' test] (',' fpdef ['=' test])* [',']
-    #  | ('**'|'*' '*') NAME)
-    # fpdef: NAME | '(' fplist ')'
-    # fplist: fpdef (',' fpdef)* [',']
-    names = [ ]
-    defaults = [ ]
-    flags = 0
+    def com_arglist(self, nodelist):
+        # varargslist:
+        #   (fpdef ['=' test] ',')* ('*' NAME [',' ('**'|'*' '*') NAME]
+        #  | fpdef ['=' test] (',' fpdef ['=' test])* [',']
+        #  | ('**'|'*' '*') NAME)
+        # fpdef: NAME | '(' fplist ')'
+        # fplist: fpdef (',' fpdef)* [',']
+        names = [ ]
+        defaults = [ ]
+        flags = 0
 
-    i = 0
-    while i < len(nodelist):
-      node = nodelist[i]
-      if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
-        if node[0] == token.STAR:
-          node = nodelist[i+1]
-          if node[0] == token.NAME:
-            names.append(node[1])
-            flags = flags | CO_VARARGS
-            i = i + 3
+        i = 0
+        while i < len(nodelist):
+            node = nodelist[i]
+            if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
+                if node[0] == token.STAR:
+                    node = nodelist[i+1]
+                    if node[0] == token.NAME:
+                        names.append(node[1])
+                        flags = flags | CO_VARARGS
+                        i = i + 3
 
-        if i < len(nodelist):
-          # should be DOUBLESTAR or STAR STAR
-          if nodelist[i][0] == token.DOUBLESTAR:
-            node = nodelist[i+1]
-          else:
-            node = nodelist[i+2]
-          names.append(node[1])
-          flags = flags | CO_VARKEYWORDS
+                if i < len(nodelist):
+                    # should be DOUBLESTAR or STAR STAR
+                    if nodelist[i][0] == token.DOUBLESTAR:
+                        node = nodelist[i+1]
+                    else:
+                        node = nodelist[i+2]
+                    names.append(node[1])
+                    flags = flags | CO_VARKEYWORDS
 
-        break
+                break
 
-      # fpdef: NAME | '(' fplist ')'
-      names.append(self.com_fpdef(node))
+            # fpdef: NAME | '(' fplist ')'
+            names.append(self.com_fpdef(node))
 
-      i = i + 1
-      if i >= len(nodelist):
-        break
+            i = i + 1
+            if i >= len(nodelist):
+                break
 
-      if nodelist[i][0] == token.EQUAL:
-        defaults.append(self.com_node(nodelist[i + 1]))
-        i = i + 2
-      elif len(defaults):
-        # Treat "(a=1, b)" as "(a=1, b=None)"
-        defaults.append(Node('const', None))
+            if nodelist[i][0] == token.EQUAL:
+                defaults.append(self.com_node(nodelist[i + 1]))
+                i = i + 2
+            elif len(defaults):
+                # Treat "(a=1, b)" as "(a=1, b=None)"
+                defaults.append(Node('const', None))
 
-      i = i + 1
+            i = i + 1
 
-    return names, defaults, flags
+        return names, defaults, flags
 
-  def com_fpdef(self, node):
-    # fpdef: NAME | '(' fplist ')'
-    if node[1][0] == token.LPAR:
-      return self.com_fplist(node[2])
-    return node[1][1]
+    def com_fpdef(self, node):
+        # fpdef: NAME | '(' fplist ')'
+        if node[1][0] == token.LPAR:
+            return self.com_fplist(node[2])
+        return node[1][1]
 
-  def com_fplist(self, node):
-    # fplist: fpdef (',' fpdef)* [','] 
-    if len(node) == 2:
-      return self.com_fpdef(node[1])
-    list = [ ]
-    for i in range(1, len(node), 2):
-      list.append(self.com_fpdef(node[i]))
-    return tuple(list)
+    def com_fplist(self, node):
+        # fplist: fpdef (',' fpdef)* [','] 
+        if len(node) == 2:
+            return self.com_fpdef(node[1])
+        list = [ ]
+        for i in range(1, len(node), 2):
+            list.append(self.com_fpdef(node[i]))
+        return tuple(list)
 
-  def com_dotted_name(self, node):
-    # String together the dotted names and return the string
-    name = ""
-    for n in node:
-      if type(n) == type(()) and n[0] == 1:
-        name = name + n[1] + '.'
-    return name[:-1]
+    def com_dotted_name(self, node):
+        # String together the dotted names and return the string
+        name = ""
+        for n in node:
+            if type(n) == type(()) and n[0] == 1:
+                name = name + n[1] + '.'
+        return name[:-1]
 
-  def com_dotted_as_name(self, node):
-    dot = self.com_dotted_name(node[1])
-    if len(node) == 2:
-      return dot, None
-    assert node[2][1] == 'as'
-    assert node[3][0] == token.NAME
-    return dot, node[3][1]
+    def com_dotted_as_name(self, node):
+        dot = self.com_dotted_name(node[1])
+        if len(node) == 2:
+            return dot, None
+        assert node[2][1] == 'as'
+        assert node[3][0] == token.NAME
+        return dot, node[3][1]
 
-  def com_import_as_name(self, node):
-    if node[0] == token.NAME:
-      return node[1], None
-    assert len(node) == 4
-    assert node[2][1] == 'as'
-    assert node[3][0] == token.NAME
-    return node[1][1], node[3][1]
+    def com_import_as_name(self, node):
+        if node[0] == token.NAME:
+            return node[1], None
+        assert len(node) == 4
+        assert node[2][1] == 'as'
+        assert node[3][0] == token.NAME
+        return node[1][1], node[3][1]
 
-  def com_bases(self, node):
-    bases = [ ]
-    for i in range(1, len(node), 2):
-      bases.append(self.com_node(node[i]))
-    return bases
+    def com_bases(self, node):
+        bases = [ ]
+        for i in range(1, len(node), 2):
+            bases.append(self.com_node(node[i]))
+        return bases
 
-  def com_try_finally(self, nodelist):
-    # try_fin_stmt: "try" ":" suite "finally" ":" suite
-    n = Node('tryfinally', self.com_node(nodelist[2]), self.com_node(nodelist[5]))
-    n.lineno = nodelist[0][2]
-    return n
+    def com_try_finally(self, nodelist):
+        # try_fin_stmt: "try" ":" suite "finally" ":" suite
+        n = Node('tryfinally', self.com_node(nodelist[2]), self.com_node(nodelist[5]))
+        n.lineno = nodelist[0][2]
+        return n
 
-  def com_try_except(self, nodelist):
-    # try_except: 'try' ':' suite (except_clause ':' suite)* ['else' suite]
-    #tryexcept:  [TryNode, [except_clauses], elseNode)]
-    stmt = self.com_node(nodelist[2])
-    clauses = []
-    elseNode = None
-    for i in range(3, len(nodelist), 3):
-      node = nodelist[i]
-      if node[0] == symbol.except_clause:
-        # except_clause: 'except' [expr [',' expr]] */
-        if len(node) > 2:
-          expr1 = self.com_node(node[2])
-          if len(node) > 4:
-            expr2 = self.com_assign(node[4], OP_ASSIGN)
-          else:
-            expr2 = None
-        else:
-          expr1 = expr2 = None
-        clauses.append((expr1, expr2, self.com_node(nodelist[i+2])))
+    def com_try_except(self, nodelist):
+        # try_except: 'try' ':' suite (except_clause ':' suite)* ['else' suite]
+        #tryexcept:  [TryNode, [except_clauses], elseNode)]
+        stmt = self.com_node(nodelist[2])
+        clauses = []
+        elseNode = None
+        for i in range(3, len(nodelist), 3):
+            node = nodelist[i]
+            if node[0] == symbol.except_clause:
+                # except_clause: 'except' [expr [',' expr]] */
+                if len(node) > 2:
+                    expr1 = self.com_node(node[2])
+                    if len(node) > 4:
+                        expr2 = self.com_assign(node[4], OP_ASSIGN)
+                    else:
+                        expr2 = None
+                else:
+                    expr1 = expr2 = None
+                clauses.append((expr1, expr2, self.com_node(nodelist[i+2])))
 
-      if node[0] == token.NAME:
-        elseNode = self.com_node(nodelist[i+2])
-    n = Node('tryexcept', self.com_node(nodelist[2]), clauses, elseNode)
-    n.lineno = nodelist[0][2]
-    return n
+            if node[0] == token.NAME:
+                elseNode = self.com_node(nodelist[i+2])
+        n = Node('tryexcept', self.com_node(nodelist[2]), clauses, elseNode)
+        n.lineno = nodelist[0][2]
+        return n
 
-  def com_assign(self, node, assigning):
-    # return a node suitable for use as an "lvalue"
-    # loop to avoid trivial recursion
-    while 1:
-      t = node[0]
-      if t == symbol.exprlist or t == symbol.testlist:
-        if len(node) > 2:
-          return self.com_assign_tuple(node, assigning)
-        node = node[1]
-      elif t in _assign_types:
-        if len(node) > 2:
-          raise SyntaxError, "can't assign to operator"
-        node = node[1]
-      elif t == symbol.power:
-        if node[1][0] != symbol.atom:
-          raise SyntaxError, "can't assign to operator"
-        if len(node) > 2:
-          primary = self.com_node(node[1])
-          for i in range(2, len(node)-1):
-            ch = node[i]
-            if ch[0] == token.DOUBLESTAR:
-              raise SyntaxError, "can't assign to operator"
-            primary = self.com_apply_trailer(primary, ch)
-          return self.com_assign_trailer(primary, node[-1], assigning)
-        node = node[1]
-      elif t == symbol.atom:
+    def com_assign(self, node, assigning):
+        # return a node suitable for use as an "lvalue"
+        # loop to avoid trivial recursion
+        while 1:
+            t = node[0]
+            if t == symbol.exprlist or t == symbol.testlist:
+                if len(node) > 2:
+                    return self.com_assign_tuple(node, assigning)
+                node = node[1]
+            elif t in _assign_types:
+                if len(node) > 2:
+                    raise SyntaxError, "can't assign to operator"
+                node = node[1]
+            elif t == symbol.power:
+                if node[1][0] != symbol.atom:
+                    raise SyntaxError, "can't assign to operator"
+                if len(node) > 2:
+                    primary = self.com_node(node[1])
+                    for i in range(2, len(node)-1):
+                        ch = node[i]
+                        if ch[0] == token.DOUBLESTAR:
+                            raise SyntaxError, "can't assign to operator"
+                        primary = self.com_apply_trailer(primary, ch)
+                    return self.com_assign_trailer(primary, node[-1], assigning)
+                node = node[1]
+            elif t == symbol.atom:
+                t = node[1][0]
+                if t == token.LPAR:
+                    node = node[2]
+                    if node[0] == token.RPAR:
+                        raise SyntaxError, "can't assign to ()"
+                elif t == token.LSQB:
+                    node = node[2]
+                    if node[0] == token.RSQB:
+                        raise SyntaxError, "can't assign to []"
+                    return self.com_assign_list(node, assigning)
+                elif t == token.NAME:
+                    return self.com_assign_name(node[1], assigning)
+                else:
+                    raise SyntaxError, "can't assign to literal"
+            else:
+                raise SyntaxError, "bad assignment"
+
+    def com_assign_tuple(self, node, assigning):
+        assigns = [ ]
+        for i in range(1, len(node), 2):
+            assigns.append(self.com_assign(node[i], assigning))
+        return Node('ass_tuple', assigns)
+
+    def com_assign_list(self, node, assigning):
+        assigns = [ ]
+        for i in range(1, len(node), 2):
+            assigns.append(self.com_assign(node[i], assigning))
+        return Node('ass_list', assigns)
+
+    def com_assign_name(self, node, assigning):
+        n = Node('ass_name', node[1], assigning)
+        n.lineno = node[2]
+        return n
+
+    def com_assign_trailer(self, primary, node, assigning):
         t = node[1][0]
         if t == token.LPAR:
-          node = node[2]
-          if node[0] == token.RPAR:
-            raise SyntaxError, "can't assign to ()"
-        elif t == token.LSQB:
-          node = node[2]
-          if node[0] == token.RSQB:
-            raise SyntaxError, "can't assign to []"
-          return self.com_assign_list(node, assigning)
-        elif t == token.NAME:
-          return self.com_assign_name(node[1], assigning)
+            raise SyntaxError, "can't assign to function call"
+        if t == token.DOT:
+            return self.com_assign_attr(primary, node[2], assigning)
+        if t == token.LSQB:
+            return self.com_subscriptlist(primary, node[2], assigning)
+        raise SyntaxError, "unknown trailer type: %s" % t
+
+    def com_assign_attr(self, primary, node, assigning):
+        return Node('ass_attr', primary, node[1], assigning)
+
+    def com_binary(self, type, nodelist):
+        "Compile 'NODE (OP NODE)*' into (type, [ node1, ..., nodeN ])."
+        if len(nodelist) == 1:
+            return self.com_node(nodelist[0])
+        items = [ ]
+        for i in range(0, len(nodelist), 2):
+            items.append(self.com_node(nodelist[i]))
+        return Node(type, items)
+
+    def com_stmt(self, node):
+        #pprint.pprint(node)
+        result = self.com_node(node)
+        try:
+            result[0]
+        except:
+            print node[0]
+        if result[0] == 'stmt':
+            return result
+        return Node('stmt', [ result ])
+
+    def com_append_stmt(self, stmts, node):
+        result = self.com_node(node)
+        try:
+            result[0]
+        except:
+            print node
+        if result[0] == 'stmt':
+            stmts[len(stmts):] = result[1]
         else:
-          raise SyntaxError, "can't assign to literal"
-      else:
-        raise SyntaxError, "bad assignment"
+            stmts.append(result)
 
-  def com_assign_tuple(self, node, assigning):
-    assigns = [ ]
-    for i in range(1, len(node), 2):
-      assigns.append(self.com_assign(node[i], assigning))
-    return Node('ass_tuple', assigns)
+    def com_list_constructor(self, nodelist):
+        values = [ ]
+        for i in range(1, len(nodelist), 2):
+            values.append(self.com_node(nodelist[i]))
+        return Node('list', values)
 
-  def com_assign_list(self, node, assigning):
-    assigns = [ ]
-    for i in range(1, len(node), 2):
-      assigns.append(self.com_assign(node[i], assigning))
-    return Node('ass_list', assigns)
+    def com_dictmaker(self, nodelist):
+        # dictmaker: test ':' test (',' test ':' value)* [',']
+        items = [ ]
+        for i in range(1, len(nodelist), 4):
+            items.append((self.com_node(nodelist[i]), self.com_node(nodelist[i+2])))
+        return Node('dict', items)
 
-  def com_assign_name(self, node, assigning):
-    n = Node('ass_name', node[1], assigning)
-    n.lineno = node[2]
-    return n
+    def com_apply_trailer(self, primaryNode, nodelist):
+        t = nodelist[1][0]
+        if t == token.LPAR:
+            return self.com_call_function(primaryNode, nodelist[2])
+        if t == token.DOT:
+            return self.com_select_member(primaryNode, nodelist[2])
+        if t == token.LSQB:
+            return self.com_subscriptlist(primaryNode, nodelist[2], OP_APPLY)
 
-  def com_assign_trailer(self, primary, node, assigning):
-    t = node[1][0]
-    if t == token.LPAR:
-      raise SyntaxError, "can't assign to function call"
-    if t == token.DOT:
-      return self.com_assign_attr(primary, node[2], assigning)
-    if t == token.LSQB:
-      return self.com_subscriptlist(primary, node[2], assigning)
-    raise SyntaxError, "unknown trailer type: %s" % t
+        raise SyntaxError, 'unknown node type: %s' % t
 
-  def com_assign_attr(self, primary, node, assigning):
-    return Node('ass_attr', primary, node[1], assigning)
+    def com_select_member(self, primaryNode, nodelist):
+        if nodelist[0] != token.NAME:
+            raise SyntaxError, "member must be a name"
+        n = Node('getattr', primaryNode, nodelist[1])
+        n.lineno = nodelist[2]
+        return n
 
-  def com_binary(self, type, nodelist):
-    "Compile 'NODE (OP NODE)*' into (type, [ node1, ..., nodeN ])."
-    if len(nodelist) == 1:
-      return self.com_node(nodelist[0])
-    items = [ ]
-    for i in range(0, len(nodelist), 2):
-      items.append(self.com_node(nodelist[i]))
-    return Node(type, items)
-
-  def com_stmt(self, node):
-    #pprint.pprint(node)
-    result = self.com_node(node)
-    try:
-      result[0]
-    except:
-      print node[0]
-    if result[0] == 'stmt':
-      return result
-    return Node('stmt', [ result ])
-
-  def com_append_stmt(self, stmts, node):
-    result = self.com_node(node)
-    try:
-      result[0]
-    except:
-      print node
-    if result[0] == 'stmt':
-      stmts[len(stmts):] = result[1]
-    else:
-      stmts.append(result)
-
-  def com_list_constructor(self, nodelist):
-    values = [ ]
-    for i in range(1, len(nodelist), 2):
-      values.append(self.com_node(nodelist[i]))
-    return Node('list', values)
-
-  def com_dictmaker(self, nodelist):
-    # dictmaker: test ':' test (',' test ':' value)* [',']
-    items = [ ]
-    for i in range(1, len(nodelist), 4):
-      items.append((self.com_node(nodelist[i]), self.com_node(nodelist[i+2])))
-    return Node('dict', items)
-
-  def com_apply_trailer(self, primaryNode, nodelist):
-    t = nodelist[1][0]
-    if t == token.LPAR:
-      return self.com_call_function(primaryNode, nodelist[2])
-    if t == token.DOT:
-      return self.com_select_member(primaryNode, nodelist[2])
-    if t == token.LSQB:
-      return self.com_subscriptlist(primaryNode, nodelist[2], OP_APPLY)
-
-    raise SyntaxError, 'unknown node type: %s' % t
-
-  def com_select_member(self, primaryNode, nodelist):
-    if nodelist[0] != token.NAME:
-      raise SyntaxError, "member must be a name"
-    n = Node('getattr', primaryNode, nodelist[1])
-    n.lineno = nodelist[2]
-    return n
-
-  def com_call_function(self, primaryNode, nodelist):
-    if nodelist[0] == token.RPAR:
-      return Node('call_func', primaryNode, [ ])
-    args = [ ]
-    kw = 0
-    len_nodelist = len(nodelist)
-    for i in range(1, len_nodelist, 2):
-      node = nodelist[i]
-      if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
-          break
-      kw, result = self.com_argument(node, kw)
-      args.append(result)
-    else:
-        i = i + 1 # No broken by star arg, so skip the last one we processed.
-    if i < len_nodelist and nodelist[i][0] == token.COMMA:
-        # need to accept an application that looks like "f(a, b,)"
-        i = i + 1
-    star_node = dstar_node = None
-    while i < len_nodelist:
-        tok = nodelist[i]
-        ch = nodelist[i+1]
-        i = i + 3
-        if tok[0]==token.STAR:
-            if star_node is not None:
-                raise SyntaxError, 'already have the varargs indentifier'
-            star_node = self.com_node(ch)
-        elif tok[0]==token.DOUBLESTAR:
-            if dstar_node is not None:
-                raise SyntaxError, 'already have the kwargs indentifier'
-            dstar_node = self.com_node(ch)
+    def com_call_function(self, primaryNode, nodelist):
+        if nodelist[0] == token.RPAR:
+            return Node('call_func', primaryNode, [ ])
+        args = [ ]
+        kw = 0
+        len_nodelist = len(nodelist)
+        for i in range(1, len_nodelist, 2):
+            node = nodelist[i]
+            if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
+                    break
+            kw, result = self.com_argument(node, kw)
+            args.append(result)
         else:
-            raise SyntaxError, 'unknown node type: %s' % tok
+                i = i + 1 # No broken by star arg, so skip the last one we processed.
+        if i < len_nodelist and nodelist[i][0] == token.COMMA:
+                # need to accept an application that looks like "f(a, b,)"
+                i = i + 1
+        star_node = dstar_node = None
+        while i < len_nodelist:
+                tok = nodelist[i]
+                ch = nodelist[i+1]
+                i = i + 3
+                if tok[0]==token.STAR:
+                        if star_node is not None:
+                                raise SyntaxError, 'already have the varargs indentifier'
+                        star_node = self.com_node(ch)
+                elif tok[0]==token.DOUBLESTAR:
+                        if dstar_node is not None:
+                                raise SyntaxError, 'already have the kwargs indentifier'
+                        dstar_node = self.com_node(ch)
+                else:
+                        raise SyntaxError, 'unknown node type: %s' % tok
 
-    return Node('call_func', primaryNode, args, star_node, dstar_node)
+        return Node('call_func', primaryNode, args, star_node, dstar_node)
 
-  def com_argument(self, nodelist, kw):
-    if len(nodelist) == 2:
-      if kw:
-        raise SyntaxError, "non-keyword arg after keyword arg"
-      return 0, self.com_node(nodelist[1])
-    result = self.com_node(nodelist[3])
-    n = nodelist[1]
-    while len(n) == 2 and n[0] != token.NAME:
-      n = n[1]
-    if n[0] != token.NAME:
-      raise SyntaxError, "keyword can't be an expression (%s)"%n[0]
-    node = Node('keyword', n[1], result)
-    node.lineno = n[2]
-    return 1, node
+    def com_argument(self, nodelist, kw):
+        if len(nodelist) == 2:
+            if kw:
+                raise SyntaxError, "non-keyword arg after keyword arg"
+            return 0, self.com_node(nodelist[1])
+        result = self.com_node(nodelist[3])
+        n = nodelist[1]
+        while len(n) == 2 and n[0] != token.NAME:
+            n = n[1]
+        if n[0] != token.NAME:
+            raise SyntaxError, "keyword can't be an expression (%s)"%n[0]
+        node = Node('keyword', n[1], result)
+        node.lineno = n[2]
+        return 1, node
 
-  def com_subscriptlist(self, primary, nodelist, assigning):
-    # slicing:      simple_slicing | extended_slicing
-    # simple_slicing:   primary "[" short_slice "]"
-    # extended_slicing: primary "[" slice_list "]" 
-    # slice_list:   slice_item ("," slice_item)* [","]
+    def com_subscriptlist(self, primary, nodelist, assigning):
+        # slicing:      simple_slicing | extended_slicing
+        # simple_slicing:   primary "[" short_slice "]"
+        # extended_slicing: primary "[" slice_list "]" 
+        # slice_list:   slice_item ("," slice_item)* [","]
 
-    # backwards compat slice for '[i:j]'
-    if len(nodelist) == 2:
-      sub = nodelist[1]
-      if (sub[1][0] == token.COLON or \
-              (len(sub) > 2 and sub[2][0] == token.COLON)) and \
-             sub[-1][0] != symbol.sliceop:
-        return self.com_slice(primary, sub, assigning)
+        # backwards compat slice for '[i:j]'
+        if len(nodelist) == 2:
+            sub = nodelist[1]
+            if (sub[1][0] == token.COLON or \
+                            (len(sub) > 2 and sub[2][0] == token.COLON)) and \
+                            sub[-1][0] != symbol.sliceop:
+                return self.com_slice(primary, sub, assigning)
 
-    subscripts = [ ]
-    for i in range(1, len(nodelist), 2):
-      subscripts.append(self.com_subscript(nodelist[i]))
+        subscripts = [ ]
+        for i in range(1, len(nodelist), 2):
+            subscripts.append(self.com_subscript(nodelist[i]))
 
-    return Node('subscript', primary, assigning, subscripts)
+        return Node('subscript', primary, assigning, subscripts)
 
-  def com_subscript(self, node):
-    # slice_item: expression | proper_slice | ellipsis
-    ch = node[1]
-    if ch[0] == token.DOT and node[2][0] == token.DOT:
-      return Node('ellipsis')
-    if ch[0] == token.COLON or len(node) > 2:
-      return self.com_sliceobj(node)
-    return self.com_node(ch)
+    def com_subscript(self, node):
+        # slice_item: expression | proper_slice | ellipsis
+        ch = node[1]
+        if ch[0] == token.DOT and node[2][0] == token.DOT:
+            return Node('ellipsis')
+        if ch[0] == token.COLON or len(node) > 2:
+            return self.com_sliceobj(node)
+        return self.com_node(ch)
 
-  def com_sliceobj(self, node):
-    # proper_slice: short_slice | long_slice
-    # short_slice:  [lower_bound] ":" [upper_bound]
-    # long_slice:   short_slice ":" [stride]
-    # lower_bound:  expression
-    # upper_bound:  expression
-    # stride:       expression
-    #
-    # Note: a stride may be further slicing...
+    def com_sliceobj(self, node):
+        # proper_slice: short_slice | long_slice
+        # short_slice:  [lower_bound] ":" [upper_bound]
+        # long_slice:   short_slice ":" [stride]
+        # lower_bound:  expression
+        # upper_bound:  expression
+        # stride:       expression
+        #
+        # Note: a stride may be further slicing...
 
-    items = [ ]
+        items = [ ]
 
-    if node[1][0] == token.COLON:
-      items.append(Node('const', None))
-      i = 2
-    else:
-      items.append(self.com_node(node[1]))
-      # i == 2 is a COLON
-      i = 3
+        if node[1][0] == token.COLON:
+            items.append(Node('const', None))
+            i = 2
+        else:
+            items.append(self.com_node(node[1]))
+            # i == 2 is a COLON
+            i = 3
 
-    if i < len(node) and node[i][0] == symbol.test:
-      items.append(self.com_node(node[i]))
-      i = i + 1
-    else:
-      items.append(Node('const', None))
+        if i < len(node) and node[i][0] == symbol.test:
+            items.append(self.com_node(node[i]))
+            i = i + 1
+        else:
+            items.append(Node('const', None))
 
-    # a short_slice has been built. look for long_slice now by looking
-    # for strides...
-    for j in range(i, len(node)):
-      ch = node[j]
-      if len(ch) == 2:
-        items.append(Node('const', None))
-      else:
-        items.append(self.com_node(ch[2]))
+        # a short_slice has been built. look for long_slice now by looking
+        # for strides...
+        for j in range(i, len(node)):
+            ch = node[j]
+            if len(ch) == 2:
+                items.append(Node('const', None))
+            else:
+                items.append(self.com_node(ch[2]))
 
-    return Node('sliceobj', items)
+        return Node('sliceobj', items)
 
-  def com_slice(self, primary, node, assigning):
-    # short_slice:  [lower_bound] ":" [upper_bound]
-    lower = upper = None
-    if len(node) == 3:
-      if node[1][0] == token.COLON:
-        upper = self.com_node(node[2])
-      else:
-        lower = self.com_node(node[1])
-    elif len(node) == 4:
-      lower = self.com_node(node[1])
-      upper = self.com_node(node[3])
-    return Node('slice', primary, assigning, lower, upper)
+    def com_slice(self, primary, node, assigning):
+        # short_slice:  [lower_bound] ":" [upper_bound]
+        lower = upper = None
+        if len(node) == 3:
+            if node[1][0] == token.COLON:
+                upper = self.com_node(node[2])
+            else:
+                lower = self.com_node(node[1])
+        elif len(node) == 4:
+            lower = self.com_node(node[1])
+            upper = self.com_node(node[3])
+        return Node('slice', primary, assigning, lower, upper)
 
-  def get_docstring(self, node, n=None):
-    if n is None:
-      n = node[0]
-      node = node[1:]
-    if n == symbol.suite:
-      if len(node) == 1:
-        return self.get_docstring(node[0])
-      for sub in node:
-        if sub[0] == symbol.stmt:
-          return self.get_docstring(sub)
-      return None
-    if n == symbol.file_input:
-      for sub in node:
-        if sub[0] == symbol.stmt:
-          return self.get_docstring(sub)
-      return None
-    if n == symbol.atom:
-      if node[0][0] == token.STRING:
-        s = ''
-        for t in node:
-          s = s + eval(t[1])
-        return s
-      return None
-    if n == symbol.stmt or n == symbol.simple_stmt or n == symbol.small_stmt:
-      return self.get_docstring(node[0])
-    if n in _doc_nodes and len(node) == 1:
-      return self.get_docstring(node[0])
-    return None
+    def get_docstring(self, node, n=None):
+        if n is None:
+            n = node[0]
+            node = node[1:]
+        if n == symbol.suite:
+            if len(node) == 1:
+                return self.get_docstring(node[0])
+            for sub in node:
+                if sub[0] == symbol.stmt:
+                    return self.get_docstring(sub)
+            return None
+        if n == symbol.file_input:
+            for sub in node:
+                if sub[0] == symbol.stmt:
+                    return self.get_docstring(sub)
+            return None
+        if n == symbol.atom:
+            if node[0][0] == token.STRING:
+                s = ''
+                for t in node:
+                    s = s + eval(t[1])
+                return s
+            return None
+        if n == symbol.stmt or n == symbol.simple_stmt or n == symbol.small_stmt:
+            return self.get_docstring(node[0])
+        if n in _doc_nodes and len(node) == 1:
+            return self.get_docstring(node[0])
+        return None
 
 
 _doc_nodes = [
-  symbol.expr_stmt,
-  symbol.testlist,
-  symbol.test,
-  symbol.and_test,
-  symbol.not_test,
-  symbol.comparison,
-  symbol.expr,
-  symbol.xor_expr,
-  symbol.and_expr,
-  symbol.shift_expr,
-  symbol.arith_expr,
-  symbol.term,
-  symbol.factor,
-  symbol.power,
-  ]
+    symbol.expr_stmt,
+    symbol.testlist,
+    symbol.test,
+    symbol.and_test,
+    symbol.not_test,
+    symbol.comparison,
+    symbol.expr,
+    symbol.xor_expr,
+    symbol.and_expr,
+    symbol.shift_expr,
+    symbol.arith_expr,
+    symbol.term,
+    symbol.factor,
+    symbol.power,
+    ]
 
 # comp_op: '<' | '>' | '=' | '>=' | '<=' | '<>' | '!=' | '=='
 #             | 'in' | 'not' 'in' | 'is' | 'is' 'not'
 _cmp_types = {
-  token.LESS : '<',
-  token.GREATER : '>',
-  token.EQEQUAL : '==',
-  token.EQUAL : '==',
-  token.LESSEQUAL : '<=',
-  token.GREATEREQUAL : '>=',
-  token.NOTEQUAL : '!=',
-  }
+    token.LESS : '<',
+    token.GREATER : '>',
+    token.EQEQUAL : '==',
+    token.EQUAL : '==',
+    token.LESSEQUAL : '<=',
+    token.GREATEREQUAL : '>=',
+    token.NOTEQUAL : '!=',
+    }
 
 _legal_node_types = [
-  symbol.funcdef,
-  symbol.classdef,
-  symbol.stmt,
-  symbol.small_stmt,
-  symbol.flow_stmt,
-  symbol.simple_stmt,
-  symbol.compound_stmt,
-  symbol.expr_stmt,
-  symbol.print_stmt,
-  symbol.del_stmt,
-  symbol.pass_stmt,
-  symbol.break_stmt,
-  symbol.continue_stmt,
-  symbol.return_stmt,
-  symbol.raise_stmt,
-  symbol.import_stmt,
-  symbol.global_stmt,
-  symbol.exec_stmt,
-  symbol.assert_stmt,
-  symbol.if_stmt,
-  symbol.while_stmt,
-  symbol.for_stmt,
-  symbol.try_stmt,
-  symbol.suite,
-  symbol.testlist,
-  symbol.test,
-  symbol.and_test,
-  symbol.not_test,
-  symbol.comparison,
-  symbol.exprlist,
-  symbol.expr,
-  symbol.xor_expr,
-  symbol.and_expr,
-  symbol.shift_expr,
-  symbol.arith_expr,
-  symbol.term,
-  symbol.factor,
-  symbol.power,
-  symbol.atom,
-  ]
+    symbol.funcdef,
+    symbol.classdef,
+    symbol.stmt,
+    symbol.small_stmt,
+    symbol.flow_stmt,
+    symbol.simple_stmt,
+    symbol.compound_stmt,
+    symbol.expr_stmt,
+    symbol.print_stmt,
+    symbol.del_stmt,
+    symbol.pass_stmt,
+    symbol.break_stmt,
+    symbol.continue_stmt,
+    symbol.return_stmt,
+    symbol.raise_stmt,
+    symbol.import_stmt,
+    symbol.global_stmt,
+    symbol.exec_stmt,
+    symbol.assert_stmt,
+    symbol.if_stmt,
+    symbol.while_stmt,
+    symbol.for_stmt,
+    symbol.try_stmt,
+    symbol.suite,
+    symbol.testlist,
+    symbol.test,
+    symbol.and_test,
+    symbol.not_test,
+    symbol.comparison,
+    symbol.exprlist,
+    symbol.expr,
+    symbol.xor_expr,
+    symbol.and_expr,
+    symbol.shift_expr,
+    symbol.arith_expr,
+    symbol.term,
+    symbol.factor,
+    symbol.power,
+    symbol.atom,
+    ]
 
 _assign_types = [
-  symbol.test,
-  symbol.and_test,
-  symbol.not_test,
-  symbol.comparison,
-  symbol.expr,
-  symbol.xor_expr,
-  symbol.and_expr,
-  symbol.shift_expr,
-  symbol.arith_expr,
-  symbol.term,
-  symbol.factor,
-  ]
-
-
+    symbol.test,
+    symbol.and_test,
+    symbol.not_test,
+    symbol.comparison,
+    symbol.expr,
+    symbol.xor_expr,
+    symbol.and_expr,
+    symbol.shift_expr,
+    symbol.arith_expr,
+    symbol.term,
+    symbol.factor,
+    ]