Commits

David Schneider  committed 370c23f Merge

merge default

  • Participants
  • Parent commits b06fe41, c6d1e8b
  • Branches arm-backend-2

Comments (0)

Files changed (148)

+.hg
+.svn
+
+*.pyc
+*.pyo
+*~
+
+bin/pypy-c
+include/*.h
+lib_pypy/ctypes_config_cache/_[^_]*_*.py
+pypy/_cache
+pypy/doc/*.html
+pypy/doc/config/*.html
+pypy/doc/discussion/*.html
+pypy/translator/c/src/dtoa.o
+pypy/translator/goal/pypy-c
+pypy/translator/goal/target*-c
+release/
 ^pypy/doc/image/stackless_informal\.png$
 ^pypy/doc/image/parsing_example.+\.png$
 ^compiled
+^.git/
+^release/

File lib-python/conftest.py

     RegrTest('test_coding.py'),
     RegrTest('test_complex_args.py'),
     RegrTest('test_contextlib.py', usemodules="thread"),
-    RegrTest('test_ctypes.py', usemodules="_rawffi"),
+    RegrTest('test_ctypes.py', usemodules="_rawffi thread"),
     RegrTest('test_defaultdict.py', usemodules='_collections'),
     RegrTest('test_email_renamed.py'),
     RegrTest('test_exception_variations.py'),

File lib-python/modified-2.7.0/test/test_ast.py

+import sys, itertools, unittest
+from test import test_support
+import ast
+
+def to_tuple(t):
+    if t is None or isinstance(t, (basestring, int, long, complex)):
+        return t
+    elif isinstance(t, list):
+        return [to_tuple(e) for e in t]
+    result = [t.__class__.__name__]
+    if hasattr(t, 'lineno') and hasattr(t, 'col_offset'):
+        result.append((t.lineno, t.col_offset))
+    if t._fields is None:
+        return tuple(result)
+    for f in t._fields:
+        result.append(to_tuple(getattr(t, f)))
+    return tuple(result)
+
+
+# These tests are compiled through "exec"
+# There should be atleast one test per statement
+exec_tests = [
+    # None
+    "None",
+    # FunctionDef
+    "def f(): pass",
+    # FunctionDef with arg
+    "def f(a): pass",
+    # FunctionDef with arg and default value
+    "def f(a=0): pass",
+    # FunctionDef with varargs
+    "def f(*args): pass",
+    # FunctionDef with kwargs
+    "def f(**kwargs): pass",
+    # FunctionDef with all kind of args
+    "def f(a, b=1, c=None, d=[], e={}, *args, **kwargs): pass",
+    # ClassDef
+    "class C:pass",
+    # ClassDef, new style class
+    "class C(object): pass",
+    # Return
+    "def f():return 1",
+    # Delete
+    "del v",
+    # Assign
+    "v = 1",
+    # AugAssign
+    "v += 1",
+    # Print
+    "print >>f, 1, ",
+    # For
+    "for v in v:pass",
+    # While
+    "while v:pass",
+    # If
+    "if v:pass",
+    # Raise
+    "raise Exception, 'string'",
+    # TryExcept
+    "try:\n  pass\nexcept Exception:\n  pass",
+    # TryFinally
+    "try:\n  pass\nfinally:\n  pass",
+    # Assert
+    "assert v",
+    # Import
+    "import sys",
+    # ImportFrom
+    "from sys import v",
+    # Exec
+    "exec 'v'",
+    # Global
+    "global v",
+    # Expr
+    "1",
+    # Pass,
+    "pass",
+    # Break
+    "break",
+    # Continue
+    "continue",
+    # for statements with naked tuples (see http://bugs.python.org/issue6704)
+    "for a,b in c: pass",
+    "[(a,b) for a,b in c]",
+    "((a,b) for a,b in c)",
+    "((a,b) for (a,b) in c)",
+    # Multiline generator expression
+    """(
+    (
+    Aa
+    ,
+       Bb
+    )
+    for
+    Aa
+    ,
+    Bb in Cc
+    )""",
+    # dictcomp
+    "{a : b for w in x for m in p if g}",
+    # dictcomp with naked tuple
+    "{a : b for v,w in x}",
+    # setcomp
+    "{r for l in x if g}",
+    # setcomp with naked tuple
+    "{r for l,m in x}",
+]
+
+# These are compiled through "single"
+# because of overlap with "eval", it just tests what
+# can't be tested with "eval"
+single_tests = [
+    "1+2"
+]
+
+# These are compiled through "eval"
+# It should test all expressions
+eval_tests = [
+  # None
+  "None",
+  # BoolOp
+  "a and b",
+  # BinOp
+  "a + b",
+  # UnaryOp
+  "not v",
+  # Lambda
+  "lambda:None",
+  # Dict
+  "{ 1:2 }",
+  # Empty dict
+  "{}",
+  # Set
+  "{None,}",
+  # Multiline dict
+  """{
+      1
+        :
+          2
+     }""",
+  # ListComp
+  "[a for b in c if d]",
+  # GeneratorExp
+  "(a for b in c if d)",
+  # Yield - yield expressions can't work outside a function
+  #
+  # Compare
+  "1 < 2 < 3",
+  # Call
+  "f(1,2,c=3,*d,**e)",
+  # Repr
+  "`v`",
+  # Num
+  "10L",
+  # Str
+  "'string'",
+  # Attribute
+  "a.b",
+  # Subscript
+  "a[b:c]",
+  # Name
+  "v",
+  # List
+  "[1,2,3]",
+  # Empty list
+  "[]",
+  # Tuple
+  "1,2,3",
+  # Tuple
+  "(1,2,3)",
+  # Empty tuple
+  "()",
+  # Combination
+  "a.b.c.d(a.b[1:2])",
+
+]
+
+# TODO: expr_context, slice, boolop, operator, unaryop, cmpop, comprehension
+# excepthandler, arguments, keywords, alias
+
+class AST_Tests(unittest.TestCase):
+
+    def _assertTrueorder(self, ast_node, parent_pos):
+        if not isinstance(ast_node, ast.AST) or ast_node._fields is None:
+            return
+        if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)):
+            node_pos = (ast_node.lineno, ast_node.col_offset)
+            self.assertTrue(node_pos >= parent_pos)
+            parent_pos = (ast_node.lineno, ast_node.col_offset)
+        for name in ast_node._fields:
+            value = getattr(ast_node, name)
+            if isinstance(value, list):
+                for child in value:
+                    self._assertTrueorder(child, parent_pos)
+            elif value is not None:
+                self._assertTrueorder(value, parent_pos)
+
+    def test_AST_objects(self):
+        x = ast.AST()
+        try:
+            x.foobar = 21
+        except AttributeError, e:
+            self.assertEquals(e.args[0],
+                              "'_ast.AST' object has no attribute 'foobar'")
+        else:
+            self.assert_(False)
+
+        try:
+            ast.AST(lineno=2)
+        except AttributeError, e:
+            self.assertEquals(e.args[0],
+                              "'_ast.AST' object has no attribute 'lineno'")
+        else:
+            self.assert_(False)
+        try:
+            ast.AST(2)
+        except TypeError, e:
+            self.assertEquals(e.args[0],
+                              "_ast.AST constructor takes 0 positional arguments")
+        else:
+            self.assert_(False)
+
+    def test_snippets(self):
+        for input, output, kind in ((exec_tests, exec_results, "exec"),
+                                    (single_tests, single_results, "single"),
+                                    (eval_tests, eval_results, "eval")):
+            for i, o in itertools.izip(input, output):
+                ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST)
+                self.assertEquals(to_tuple(ast_tree), o)
+                self._assertTrueorder(ast_tree, (0, 0))
+
+    def test_slice(self):
+        slc = ast.parse("x[::]").body[0].value.slice
+        self.assertIsNone(slc.upper)
+        self.assertIsNone(slc.lower)
+        self.assertIsInstance(slc.step, ast.Name)
+        self.assertEqual(slc.step.id, "None")
+
+    def test_from_import(self):
+        im = ast.parse("from . import y").body[0]
+        self.assertIsNone(im.module)
+
+    def test_base_classes(self):
+        self.assertTrue(issubclass(ast.For, ast.stmt))
+        self.assertTrue(issubclass(ast.Name, ast.expr))
+        self.assertTrue(issubclass(ast.stmt, ast.AST))
+        self.assertTrue(issubclass(ast.expr, ast.AST))
+        self.assertTrue(issubclass(ast.comprehension, ast.AST))
+        self.assertTrue(issubclass(ast.Gt, ast.AST))
+
+    def test_field_attr_existence(self):
+        for name, item in ast.__dict__.iteritems():
+            if isinstance(item, type) and name != 'AST' and name[0].isupper(): # XXX: pypy does not allow abstract ast class instanciation
+                x = item()
+                if isinstance(x, ast.AST):
+                    self.assertEquals(type(x._fields), tuple)
+
+    def test_arguments(self):
+        x = ast.arguments()
+        self.assertEquals(x._fields, ('args', 'vararg', 'kwarg', 'defaults'))
+        try:
+            x.vararg
+        except AttributeError, e:
+            self.assertEquals(e.args[0],
+                              "'arguments' object has no attribute 'vararg'")
+        else:
+            self.assert_(False)
+        x = ast.arguments(1, 2, 3, 4)
+        self.assertEquals(x.vararg, 2)
+
+    def test_field_attr_writable(self):
+        x = ast.Num()
+        # We can assign to _fields
+        x._fields = 666
+        self.assertEquals(x._fields, 666)
+
+    def test_classattrs(self):
+        x = ast.Num()
+        self.assertEquals(x._fields, ('n',))
+        try:
+            x.n
+        except AttributeError, e:
+            self.assertEquals(e.args[0],
+                              "'Num' object has no attribute 'n'")
+        else:
+            self.assert_(False)
+
+        x = ast.Num(42)
+        self.assertEquals(x.n, 42)
+        try:
+            x.lineno
+        except AttributeError, e:
+            self.assertEquals(e.args[0],
+                              "'Num' object has no attribute 'lineno'")
+        else:
+            self.assert_(False)
+
+        y = ast.Num()
+        x.lineno = y
+        self.assertEquals(x.lineno, y)
+
+        try:
+            x.foobar
+        except AttributeError, e:
+            self.assertEquals(e.args[0],
+                              "'Num' object has no attribute 'foobar'")
+        else:
+            self.assert_(False)
+
+        x = ast.Num(lineno=2)
+        self.assertEquals(x.lineno, 2)
+
+        x = ast.Num(42, lineno=0)
+        self.assertEquals(x.lineno, 0)
+        self.assertEquals(x._fields, ('n',))
+        self.assertEquals(x.n, 42)
+
+        self.assertRaises(TypeError, ast.Num, 1, 2)
+        self.assertRaises(TypeError, ast.Num, 1, 2, lineno=0)
+
+    def test_module(self):
+        body = [ast.Num(42)]
+        x = ast.Module(body)
+        self.assertEquals(x.body, body)
+
+    def test_nodeclass(self):
+        x = ast.BinOp()
+        self.assertEquals(x._fields, ('left', 'op', 'right'))
+
+        # Zero arguments constructor explicitely allowed
+        x = ast.BinOp()
+        # Random attribute allowed too
+        x.foobarbaz = 5
+        self.assertEquals(x.foobarbaz, 5)
+
+        n1 = ast.Num(1)
+        n3 = ast.Num(3)
+        addop = ast.Add()
+        x = ast.BinOp(n1, addop, n3)
+        self.assertEquals(x.left, n1)
+        self.assertEquals(x.op, addop)
+        self.assertEquals(x.right, n3)
+        
+        x = ast.BinOp(1, 2, 3)
+        self.assertEquals(x.left, 1)
+        self.assertEquals(x.op, 2)
+        self.assertEquals(x.right, 3)
+
+        x = ast.BinOp(1, 2, 3, lineno=0)
+        self.assertEquals(x.lineno, 0)
+
+        # node raises exception when not given enough arguments
+        self.assertRaises(TypeError, ast.BinOp, 1, 2)
+        # node raises exception when given too many arguments
+        self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4)
+        # node raises exception when not given enough arguments
+        self.assertRaises(TypeError, ast.BinOp, 1, 2, lineno=0)
+        # node raises exception when given too many arguments
+        self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4, lineno=0)
+
+        # can set attributes through kwargs too
+        x = ast.BinOp(left=1, op=2, right=3, lineno=0)
+        self.assertEquals(x.left, 1)
+        self.assertEquals(x.op, 2)
+        self.assertEquals(x.right, 3)
+        self.assertEquals(x.lineno, 0)
+
+        # Random kwargs also allowed
+        x = ast.BinOp(1, 2, 3, foobarbaz=42)
+        self.assertEquals(x.foobarbaz, 42)
+
+    def test_no_fields(self):
+        # this used to fail because Sub._fields was None
+        x = ast.Sub()
+        self.assertEquals(x._fields, ())
+
+    def test_pickling(self):
+        import pickle
+        mods = [pickle]
+        try:
+            import cPickle
+            mods.append(cPickle)
+        except ImportError:
+            pass
+        protocols = [0, 1, 2]
+        for mod in mods:
+            for protocol in protocols:
+                for ast in (compile(i, "?", "exec", 0x400) for i in exec_tests):
+                    ast2 = mod.loads(mod.dumps(ast, protocol))
+                    self.assertEquals(to_tuple(ast2), to_tuple(ast))
+
+
+class ASTHelpers_Test(unittest.TestCase):
+
+    def test_parse(self):
+        a = ast.parse('foo(1 + 1)')
+        b = compile('foo(1 + 1)', '<unknown>', 'exec', ast.PyCF_ONLY_AST)
+        self.assertEqual(ast.dump(a), ast.dump(b))
+
+    def test_dump(self):
+        node = ast.parse('spam(eggs, "and cheese")')
+        self.assertEqual(ast.dump(node),
+            "Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load()), "
+            "args=[Name(id='eggs', ctx=Load()), Str(s='and cheese')], "
+            "keywords=[], starargs=None, kwargs=None))])"
+        )
+        self.assertEqual(ast.dump(node, annotate_fields=False),
+            "Module([Expr(Call(Name('spam', Load()), [Name('eggs', Load()), "
+            "Str('and cheese')], [], None, None))])"
+        )
+        self.assertEqual(ast.dump(node, include_attributes=True),
+            "Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load(), "
+            "lineno=1, col_offset=0), args=[Name(id='eggs', ctx=Load(), "
+            "lineno=1, col_offset=5), Str(s='and cheese', lineno=1, "
+            "col_offset=11)], keywords=[], starargs=None, kwargs=None, "
+            "lineno=1, col_offset=0), lineno=1, col_offset=0)])"
+        )
+
+    def test_copy_location(self):
+        src = ast.parse('1 + 1', mode='eval')
+        src.body.right = ast.copy_location(ast.Num(2), src.body.right)
+        self.assertEqual(ast.dump(src, include_attributes=True),
+            'Expression(body=BinOp(left=Num(n=1, lineno=1, col_offset=0), '
+            'op=Add(), right=Num(n=2, lineno=1, col_offset=4), lineno=1, '
+            'col_offset=0))'
+        )
+
+    def test_fix_missing_locations(self):
+        src = ast.parse('write("spam")')
+        src.body.append(ast.Expr(ast.Call(ast.Name('spam', ast.Load()),
+                                          [ast.Str('eggs')], [], None, None)))
+        self.assertEqual(src, ast.fix_missing_locations(src))
+        self.assertEqual(ast.dump(src, include_attributes=True),
+            "Module(body=[Expr(value=Call(func=Name(id='write', ctx=Load(), "
+            "lineno=1, col_offset=0), args=[Str(s='spam', lineno=1, "
+            "col_offset=6)], keywords=[], starargs=None, kwargs=None, "
+            "lineno=1, col_offset=0), lineno=1, col_offset=0), "
+            "Expr(value=Call(func=Name(id='spam', ctx=Load(), lineno=1, "
+            "col_offset=0), args=[Str(s='eggs', lineno=1, col_offset=0)], "
+            "keywords=[], starargs=None, kwargs=None, lineno=1, "
+            "col_offset=0), lineno=1, col_offset=0)])"
+        )
+
+    def test_increment_lineno(self):
+        src = ast.parse('1 + 1', mode='eval')
+        self.assertEqual(ast.increment_lineno(src, n=3), src)
+        self.assertEqual(ast.dump(src, include_attributes=True),
+            'Expression(body=BinOp(left=Num(n=1, lineno=4, col_offset=0), '
+            'op=Add(), right=Num(n=1, lineno=4, col_offset=4), lineno=4, '
+            'col_offset=0))'
+        )
+
+    def test_iter_fields(self):
+        node = ast.parse('foo()', mode='eval')
+        d = dict(ast.iter_fields(node.body))
+        self.assertEqual(d.pop('func').id, 'foo')
+        self.assertEqual(d, {'keywords': [], 'kwargs': None,
+                             'args': [], 'starargs': None})
+
+    def test_iter_child_nodes(self):
+        node = ast.parse("spam(23, 42, eggs='leek')", mode='eval')
+        self.assertEqual(len(list(ast.iter_child_nodes(node.body))), 4)
+        iterator = ast.iter_child_nodes(node.body)
+        self.assertEqual(next(iterator).id, 'spam')
+        self.assertEqual(next(iterator).n, 23)
+        self.assertEqual(next(iterator).n, 42)
+        self.assertEqual(ast.dump(next(iterator)),
+            "keyword(arg='eggs', value=Str(s='leek'))"
+        )
+
+    def test_get_docstring(self):
+        node = ast.parse('def foo():\n  """line one\n  line two"""')
+        self.assertEqual(ast.get_docstring(node.body[0]),
+                         'line one\nline two')
+
+    def test_literal_eval(self):
+        self.assertEqual(ast.literal_eval('[1, 2, 3]'), [1, 2, 3])
+        self.assertEqual(ast.literal_eval('{"foo": 42}'), {"foo": 42})
+        self.assertEqual(ast.literal_eval('(True, False, None)'), (True, False, None))
+        self.assertRaises(ValueError, ast.literal_eval, 'foo()')
+
+    def test_literal_eval_issue4907(self):
+        self.assertEqual(ast.literal_eval('2j'), 2j)
+        self.assertEqual(ast.literal_eval('10 + 2j'), 10 + 2j)
+        self.assertEqual(ast.literal_eval('1.5 - 2j'), 1.5 - 2j)
+        self.assertRaises(ValueError, ast.literal_eval, '2 + (3 + 4j)')
+
+
+def test_main():
+    with test_support.check_py3k_warnings(("backquote not supported",
+                                             SyntaxWarning)):
+        test_support.run_unittest(AST_Tests, ASTHelpers_Test)
+
+def main():
+    if __name__ != '__main__':
+        return
+    if sys.argv[1:] == ['-g']:
+        for statements, kind in ((exec_tests, "exec"), (single_tests, "single"),
+                                 (eval_tests, "eval")):
+            print kind+"_results = ["
+            for s in statements:
+                print repr(to_tuple(compile(s, "?", kind, 0x400)))+","
+            print "]"
+        print "main()"
+        raise SystemExit
+    test_main()
+
+#### EVERYTHING BELOW IS GENERATED #####
+exec_results = [
+('Module', [('Expr', (1, 0), ('Name', (1, 0), 'None', ('Load',)))]),
+('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, None, []), [('Pass', (1, 9))], [])]),
+('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [('Name', (1, 6), 'a', ('Param',))], None, None, []), [('Pass', (1, 10))], [])]),
+('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [('Name', (1, 6), 'a', ('Param',))], None, None, [('Num', (1, 8), 0)]), [('Pass', (1, 12))], [])]),
+('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], 'args', None, []), [('Pass', (1, 14))], [])]),
+('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, 'kwargs', []), [('Pass', (1, 17))], [])]),
+('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [('Name', (1, 6), 'a', ('Param',)), ('Name', (1, 9), 'b', ('Param',)), ('Name', (1, 14), 'c', ('Param',)), ('Name', (1, 22), 'd', ('Param',)), ('Name', (1, 28), 'e', ('Param',))], 'args', 'kwargs', [('Num', (1, 11), 1), ('Name', (1, 16), 'None', ('Load',)), ('List', (1, 24), [], ('Load',)), ('Dict', (1, 30), [], [])]), [('Pass', (1, 52))], [])]),
+('Module', [('ClassDef', (1, 0), 'C', [], [('Pass', (1, 8))], [])]),
+('Module', [('ClassDef', (1, 0), 'C', [('Name', (1, 8), 'object', ('Load',))], [('Pass', (1, 17))], [])]),
+('Module', [('FunctionDef', (1, 0), 'f', ('arguments', [], None, None, []), [('Return', (1, 8), ('Num', (1, 15), 1))], [])]),
+('Module', [('Delete', (1, 0), [('Name', (1, 4), 'v', ('Del',))])]),
+('Module', [('Assign', (1, 0), [('Name', (1, 0), 'v', ('Store',))], ('Num', (1, 4), 1))]),
+('Module', [('AugAssign', (1, 0), ('Name', (1, 0), 'v', ('Store',)), ('Add',), ('Num', (1, 5), 1))]),
+('Module', [('Print', (1, 0), ('Name', (1, 8), 'f', ('Load',)), [('Num', (1, 11), 1)], False)]),
+('Module', [('For', (1, 0), ('Name', (1, 4), 'v', ('Store',)), ('Name', (1, 9), 'v', ('Load',)), [('Pass', (1, 11))], [])]),
+('Module', [('While', (1, 0), ('Name', (1, 6), 'v', ('Load',)), [('Pass', (1, 8))], [])]),
+('Module', [('If', (1, 0), ('Name', (1, 3), 'v', ('Load',)), [('Pass', (1, 5))], [])]),
+('Module', [('Raise', (1, 0), ('Name', (1, 6), 'Exception', ('Load',)), ('Str', (1, 17), 'string'), None)]),
+('Module', [('TryExcept', (1, 0), [('Pass', (2, 2))], [('ExceptHandler', (3, 0), ('Name', (3, 7), 'Exception', ('Load',)), None, [('Pass', (4, 2))])], [])]),
+('Module', [('TryFinally', (1, 0), [('Pass', (2, 2))], [('Pass', (4, 2))])]),
+('Module', [('Assert', (1, 0), ('Name', (1, 7), 'v', ('Load',)), None)]),
+('Module', [('Import', (1, 0), [('alias', 'sys', None)])]),
+('Module', [('ImportFrom', (1, 0), 'sys', [('alias', 'v', None)], 0)]),
+('Module', [('Exec', (1, 0), ('Str', (1, 5), 'v'), None, None)]),
+('Module', [('Global', (1, 0), ['v'])]),
+('Module', [('Expr', (1, 0), ('Num', (1, 0), 1))]),
+('Module', [('Pass', (1, 0))]),
+('Module', [('Break', (1, 0))]),
+('Module', [('Continue', (1, 0))]),
+('Module', [('For', (1, 0), ('Tuple', (1, 4), [('Name', (1, 4), 'a', ('Store',)), ('Name', (1, 6), 'b', ('Store',))], ('Store',)), ('Name', (1, 11), 'c', ('Load',)), [('Pass', (1, 14))], [])]),
+('Module', [('Expr', (1, 0), ('ListComp', (1, 1), ('Tuple', (1, 2), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'a', ('Store',)), ('Name', (1, 13), 'b', ('Store',))], ('Store',)), ('Name', (1, 18), 'c', ('Load',)), [])]))]),
+('Module', [('Expr', (1, 0), ('GeneratorExp', (1, 1), ('Tuple', (1, 2), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'a', ('Store',)), ('Name', (1, 13), 'b', ('Store',))], ('Store',)), ('Name', (1, 18), 'c', ('Load',)), [])]))]),
+('Module', [('Expr', (1, 0), ('GeneratorExp', (1, 1), ('Tuple', (1, 2), [('Name', (1, 2), 'a', ('Load',)), ('Name', (1, 4), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 12), [('Name', (1, 12), 'a', ('Store',)), ('Name', (1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 20), 'c', ('Load',)), [])]))]),
+('Module', [('Expr', (1, 0), ('GeneratorExp', (2, 4), ('Tuple', (3, 4), [('Name', (3, 4), 'Aa', ('Load',)), ('Name', (5, 7), 'Bb', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (8, 4), [('Name', (8, 4), 'Aa', ('Store',)), ('Name', (10, 4), 'Bb', ('Store',))], ('Store',)), ('Name', (10, 10), 'Cc', ('Load',)), [])]))]),
+('Module', [('Expr', (1, 0), ('DictComp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), ('Name', (1, 5), 'b', ('Load',)), [('comprehension', ('Name', (1, 11), 'w', ('Store',)), ('Name', (1, 16), 'x', ('Load',)), []), ('comprehension', ('Name', (1, 22), 'm', ('Store',)), ('Name', (1, 27), 'p', ('Load',)), [('Name', (1, 32), 'g', ('Load',))])]))]),
+('Module', [('Expr', (1, 0), ('DictComp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), ('Name', (1, 5), 'b', ('Load',)), [('comprehension', ('Tuple', (1, 11), [('Name', (1, 11), 'v', ('Store',)), ('Name', (1, 13), 'w', ('Store',))], ('Store',)), ('Name', (1, 18), 'x', ('Load',)), [])]))]),
+('Module', [('Expr', (1, 0), ('SetComp', (1, 1), ('Name', (1, 1), 'r', ('Load',)), [('comprehension', ('Name', (1, 7), 'l', ('Store',)), ('Name', (1, 12), 'x', ('Load',)), [('Name', (1, 17), 'g', ('Load',))])]))]),
+('Module', [('Expr', (1, 0), ('SetComp', (1, 1), ('Name', (1, 1), 'r', ('Load',)), [('comprehension', ('Tuple', (1, 7), [('Name', (1, 7), 'l', ('Store',)), ('Name', (1, 9), 'm', ('Store',))], ('Store',)), ('Name', (1, 14), 'x', ('Load',)), [])]))]),
+]
+single_results = [
+('Interactive', [('Expr', (1, 0), ('BinOp', (1, 0), ('Num', (1, 0), 1), ('Add',), ('Num', (1, 2), 2)))]),
+]
+eval_results = [
+('Expression', ('Name', (1, 0), 'None', ('Load',))),
+('Expression', ('BoolOp', (1, 0), ('And',), [('Name', (1, 0), 'a', ('Load',)), ('Name', (1, 6), 'b', ('Load',))])),
+('Expression', ('BinOp', (1, 0), ('Name', (1, 0), 'a', ('Load',)), ('Add',), ('Name', (1, 4), 'b', ('Load',)))),
+('Expression', ('UnaryOp', (1, 0), ('Not',), ('Name', (1, 4), 'v', ('Load',)))),
+('Expression', ('Lambda', (1, 0), ('arguments', [], None, None, []), ('Name', (1, 7), 'None', ('Load',)))),
+('Expression', ('Dict', (1, 0), [('Num', (1, 2), 1)], [('Num', (1, 4), 2)])),
+('Expression', ('Dict', (1, 0), [], [])),
+('Expression', ('Set', (1, 0), [('Name', (1, 1), 'None', ('Load',))])),
+('Expression', ('Dict', (1, 0), [('Num', (2, 6), 1)], [('Num', (4, 10), 2)])),
+('Expression', ('ListComp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))])])),
+('Expression', ('GeneratorExp', (1, 1), ('Name', (1, 1), 'a', ('Load',)), [('comprehension', ('Name', (1, 7), 'b', ('Store',)), ('Name', (1, 12), 'c', ('Load',)), [('Name', (1, 17), 'd', ('Load',))])])),
+('Expression', ('Compare', (1, 0), ('Num', (1, 0), 1), [('Lt',), ('Lt',)], [('Num', (1, 4), 2), ('Num', (1, 8), 3)])),
+('Expression', ('Call', (1, 0), ('Name', (1, 0), 'f', ('Load',)), [('Num', (1, 2), 1), ('Num', (1, 4), 2)], [('keyword', 'c', ('Num', (1, 8), 3))], ('Name', (1, 11), 'd', ('Load',)), ('Name', (1, 15), 'e', ('Load',)))),
+('Expression', ('Repr', (1, 0), ('Name', (1, 1), 'v', ('Load',)))),
+('Expression', ('Num', (1, 0), 10L)),
+('Expression', ('Str', (1, 0), 'string')),
+('Expression', ('Attribute', (1, 0), ('Name', (1, 0), 'a', ('Load',)), 'b', ('Load',))),
+('Expression', ('Subscript', (1, 0), ('Name', (1, 0), 'a', ('Load',)), ('Slice', ('Name', (1, 2), 'b', ('Load',)), ('Name', (1, 4), 'c', ('Load',)), None), ('Load',))),
+('Expression', ('Name', (1, 0), 'v', ('Load',))),
+('Expression', ('List', (1, 0), [('Num', (1, 1), 1), ('Num', (1, 3), 2), ('Num', (1, 5), 3)], ('Load',))),
+('Expression', ('List', (1, 0), [], ('Load',))),
+('Expression', ('Tuple', (1, 0), [('Num', (1, 0), 1), ('Num', (1, 2), 2), ('Num', (1, 4), 3)], ('Load',))),
+('Expression', ('Tuple', (1, 1), [('Num', (1, 1), 1), ('Num', (1, 3), 2), ('Num', (1, 5), 3)], ('Load',))),
+('Expression', ('Tuple', (1, 0), [], ('Load',))),
+('Expression', ('Call', (1, 0), ('Attribute', (1, 0), ('Attribute', (1, 0), ('Attribute', (1, 0), ('Name', (1, 0), 'a', ('Load',)), 'b', ('Load',)), 'c', ('Load',)), 'd', ('Load',)), [('Subscript', (1, 8), ('Attribute', (1, 8), ('Name', (1, 8), 'a', ('Load',)), 'b', ('Load',)), ('Slice', ('Num', (1, 12), 1), ('Num', (1, 14), 2), None), ('Load',))], [], None, None)),
+]
+main()

File lib_pypy/_csv.py

     names = csv.list_dialects()"""
     return list(_dialects)
 
-class Reader:
-
+class Reader(object):
     """CSV reader
 
     Reader objects are responsible for reading and parsing tabular data
         self._parse_reset()
 
     def _parse_reset(self):
-        self.field = []
+        self.field = ''
         self.fields = []
         self.state = self.START_RECORD
         self.numeric_field = False
 
             self.line_num += 1
 
-            for c in line:
-                if c == '\0':
-                    raise Error("line contains NULL byte")
-                self._parse_process_char(c)
-            self._parse_process_char('\0')
+            if '\0' in line:
+                raise Error("line contains NULL byte")
+            pos = 0
+            while pos < len(line):
+                pos = self._parse_process_char(line, pos)
+            self._parse_eol()
 
             if self.state == self.START_RECORD:
                 break
         self.fields = []
         return fields
             
-    def _parse_process_char(self, c):
+    def _parse_process_char(self, line, pos):
+        c = line[pos]
         if self.state == self.IN_FIELD:
             # in unquoted field
-            if c in ('\n', '\r', '\0'):
-                # end of line - return [fields]
-                self._parse_save_field()
-                if c == '\0':
-                    self.state = self.START_RECORD
+            pos2 = pos
+            while True:
+                if c in '\n\r':
+                    # end of line - return [fields]
+                    if pos2 > pos:
+                        self._parse_add_char(line[pos:pos2])
+                        pos = pos2
+                    self._parse_save_field()
+                    self.state = self.EAT_CRNL
+                elif c == self.dialect.escapechar:
+                    # possible escaped character
+                    pos2 -= 1
+                    self.state = self.ESCAPED_CHAR
+                elif c == self.dialect.delimiter:
+                    # save field - wait for new field
+                    if pos2 > pos:
+                        self._parse_add_char(line[pos:pos2])
+                        pos = pos2
+                    self._parse_save_field()
+                    self.state = self.START_FIELD
                 else:
-                    self.state = self.EAT_CRNL
-            elif c == self.dialect.escapechar:
-                # possible escaped character
-                self.state = self.ESCAPED_CHAR
-            elif c == self.dialect.delimiter:
-                # save field - wait for new field
-                self._parse_save_field()
-                self.state = self.START_FIELD
-            else:
-                # normal character - save in field
-                self._parse_add_char(c)
-                
+                    # normal character - save in field
+                    pos2 += 1
+                    if pos2 < len(line):
+                        c = line[pos2]
+                        continue
+                break
+            if pos2 > pos:
+                self._parse_add_char(line[pos:pos2])
+                pos = pos2 - 1
+
         elif self.state == self.START_RECORD:
-            if c == '\0':
-                # empty line - return []
-                pass
-            elif c in ('\n', '\r'):
+            if c in '\n\r':
                 self.state = self.EAT_CRNL
             else:
                 self.state = self.START_FIELD
                 # restart process
-                self._parse_process_char(c)
+                self._parse_process_char(line, pos)
 
         elif self.state == self.START_FIELD:
-            if c in ('\n', '\r', '\0'):
+            if c in '\n\r':
                 # save empty field - return [fields]
                 self._parse_save_field()
-                if c == '\0':
-                    self.state = self.START_RECORD
-                else:
-                    self.state = self.EAT_CRNL
+                self.state = self.EAT_CRNL
             elif (c == self.dialect.quotechar
                   and self.dialect.quoting != QUOTE_NONE):
                 # start quoted field
                 self.state = self.IN_FIELD
         
         elif self.state == self.ESCAPED_CHAR:
-            if c == '\0':
-                c = '\n'
             self._parse_add_char(c)
             self.state = self.IN_FIELD
         
         elif self.state == self.IN_QUOTED_FIELD:
-            if c == '\0':
-                pass
-            elif c == self.dialect.escapechar:
+            if c == self.dialect.escapechar:
                 # possible escape character
                 self.state = self.ESCAPE_IN_QUOTED_FIELD
             elif (c == self.dialect.quotechar
                 self._parse_add_char(c)
                 
         elif self.state == self.ESCAPE_IN_QUOTED_FIELD:
-            if c == '\0':
-                c = '\n'
             self._parse_add_char(c)
             self.state = self.IN_QUOTED_FIELD
                 
                 # save field - wait for new field
                 self._parse_save_field()
                 self.state = self.START_FIELD
-            elif c in ('\r', '\n', '\0'):
+            elif c in '\r\n':
                 # end of line - return [fields]
                 self._parse_save_field()
-                if c == '\0':
-                    self.state = self.START_RECORD
-                else:
-                    self.state = self.EAT_CRNL
+                self.state = self.EAT_CRNL
             elif not self.dialect.strict:
                 self._parse_add_char(c)
                 self.state = self.IN_FIELD
                             (self.dialect.delimiter, self.dialect.quotechar))
 
         elif self.state == self.EAT_CRNL:
-            if c in ('\r', '\n'):
+            if c in '\r\n':
                 pass
-            elif c == '\0':
-                self.state = self.START_RECORD
             else:
                 raise Error("new-line character seen in unquoted field - "
                             "do you need to open the file "
         else:
             raise RuntimeError("unknown state: %r" % (self.state,))
 
+        return pos + 1
+
+    def _parse_eol(self):
+        if self.state == self.EAT_CRNL:
+            self.state = self.START_RECORD
+        elif self.state == self.START_RECORD:
+            # empty line - return []
+            pass
+        elif self.state == self.IN_FIELD:
+            # in unquoted field
+            # end of line - return [fields]
+            self._parse_save_field()
+            self.state = self.START_RECORD
+        elif self.state == self.START_FIELD:
+            # save empty field - return [fields]
+            self._parse_save_field()
+            self.state = self.START_RECORD
+        elif self.state == self.ESCAPED_CHAR:
+            self._parse_add_char('\n')
+            self.state = self.IN_FIELD
+        elif self.state == self.IN_QUOTED_FIELD:
+            pass
+        elif self.state == self.ESCAPE_IN_QUOTED_FIELD:
+            self._parse_add_char('\n')
+            self.state = self.IN_QUOTED_FIELD
+        elif self.state == self.QUOTE_IN_QUOTED_FIELD:
+            # end of line - return [fields]
+            self._parse_save_field()
+            self.state = self.START_RECORD
+        else:
+            raise RuntimeError("unknown state: %r" % (self.state,))
+
     def _parse_save_field(self):
-        field, self.field = self.field, []
-        field = ''.join(field)
+        field, self.field = self.field, ''
         if self.numeric_field:
             self.numeric_field = False
             field = float(field)
         self.fields.append(field)
 
     def _parse_add_char(self, c):
-        if len(self.field) >= _field_limit:
+        if len(self.field) + len(c) > _field_limit:
             raise Error("field larget than field limit (%d)" % (_field_limit))
-        self.field.append(c)
+        self.field += c
         
 
-class Writer:
+class Writer(object):
     """CSV writer
 
     Writer objects are responsible for generating tabular data

File py/_plugin/pytest_restdoc.py

         try: 
             self._checkskip(path, self.project.get_htmloutputpath(path))
             self.project.process(path)
-        except KeyboardInterrupt: 
-            raise 
+        except KeyboardInterrupt:
+            raise
+        except SystemExit, error:
+            if error.message == "ERROR: dot not found":
+                py.test.skip("system doesn't have graphviz installed")
+            raise
         except SystemMessage: 
             # we assume docutils printed info on stdout 
             py.test.fail("docutils processing failed, see captured stderr") 

File pypy/annotation/model.py

 from pypy.tool.pairtype import pair, extendabletype
 from pypy.tool.tls import tlsobject
 from pypy.rlib.rarithmetic import r_uint, r_ulonglong, base_int
-from pypy.rlib.rarithmetic import r_singlefloat, r_longfloat, isnan
+from pypy.rlib.rarithmetic import r_singlefloat, r_longfloat
 import inspect, weakref
 
 DEBUG = False    # set to False to disable recording of debugging information
     def __eq__(self, other):
         if (type(self) is SomeFloat and type(other) is SomeFloat and
             self.is_constant() and other.is_constant()):
+            from pypy.rlib.rfloat import isnan, copysign
             # NaN unpleasantness.
             if isnan(self.const) and isnan(other.const):
                 return True
             # 0.0 vs -0.0 unpleasantness.
             if not self.const and not other.const:
-                from pypy.rlib.rarithmetic import copysign
                 return copysign(1., self.const) == copysign(1., other.const)
             #
         return super(SomeFloat, self).__eq__(other)

File pypy/conftest.py

     def str_w(self, w_str):
         return w_str
 
-    def newdict(self):
+    def newdict(self, module=None):
         return {}
 
     def newtuple(self, iterable):

File pypy/doc/discussion/thoughts_string_interning.txt

 String Interning in PyPy
-===========================
+========================
 
 A few thoughts about string interning. CPython gets a remarkable
 speed-up by interning strings. Interned are all builtin string
 saving the need to do a string comparison.
 
 Interned Strings in CPython
---------------------------
+---------------------------
 
 CPython keeps an internal dictionary named ``interned`` for all of these
 strings. It contains the string both as key and as value, which means
 way to express this (less refcount, exclusion from Boehm, whatever).
 
 A prototype brute-force patch
---------------------------------
+-----------------------------
 
 In order to get some idea how efficient string interning is at the moment,
 I implemented a quite crude version of interning. I patched space.wrap

File pypy/doc/faq.txt

 
 
 General
-========================================================================
+=======
 
 -------------
 What is PyPy?
 
 .. _`prolog and javascript`:
 
----------------------------------------------------------------
+----------------------------------------------------------------
 Can PyPy support interpreters for other languages beyond Python?
----------------------------------------------------------------
+----------------------------------------------------------------
 
 The toolsuite that translates the PyPy interpreter is quite
 general and can be used to create optimized versions of interpreters
 .. _`SmallTalk interpreter`: http://dx.doi.org/10.1007/978-3-540-89275-5_7
 .. _`All of them`: http://codespeak.net/svn/pypy/lang/
 
+
 Development
-========================================================================
+===========
 
 -----------------------------------------------------------
 How do I get into PyPy development?  Can I come to sprints?
 This will disable SELinux's protection and allow PyPy to configure correctly.
 Be sure to enable it again if you need it!
 
+
 PyPy translation tool chain
-========================================================================
+===========================
 
 ----------------------------------------
 Can PyPy compile normal Python programs?
 
 .. _`RPython description`: coding-guide.html#restricted-python
 
--------------------------------------------------------------------------
-Does RPython have anything to do with Zope's Restricted Python? 
--------------------------------------------------------------------------
+---------------------------------------------------------------
+Does RPython have anything to do with Zope's Restricted Python?
+---------------------------------------------------------------
 
 No.  `Zope's RestrictedPython`_ aims to provide a sandboxed 
 execution environment for CPython.   `PyPy's RPython`_ is the implementation
 
 .. _`how do I compile my own interpreters`:
 
---------------------------------------
+-------------------------------------
 How do I compile my own interpreters?
---------------------------------------
+-------------------------------------
 
 Start from the example of
 `pypy/translator/goal/targetnopstandalone.py`_, which you compile by

File pypy/interpreter/astcompiler/assemble.py

 
 from pypy.interpreter.error import OperationError
 from pypy.rlib.objectmodel import we_are_translated
-from pypy.rlib import rarithmetic
+from pypy.rlib import rfloat
 
 
 class Instruction(object):
         w_type = space.type(obj)
         if space.is_w(w_type, space.w_float):
             val = space.float_w(obj)
-            if val == 0.0 and rarithmetic.copysign(1., val) < 0:
+            if val == 0.0 and rfloat.copysign(1., val) < 0:
                 w_key = space.newtuple([obj, space.w_float, space.w_None])
             else:
                 w_key = space.newtuple([obj, space.w_float])
             real = space.float_w(w_real)
             imag = space.float_w(w_imag)
             real_negzero = (real == 0.0 and
-                            rarithmetic.copysign(1., real) < 0)
+                            rfloat.copysign(1., real) < 0)
             imag_negzero = (imag == 0.0 and
-                            rarithmetic.copysign(1., imag) < 0)
+                            rfloat.copysign(1., imag) < 0)
             if real_negzero and imag_negzero:
                 tup = [obj, space.w_complex, space.w_None, space.w_None,
                        space.w_None]

File pypy/interpreter/astcompiler/astbuilder.py

         elif first_child_type == tokens.LBRACE:
             maker = atom_node.children[1]
             if maker.type == tokens.RBRACE:
-                return ast.Dict(None, None, maker.lineno, maker.column)
+                return ast.Dict(None, None, atom_node.lineno, atom_node.column)
             n_maker_children = len(maker.children)
             if n_maker_children == 1 or maker.children[1].type == tokens.COMMA:
                 elts = []
                 for i in range(0, n_maker_children, 2):
                     elts.append(self.handle_expr(maker.children[i]))
-                return ast.Set(elts, maker.lineno, maker.column)
+                return ast.Set(elts, atom_node.lineno, atom_node.column)
             if maker.children[1].type == syms.comp_for:
                 return self.handle_setcomp(maker)
             if (n_maker_children > 3 and
             for i in range(0, n_maker_children, 4):
                 keys.append(self.handle_expr(maker.children[i]))
                 values.append(self.handle_expr(maker.children[i + 2]))
-            return ast.Dict(keys, values, maker.lineno, maker.column)
+            return ast.Dict(keys, values, atom_node.lineno, atom_node.column)
         elif first_child_type == tokens.BACKQUOTE:
             expr = self.handle_testlist(atom_node.children[1])
             return ast.Repr(expr, atom_node.lineno, atom_node.column)
     def comprehension_helper(self, comp_node,
                              handle_source_expr_meth="handle_expr",
                              for_type=syms.comp_for, if_type=syms.comp_if,
-                             iter_type=syms.comp_iter):
+                             iter_type=syms.comp_iter,
+                             comp_fix_unamed_tuple_location=False):
         handle_source_expression = getattr(self, handle_source_expr_meth)
         fors_count = self.count_comp_fors(comp_node, for_type, if_type)
         comps = []
             if len(for_node.children) == 1:
                 comp = ast.comprehension(for_targets[0], expr, None)
             else:
-                target = ast.Tuple(for_targets, ast.Store, comp_node.lineno,
-                                   comp_node.column)
+                col = comp_node.column
+                line = comp_node.lineno
+                # Modified in python2.7, see http://bugs.python.org/issue6704
+                if comp_fix_unamed_tuple_location:
+                    expr_node = for_targets[0]
+                    assert isinstance(expr_node, ast.expr)
+                    col = expr_node.col_offset
+                    line = expr_node.lineno
+                target = ast.Tuple(for_targets, ast.Store, line, col)
                 comp = ast.comprehension(target, expr, None)
             if len(comp_node.children) == 5:
                 comp_node = comp_iter = comp_node.children[4]
 
     def handle_genexp(self, genexp_node):
         elt = self.handle_expr(genexp_node.children[0])
-        comps = self.comprehension_helper(genexp_node.children[1])
+        comps = self.comprehension_helper(genexp_node.children[1],
+                                          comp_fix_unamed_tuple_location=True)
         return ast.GeneratorExp(elt, comps, genexp_node.lineno,
                                 genexp_node.column)
 
         comps = self.comprehension_helper(listcomp_node.children[1],
                                           "handle_testlist",
                                           syms.list_for, syms.list_if,
-                                          syms.list_iter)
+                                          syms.list_iter,
+                                          comp_fix_unamed_tuple_location=True)
         return ast.ListComp(elt, comps, listcomp_node.lineno,
                             listcomp_node.column)
 
     def handle_setcomp(self, set_maker):
         elt = self.handle_expr(set_maker.children[0])
-        comps = self.comprehension_helper(set_maker.children[1])
+        comps = self.comprehension_helper(set_maker.children[1],
+                                          comp_fix_unamed_tuple_location=True)
         return ast.SetComp(elt, comps, set_maker.lineno, set_maker.column)
 
     def handle_dictcomp(self, dict_maker):
         key = self.handle_expr(dict_maker.children[0])
         value = self.handle_expr(dict_maker.children[2])
-        comps = self.comprehension_helper(dict_maker.children[3])
+        comps = self.comprehension_helper(dict_maker.children[3],
+                                          comp_fix_unamed_tuple_location=True)
         return ast.DictComp(key, value, comps, dict_maker.lineno,
                             dict_maker.column)
 

File pypy/interpreter/baseobjspace.py

         else:
             name = importname
 
-        w_name = self.wrap(name)
-        w_mod = self.wrap(Module(self, w_name))
-        self.builtin_modules[name] = w_mod
+        mod = Module(self, self.wrap(name))
+        mod.install()
+
         return name
 
     def getbuiltinmodule(self, name, force_init=False):
         from pypy.module.exceptions import Module
         w_name = self.wrap('exceptions')
         self.exceptions_module = Module(self, w_name)
-        self.builtin_modules['exceptions'] = self.wrap(self.exceptions_module)
+        self.exceptions_module.install()
 
         from pypy.module.sys import Module
         w_name = self.wrap('sys')
         self.sys = Module(self, w_name)
-        self.builtin_modules['sys'] = self.wrap(self.sys)
+        self.sys.install()
 
         from pypy.module.imp import Module
         w_name = self.wrap('imp')
-        self.builtin_modules['imp'] = self.wrap(Module(self, w_name))
+        mod = Module(self, w_name)
+        mod.install()
 
         from pypy.module.__builtin__ import Module
         w_name = self.wrap('__builtin__')
         self.builtin = Module(self, w_name)
         w_builtin = self.wrap(self.builtin)
-        self.builtin_modules['__builtin__'] = self.wrap(w_builtin)
+        w_builtin.install()
         self.setitem(self.builtin.w_dict, self.wrap('__builtins__'), w_builtin)
 
         bootstrap_modules = set(('sys', 'imp', '__builtin__', 'exceptions'))

File pypy/interpreter/mixedmodule.py

 from pypy.interpreter.module import Module
 from pypy.interpreter.function import Function, BuiltinFunction
-from pypy.interpreter import gateway 
-from pypy.interpreter.error import OperationError 
+from pypy.interpreter import gateway
+from pypy.interpreter.error import OperationError
 from pypy.interpreter.baseobjspace import W_Root
 import os, sys
 
     # after startup().
     w_initialdict = None
 
-    def __init__(self, space, w_name): 
-        """ NOT_RPYTHON """ 
-        Module.__init__(self, space, w_name) 
-        self.lazy = True 
+    def __init__(self, space, w_name):
+        """ NOT_RPYTHON """
+        Module.__init__(self, space, w_name)
+        self.lazy = True
         self.__class__.buildloaders()
         self.loaders = self.loaders.copy()    # copy from the class to the inst
+        self.submodules_w = []
+
+    def install(self):
+        """NOT_RPYTHON: install this module, and it's submodules into
+        space.builtin_modules"""
+        Module.install(self)
+        if hasattr(self, "submodules"):
+            space = self.space
+            name = space.unwrap(self.w_name)
+            for sub_name, module_cls in self.submodules.iteritems():
+                module_name = space.wrap("%s.%s" % (name, sub_name))
+                m = module_cls(space, module_name)
+                m.install()
+                self.submodules_w.append(m)
 
     def init(self, space):
         """This is called each time the module is imported or reloaded
             # the saved dict, as done with built-in and extension modules
             # on CPython.
             space.call_method(self.w_dict, 'update', self.w_initialdict)
-        else:
+
+        for w_submodule in self.submodules_w:
+            name = space.str_w(w_submodule.w_name)
+            space.setitem(self.w_dict, space.wrap(name.split(".")[-1]), w_submodule)
+            space.getbuiltinmodule(name)
+
+        if self.w_initialdict is None:
             Module.init(self, space)
             if not self.lazy and self.w_initialdict is None:
                 self.w_initialdict = space.call_method(self.w_dict, 'items')
 
+
     def get_applevel_name(cls):
         """ NOT_RPYTHON """
         if cls.applevel_name is not None:
 
     def get(self, name):
         space = self.space
-        w_value = self.getdictvalue(space, name) 
-        if w_value is None: 
+        w_value = self.getdictvalue(space, name)
+        if w_value is None:
             raise OperationError(space.w_AttributeError, space.wrap(name))
-        return w_value 
+        return w_value
 
-    def call(self, name, *args_w): 
-        w_builtin = self.get(name) 
+    def call(self, name, *args_w):
+        w_builtin = self.get(name)
         return self.space.call_function(w_builtin, *args_w)
 
     def getdictvalue(self, space, name):
 
     def _load_lazily(self, space, name):
         w_name = space.new_interned_str(name)
-        try: 
+        try:
             loader = self.loaders[name]
-        except KeyError: 
-            return None 
-        else: 
-            w_value = loader(space) 
+        except KeyError:
+            return None
+        else:
+            w_value = loader(space)
             func = space.interpclass_w(w_value)
             # the idea of the following code is that all functions that are
             # directly in a mixed-module are "builtin", e.g. they get a
                     func._builtinversion_ = bltin
                     bltin.name = name
                 w_value = space.wrap(bltin)
-            space.setitem(self.w_dict, w_name, w_value) 
+            space.setitem(self.w_dict, w_name, w_value)
             return w_value
 
 
-    def getdict(self): 
-        if self.lazy: 
+    def getdict(self):
+        if self.lazy:
             space = self.space
-            for name in self.loaders: 
-                w_value = self.get(name)  
-                space.setitem(self.w_dict, space.new_interned_str(name), w_value) 
+            for name in self.loaders:
+                w_value = self.get(name)
+                space.setitem(self.w_dict, space.new_interned_str(name), w_value)
             self.lazy = False
             self.w_initialdict = space.call_method(self.w_dict, 'items')
-        return self.w_dict 
+        return self.w_dict
 
     def _freeze_(self):
         self.getdict()
         # not constant
         return False
 
-    def buildloaders(cls): 
-        """ NOT_RPYTHON """ 
-        if not hasattr(cls, 'loaders'): 
+    def buildloaders(cls):
+        """ NOT_RPYTHON """
+        if not hasattr(cls, 'loaders'):
             # build a constant dictionary out of
-            # applevel/interplevel definitions 
+            # applevel/interplevel definitions
             cls.loaders = loaders = {}
             pkgroot = cls.__module__
             appname = cls.get_applevel_name()
-            for name, spec in cls.interpleveldefs.items(): 
-                loaders[name] = getinterpevalloader(pkgroot, spec) 
-            for name, spec in cls.appleveldefs.items(): 
+            for name, spec in cls.interpleveldefs.items():
+                loaders[name] = getinterpevalloader(pkgroot, spec)
+            for name, spec in cls.appleveldefs.items():
                 loaders[name] = getappfileloader(pkgroot, appname, spec)
-            assert '__file__' not in loaders 
+            assert '__file__' not in loaders
             if cls.expose__file__attribute:
                 loaders['__file__'] = cls.get__file__
             if '__doc__' not in loaders:
         w_obj = loader(space)
         space.setattr(space.wrap(self), space.wrap(name), w_obj)
 
-    def get__file__(cls, space): 
-        """ NOT_RPYTHON. 
-        return the __file__ attribute of a MixedModule 
-        which is the root-directory for the various 
+    def get__file__(cls, space):
+        """ NOT_RPYTHON.
+        return the __file__ attribute of a MixedModule
+        which is the root-directory for the various
         applevel and interplevel snippets that make
-        up the module. 
-        """ 
-        try: 
-            fname = cls._fname 
-        except AttributeError: 
+        up the module.
+        """
+        try:
+            fname = cls._fname
+        except AttributeError:
             pkgroot = cls.__module__
             mod = __import__(pkgroot, None, None, ['__doc__'])
-            fname = mod.__file__ 
+            fname = mod.__file__
             assert os.path.basename(fname).startswith('__init__.py')
             # make it clear that it's not really the interp-level module
             # at this path that we are seeing, but an app-level version of it
             fname = os.path.dirname(fname)
-            cls._fname = fname 
-        return space.wrap(fname) 
+            cls._fname = fname
+        return space.wrap(fname)
 
-    get__file__ = classmethod(get__file__) 
+    get__file__ = classmethod(get__file__)
 
     def get__doc__(cls, space):
         return space.wrap(cls.__doc__)
 
 
 def getinterpevalloader(pkgroot, spec):
-    """ NOT_RPYTHON """     
-    def ifileloader(space): 
+    """ NOT_RPYTHON """
+    def ifileloader(space):
         d = {'space' : space}
-        # EVIL HACK (but it works, and this is not RPython :-) 
-        while 1: 
-            try: 
-                value = eval(spec, d) 
-            except NameError, ex: 
-                name = ex.args[0].split("'")[1] # super-Evil 
+        # EVIL HACK (but it works, and this is not RPython :-)
+        while 1:
+            try:
+                value = eval(spec, d)
+            except NameError, ex:
+                name = ex.args[0].split("'")[1] # super-Evil
                 if name in d:
                     raise   # propagate the NameError
-                try: 
+                try:
                     d[name] = __import__(pkgroot+'.'+name, None, None, [name])
                 except ImportError:
                     etype, evalue, etb = sys.exc_info()
                         # didn't help, re-raise the original exception for
                         # clarity
                         raise etype, evalue, etb
-            else: 
+            else:
                 #print spec, "->", value
-                if hasattr(value, 'func_code'):  # semi-evil 
+                if hasattr(value, 'func_code'):  # semi-evil
                     return space.wrap(gateway.interp2app(value))
 
                 try:
                 assert isinstance(value, W_Root), (
                     "interpleveldef %s.%s must return a wrapped object "
                     "(got %r instead)" % (pkgroot, spec, value))
-                return value 
-    return ifileloader 
-        
+                return value
+    return ifileloader
+
 applevelcache = {}
 def getappfileloader(pkgroot, appname, spec):
-    """ NOT_RPYTHON """ 
-    # hum, it's a bit more involved, because we usually 
+    """ NOT_RPYTHON """
+    # hum, it's a bit more involved, because we usually
     # want the import at applevel
     modname, attrname = spec.split('.')
     impbase = pkgroot + '.' + modname
         app = gateway.applevel(source, filename=fn, modname=appname)
         applevelcache[impbase] = app
 
-    def afileloader(space): 
+    def afileloader(space):
         return app.wget(space, attrname)
-    return afileloader 
-
+    return afileloader

File pypy/interpreter/module.py

 
     def __init__(self, space, w_name, w_dict=None, add_package=True):
         self.space = space
-        if w_dict is None: 
+        if w_dict is None:
             w_dict = space.newdict(module=True)
-        self.w_dict = w_dict 
-        self.w_name = w_name 
+        self.w_dict = w_dict
+        self.w_name = w_name
         if w_name is not None:
             space.setitem(w_dict, space.new_interned_str('__name__'), w_name)
         if add_package:
                           space.w_None)
         self.startup_called = False
 
+    def install(self):
+        """NOT_RPYTHON: installs this module into space.builtin_modules"""
+        w_mod = self.space.wrap(self)
+        self.space.builtin_modules[self.space.unwrap(self.w_name)] = w_mod
+
     def setup_after_space_initialization(self):
         """NOT_RPYTHON: to allow built-in modules to do some more setup
         after the space is fully initialized."""
     def descr_module__init__(self, w_name, w_doc=None):
         space = self.space
         self.w_name = w_name
-        if w_doc is None:  
+        if w_doc is None:
             w_doc = space.w_None
         space.setitem(self.w_dict, space.new_interned_str('__name__'), w_name)
         space.setitem(self.w_dict, space.new_interned_str('__doc__'), w_doc)
 
     def descr__reduce__(self, space):
         w_name = space.finditem(self.w_dict, space.wrap('__name__'))
-        if (w_name is None or 
+        if (w_name is None or
             not space.is_true(space.isinstance(w_name, space.w_str))):
             # maybe raise exception here (XXX this path is untested)
             return space.w_None
             from pypy.interpreter.mixedmodule import MixedModule
             w_mod    = space.getbuiltinmodule('_pickle_support')
             mod      = space.interp_w(MixedModule, w_mod)
-            new_inst = mod.get('module_new')            
+            new_inst = mod.get('module_new')
             return space.newtuple([new_inst, space.newtuple([w_name,
-                                    self.getdict()]), 
+                                    self.getdict()]),
                                   ])
         #already imported case
         w_import = space.builtin.get('__import__')

File pypy/interpreter/pyparser/future.py

 
 from pypy.interpreter.astcompiler.consts import CO_GENERATOR_ALLOWED, \
     CO_FUTURE_DIVISION, CO_FUTURE_WITH_STATEMENT, CO_FUTURE_ABSOLUTE_IMPORT
-            
+
 def get_futures(future_flags, source):
     futures = FutureAutomaton(future_flags, source)
     try:
     except DoneException, e:
         pass
     return futures.flags, (futures.lineno, futures.col_offset)
-    
+
 class DoneException(Exception):
     pass
 
         c = self.getc()
         if c in ("'", '"', "r", "u") and not self.docstring_consumed:
             self.consume_docstring()
-        elif c in whitespace_or_newline:
+        elif c == '\\' or c in whitespace_or_newline:
             self.consume_empty_line()
         elif c == '#':
             self.consume_comment()
                     # Syntax error
                     return
 
+    def consume_continuation(self):
+        c = self.getc()
+        if c in '\n\r':
+            self.pos += 1
+            self.atbol()
+
     def consume_empty_line(self):
         """
         Called when the remainder of the line can only contain whitespace
             self.pos += 1
             self.consume_whitespace()
             self.start()
+        elif self.getc() in '\\':
+            self.pos += 1
+            self.consume_continuation()
+            self.start()
         elif self.getc() in '\r\n':
             c = self.getc()
             self.pos += 1
             if c == '\r':
                 if self.getc() == '\n':
                     self.pos += 1
-                    self.atbol()
+                self.atbol()
             else:
                 self.atbol()
             self.start()
         if self.getc() not in whitespace + '\\':
             raise DoneException
         self.consume_whitespace()
-        
+
     def consume_whitespace(self):
         while 1:
             c = self.getc()
         if paren_list and self.getc() == ')':
             self.pos += 1
             return
-        
         if (self.getc() == 'a' and
             self.getc(+1) == 's' and
             self.getc(+2) in whitespace):

File pypy/interpreter/pyparser/test/test_futureautomaton.py

     f = run(s)
     assert f.pos == len(s)
     assert f.flags == fut.CO_FUTURE_DIVISION
+    assert f.lineno == 2
+    assert f.col_offset == 0
 
 def test_comment():
     s = '# A comment about nothing ;\n'
     f = run(s)
     assert f.pos == len(s)
+    assert f.lineno == -1
+    assert f.col_offset == 0
 
 def test_tripledocstring():
     s = '''""" This is a
 '''
     f = run(s)
     assert f.pos == len(s)
+    assert f.lineno == -1
+    assert f.col_offset == 0
 
 def test_escapedquote_in_tripledocstring():
     s = '''""" This is a
 '''
     f = run(s)
     assert f.pos == len(s)
-
-
+    assert f.lineno == -1
+    assert f.col_offset == 0
 
 def test_empty_line():
     s = ' \t   \f \n   \n'
     f = run(s)
     assert f.pos == len(s)
+    assert f.lineno == -1
+    assert f.col_offset == 0
 
 def test_from():
     s = 'from  __future__ import division\n'
     f = run(s)
     assert f.pos == len(s)
     assert f.flags == fut.CO_FUTURE_DIVISION
+    assert f.lineno == 1
+    assert f.col_offset == 0
 
 def test_froms():
     s = 'from  __future__ import division, generators, with_statement\n'
     assert f.flags == (fut.CO_FUTURE_DIVISION |
                        fut.CO_GENERATOR_ALLOWED |
                        fut.CO_FUTURE_WITH_STATEMENT)
+    assert f.lineno == 1
+    assert f.col_offset == 0
 
 def test_from_as():
     s = 'from  __future__ import division as b\n'
     f = run(s)
     assert f.pos == len(s)
     assert f.flags == fut.CO_FUTURE_DIVISION
+    assert f.lineno == 1
+    assert f.col_offset == 0
     
 def test_froms_as():
     s = 'from  __future__ import division as b, generators as c\n'
     assert f.pos == len(s)
     assert f.flags == (fut.CO_FUTURE_DIVISION |
                        fut.CO_GENERATOR_ALLOWED)
+    assert f.lineno == 1
+    assert f.col_offset == 0
 
 def test_from_paren():
     s = 'from  __future__ import (division)\n'
     f = run(s)
     assert f.pos == len(s)
     assert f.flags == fut.CO_FUTURE_DIVISION
+    assert f.lineno == 1
+    assert f.col_offset == 0
 
 def test_froms_paren():
     s = 'from  __future__ import (division, generators)\n'
     assert f.pos == len(s)
     assert f.flags == (fut.CO_FUTURE_DIVISION |
                        fut.CO_GENERATOR_ALLOWED)
+    assert f.lineno == 1
+    assert f.col_offset == 0
 
 def test_froms_paren_as():
     s = 'from  __future__ import (division as b, generators,)\n'
     assert f.pos == len(s)
     assert f.flags == (fut.CO_FUTURE_DIVISION |
                        fut.CO_GENERATOR_ALLOWED)
+    assert f.lineno == 1
+    assert f.col_offset == 0
 
 def test_multiline():
     s = '"abc" #def\n  #ghi\nfrom  __future__ import (division as b, generators,)\nfrom __future__ import with_statement\n'
     assert f.flags == (fut.CO_FUTURE_DIVISION |
                        fut.CO_GENERATOR_ALLOWED |
                        fut.CO_FUTURE_WITH_STATEMENT)
+    assert f.lineno == 4
+    assert f.col_offset == 0
 
 def test_windows_style_lineendings():
     s = '"abc" #def\r\n  #ghi\r\nfrom  __future__ import (division as b, generators,)\r\nfrom __future__ import with_statement\r\n'
     assert f.flags == (fut.CO_FUTURE_DIVISION |
                        fut.CO_GENERATOR_ALLOWED |
                        fut.CO_FUTURE_WITH_STATEMENT)
+    assert f.lineno == 4
+    assert f.col_offset == 0
 
 def test_mac_style_lineendings():
     s = '"abc" #def\r  #ghi\rfrom  __future__ import (division as b, generators,)\rfrom __future__ import with_statement\r'
     assert f.flags == (fut.CO_FUTURE_DIVISION |
                        fut.CO_GENERATOR_ALLOWED |
                        fut.CO_FUTURE_WITH_STATEMENT)
+    assert f.lineno == 4
+    assert f.col_offset == 0
+
 def test_semicolon():
     s = '"abc" #def\n  #ghi\nfrom  __future__ import (division as b, generators,);  from __future__ import with_statement\n'
     f = run(s)
     assert f.flags == (fut.CO_FUTURE_DIVISION |
                        fut.CO_GENERATOR_ALLOWED |
                        fut.CO_FUTURE_WITH_STATEMENT)
+    assert f.lineno == 3
+    assert f.col_offset == 55
 
 def test_full_chain():
     s = '"abc" #def\n  #ghi\nfrom  __future__ import (division as b, generators,);  from __future__ import with_statement\n'
     assert flags & fut.CO_FUTURE_WITH_STATEMENT == 0
     assert pos == (1, 0)
 
-
 def test_nonexisting():
     s = 'from  __future__ import non_existing_feature\n'
     f = run(s)
     assert f.pos == len(s)
     assert f.flags == 0
+    assert f.lineno == 1
+    assert f.col_offset == 0
 
 def test_from_import_abs_import():
     s = 'from  __future__ import absolute_import\n'
     f = run(s)
     assert f.pos == len(s)
     assert f.flags == fut.CO_FUTURE_ABSOLUTE_IMPORT
-
+    assert f.lineno == 1
+    assert f.col_offset == 0
 
 def test_raw_doc():
     s = 'r"Doc"\nfrom __future__ import with_statement\n'
     f = run(s)
     assert f.pos == len(s)
     assert f.flags == fut.CO_FUTURE_WITH_STATEMENT
+    assert f.lineno == 2
+    assert f.col_offset == 0
 
 def test_unicode_doc():
     s = 'u"Doc"\nfrom __future__ import with_statement\n'
     f = run(s)
     assert f.pos == len(s)
     assert f.flags == fut.CO_FUTURE_WITH_STATEMENT
+    assert f.lineno == 2
+    assert f.col_offset == 0
 
 def test_raw_unicode_doc():
     s = 'ru"Doc"\nfrom __future__ import with_statement\n'
     f = run(s)
     assert f.pos == len(s)
     assert f.flags == fut.CO_FUTURE_WITH_STATEMENT
+
+def test_continuation_line():
+    s = "\\\nfrom __future__ import with_statement\n"
+    f = run(s)
+    assert f.pos == len(s)
+    assert f.flags == fut.CO_FUTURE_WITH_STATEMENT
+    assert f.lineno == 2
+    assert f.col_offset == 0
+
+def test_continuation_lines():
+    s = "\\\n  \t\\\nfrom __future__ import with_statement\n"
+    f = run(s)
+    assert f.pos == len(s)
+    assert f.flags == fut.CO_FUTURE_WITH_STATEMENT
+    assert f.lineno == 3
+    assert f.col_offset == 0
+
+# This looks like a bug in cpython parser
+# and would require extensive modifications
+# to future.py in order to emulate the same behaviour
+def test_continuation_lines_raise():
+    py.test.skip("probably a CPython bug")
+    s = "   \\\n  \t\\\nfrom __future__ import with_statement\n"
+    try:
+        f = run(s)
+    except IndentationError, e:
+        assert e.args == 'unexpected indent'
+        assert f.pos == len(s)
+        assert f.flags == 0
+        assert f.lineno == -1
+        assert f.col_offset == 0
+    else: