Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 1 of 2.

1 files changed, 233 insertions, 233 deletions

diff --git a/contrib/tools/cython/Cython/Compiler/TreeFragment.py b/contrib/tools/cython/Cython/Compiler/TreeFragment.py
index b85da8191a..5bd7fc39e0 100644
--- a/contrib/tools/cython/Cython/Compiler/TreeFragment.py
+++ b/contrib/tools/cython/Cython/Compiler/TreeFragment.py
@@ -1,29 +1,29 @@
-#
-# TreeFragments - parsing of strings to trees
-#
-
-"""
-Support for parsing strings into code trees.
-"""
-
-from __future__ import absolute_import
-
-import re
+# 
+# TreeFragments - parsing of strings to trees 
+# 
+ 
+""" 
+Support for parsing strings into code trees. 
+""" 
+ 
+from __future__ import absolute_import 
+ 
+import re 
 from io import StringIO
-
-from .Scanning import PyrexScanner, StringSourceDescriptor
-from .Symtab import ModuleScope
-from . import PyrexTypes
-from .Visitor import VisitorTransform
-from .Nodes import Node, StatListNode
-from .ExprNodes import NameNode
+ 
+from .Scanning import PyrexScanner, StringSourceDescriptor 
+from .Symtab import ModuleScope 
+from . import PyrexTypes 
+from .Visitor import VisitorTransform 
+from .Nodes import Node, StatListNode 
+from .ExprNodes import NameNode 
 from .StringEncoding import _unicode
-from . import Parsing
-from . import Main
-from . import UtilNodes
-
-
-class StringParseContext(Main.Context):
+from . import Parsing 
+from . import Main 
+from . import UtilNodes 
+ 
+ 
+class StringParseContext(Main.Context): 
     def __init__(self, name, include_directories=None, compiler_directives=None, cpp=False):
         if include_directories is None:
             include_directories = []
@@ -31,191 +31,191 @@ class StringParseContext(Main.Context):
             compiler_directives = {}
         # TODO: see if "language_level=3" also works for our internal code here.
         Main.Context.__init__(self, include_directories, compiler_directives, cpp=cpp, language_level=2)
-        self.module_name = name
-
+        self.module_name = name 
+ 
     def find_module(self, module_name, relative_to=None, pos=None, need_pxd=1, absolute_fallback=True):
-        if module_name not in (self.module_name, 'cython'):
-            raise AssertionError("Not yet supporting any cimports/includes from string code snippets")
+        if module_name not in (self.module_name, 'cython'): 
+            raise AssertionError("Not yet supporting any cimports/includes from string code snippets") 
         return ModuleScope(module_name, parent_module=None, context=self)
-
-
+ 
+ 
 def parse_from_strings(name, code, pxds=None, level=None, initial_pos=None,
-                       context=None, allow_struct_enum_decorator=False):
-    """
-    Utility method to parse a (unicode) string of code. This is mostly
-    used for internal Cython compiler purposes (creating code snippets
-    that transforms should emit, as well as unit testing).
-
-    code - a unicode string containing Cython (module-level) code
-    name - a descriptive name for the code source (to use in error messages etc.)
-
-    RETURNS
-
-    The tree, i.e. a ModuleNode. The ModuleNode's scope attribute is
-    set to the scope used when parsing.
-    """
-    if context is None:
-        context = StringParseContext(name)
-    # Since source files carry an encoding, it makes sense in this context
-    # to use a unicode string so that code fragments don't have to bother
-    # with encoding. This means that test code passed in should not have an
-    # encoding header.
+                       context=None, allow_struct_enum_decorator=False): 
+    """ 
+    Utility method to parse a (unicode) string of code. This is mostly 
+    used for internal Cython compiler purposes (creating code snippets 
+    that transforms should emit, as well as unit testing). 
+ 
+    code - a unicode string containing Cython (module-level) code 
+    name - a descriptive name for the code source (to use in error messages etc.) 
+ 
+    RETURNS 
+ 
+    The tree, i.e. a ModuleNode. The ModuleNode's scope attribute is 
+    set to the scope used when parsing. 
+    """ 
+    if context is None: 
+        context = StringParseContext(name) 
+    # Since source files carry an encoding, it makes sense in this context 
+    # to use a unicode string so that code fragments don't have to bother 
+    # with encoding. This means that test code passed in should not have an 
+    # encoding header. 
     assert isinstance(code, _unicode), "unicode code snippets only please"
-    encoding = "UTF-8"
-
-    module_name = name
-    if initial_pos is None:
-        initial_pos = (name, 1, 0)
-    code_source = StringSourceDescriptor(name, code)
-
+    encoding = "UTF-8" 
+ 
+    module_name = name 
+    if initial_pos is None: 
+        initial_pos = (name, 1, 0) 
+    code_source = StringSourceDescriptor(name, code) 
+ 
     scope = context.find_module(module_name, pos=initial_pos, need_pxd=False)
-
-    buf = StringIO(code)
-
-    scanner = PyrexScanner(buf, code_source, source_encoding = encoding,
-                     scope = scope, context = context, initial_pos = initial_pos)
-    ctx = Parsing.Ctx(allow_struct_enum_decorator=allow_struct_enum_decorator)
-
-    if level is None:
-        tree = Parsing.p_module(scanner, 0, module_name, ctx=ctx)
-        tree.scope = scope
-        tree.is_pxd = False
-    else:
-        tree = Parsing.p_code(scanner, level=level, ctx=ctx)
-
-    tree.scope = scope
-    return tree
-
-
-class TreeCopier(VisitorTransform):
-    def visit_Node(self, node):
-        if node is None:
-            return node
-        else:
-            c = node.clone_node()
-            self.visitchildren(c)
-            return c
-
-
-class ApplyPositionAndCopy(TreeCopier):
-    def __init__(self, pos):
-        super(ApplyPositionAndCopy, self).__init__()
-        self.pos = pos
-
-    def visit_Node(self, node):
-        copy = super(ApplyPositionAndCopy, self).visit_Node(node)
-        copy.pos = self.pos
-        return copy
-
-
-class TemplateTransform(VisitorTransform):
-    """
-    Makes a copy of a template tree while doing substitutions.
-
-    A dictionary "substitutions" should be passed in when calling
-    the transform; mapping names to replacement nodes. Then replacement
-    happens like this:
-     - If an ExprStatNode contains a single NameNode, whose name is
-       a key in the substitutions dictionary, the ExprStatNode is
-       replaced with a copy of the tree given in the dictionary.
-       It is the responsibility of the caller that the replacement
-       node is a valid statement.
-     - If a single NameNode is otherwise encountered, it is replaced
-       if its name is listed in the substitutions dictionary in the
-       same way. It is the responsibility of the caller to make sure
-       that the replacement nodes is a valid expression.
-
-    Also a list "temps" should be passed. Any names listed will
-    be transformed into anonymous, temporary names.
-
-    Currently supported for tempnames is:
-    NameNode
-    (various function and class definition nodes etc. should be added to this)
-
-    Each replacement node gets the position of the substituted node
-    recursively applied to every member node.
-    """
-
-    temp_name_counter = 0
-
-    def __call__(self, node, substitutions, temps, pos):
-        self.substitutions = substitutions
-        self.pos = pos
-        tempmap = {}
-        temphandles = []
-        for temp in temps:
-            TemplateTransform.temp_name_counter += 1
-            handle = UtilNodes.TempHandle(PyrexTypes.py_object_type)
-            tempmap[temp] = handle
-            temphandles.append(handle)
-        self.tempmap = tempmap
-        result = super(TemplateTransform, self).__call__(node)
-        if temps:
-            result = UtilNodes.TempsBlockNode(self.get_pos(node),
-                                              temps=temphandles,
-                                              body=result)
-        return result
-
-    def get_pos(self, node):
-        if self.pos:
-            return self.pos
-        else:
-            return node.pos
-
-    def visit_Node(self, node):
-        if node is None:
-            return None
-        else:
-            c = node.clone_node()
-            if self.pos is not None:
-                c.pos = self.pos
-            self.visitchildren(c)
-            return c
-
-    def try_substitution(self, node, key):
-        sub = self.substitutions.get(key)
-        if sub is not None:
-            pos = self.pos
-            if pos is None: pos = node.pos
-            return ApplyPositionAndCopy(pos)(sub)
-        else:
-            return self.visit_Node(node) # make copy as usual
-
-    def visit_NameNode(self, node):
-        temphandle = self.tempmap.get(node.name)
-        if temphandle:
-            # Replace name with temporary
-            return temphandle.ref(self.get_pos(node))
-        else:
-            return self.try_substitution(node, node.name)
-
-    def visit_ExprStatNode(self, node):
-        # If an expression-as-statement consists of only a replaceable
-        # NameNode, we replace the entire statement, not only the NameNode
-        if isinstance(node.expr, NameNode):
-            return self.try_substitution(node, node.expr.name)
-        else:
-            return self.visit_Node(node)
-
-
-def copy_code_tree(node):
-    return TreeCopier()(node)
-
+ 
+    buf = StringIO(code) 
+ 
+    scanner = PyrexScanner(buf, code_source, source_encoding = encoding, 
+                     scope = scope, context = context, initial_pos = initial_pos) 
+    ctx = Parsing.Ctx(allow_struct_enum_decorator=allow_struct_enum_decorator) 
+ 
+    if level is None: 
+        tree = Parsing.p_module(scanner, 0, module_name, ctx=ctx) 
+        tree.scope = scope 
+        tree.is_pxd = False 
+    else: 
+        tree = Parsing.p_code(scanner, level=level, ctx=ctx) 
+ 
+    tree.scope = scope 
+    return tree 
+ 
+
+class TreeCopier(VisitorTransform): 
+    def visit_Node(self, node): 
+        if node is None: 
+            return node 
+        else: 
+            c = node.clone_node() 
+            self.visitchildren(c) 
+            return c 
+ 
+
+class ApplyPositionAndCopy(TreeCopier): 
+    def __init__(self, pos): 
+        super(ApplyPositionAndCopy, self).__init__() 
+        self.pos = pos 
+ 
+    def visit_Node(self, node): 
+        copy = super(ApplyPositionAndCopy, self).visit_Node(node) 
+        copy.pos = self.pos 
+        return copy 
+ 
+
+class TemplateTransform(VisitorTransform): 
+    """ 
+    Makes a copy of a template tree while doing substitutions. 
+ 
+    A dictionary "substitutions" should be passed in when calling 
+    the transform; mapping names to replacement nodes. Then replacement 
+    happens like this: 
+     - If an ExprStatNode contains a single NameNode, whose name is 
+       a key in the substitutions dictionary, the ExprStatNode is 
+       replaced with a copy of the tree given in the dictionary. 
+       It is the responsibility of the caller that the replacement 
+       node is a valid statement. 
+     - If a single NameNode is otherwise encountered, it is replaced 
+       if its name is listed in the substitutions dictionary in the 
+       same way. It is the responsibility of the caller to make sure 
+       that the replacement nodes is a valid expression. 
+ 
+    Also a list "temps" should be passed. Any names listed will 
+    be transformed into anonymous, temporary names. 
+ 
+    Currently supported for tempnames is: 
+    NameNode 
+    (various function and class definition nodes etc. should be added to this) 
+ 
+    Each replacement node gets the position of the substituted node 
+    recursively applied to every member node. 
+    """ 
+ 
+    temp_name_counter = 0 
+ 
+    def __call__(self, node, substitutions, temps, pos): 
+        self.substitutions = substitutions 
+        self.pos = pos 
+        tempmap = {} 
+        temphandles = [] 
+        for temp in temps: 
+            TemplateTransform.temp_name_counter += 1 
+            handle = UtilNodes.TempHandle(PyrexTypes.py_object_type) 
+            tempmap[temp] = handle 
+            temphandles.append(handle) 
+        self.tempmap = tempmap 
+        result = super(TemplateTransform, self).__call__(node) 
+        if temps: 
+            result = UtilNodes.TempsBlockNode(self.get_pos(node), 
+                                              temps=temphandles, 
+                                              body=result) 
+        return result 
+ 
+    def get_pos(self, node): 
+        if self.pos: 
+            return self.pos 
+        else: 
+            return node.pos 
+ 
+    def visit_Node(self, node): 
+        if node is None: 
+            return None 
+        else: 
+            c = node.clone_node() 
+            if self.pos is not None: 
+                c.pos = self.pos 
+            self.visitchildren(c) 
+            return c 
+ 
+    def try_substitution(self, node, key): 
+        sub = self.substitutions.get(key) 
+        if sub is not None: 
+            pos = self.pos 
+            if pos is None: pos = node.pos 
+            return ApplyPositionAndCopy(pos)(sub) 
+        else: 
+            return self.visit_Node(node) # make copy as usual 
+ 
+    def visit_NameNode(self, node): 
+        temphandle = self.tempmap.get(node.name) 
+        if temphandle: 
+            # Replace name with temporary 
+            return temphandle.ref(self.get_pos(node)) 
+        else: 
+            return self.try_substitution(node, node.name) 
+ 
+    def visit_ExprStatNode(self, node): 
+        # If an expression-as-statement consists of only a replaceable 
+        # NameNode, we replace the entire statement, not only the NameNode 
+        if isinstance(node.expr, NameNode): 
+            return self.try_substitution(node, node.expr.name) 
+        else: 
+            return self.visit_Node(node) 
+ 
+
+def copy_code_tree(node): 
+    return TreeCopier()(node) 
+ 
 
 _match_indent = re.compile(u"^ *").match
 
 
-def strip_common_indent(lines):
+def strip_common_indent(lines): 
     """Strips empty lines and common indentation from the list of strings given in lines"""
-    # TODO: Facilitate textwrap.indent instead
-    lines = [x for x in lines if x.strip() != u""]
+    # TODO: Facilitate textwrap.indent instead 
+    lines = [x for x in lines if x.strip() != u""] 
     if lines:
         minindent = min([len(_match_indent(x).group(0)) for x in lines])
         lines = [x[minindent:] for x in lines]
-    return lines
-
+    return lines 
+ 
 
-class TreeFragment(object):
+class TreeFragment(object): 
     def __init__(self, code, name=None, pxds=None, temps=None, pipeline=None, level=None, initial_pos=None):
         if pxds is None:
             pxds = {}
@@ -227,49 +227,49 @@ class TreeFragment(object):
             name = "(tree fragment)"
 
         if isinstance(code, _unicode):
-            def fmt(x): return u"\n".join(strip_common_indent(x.split(u"\n")))
-
-            fmt_code = fmt(code)
-            fmt_pxds = {}
+            def fmt(x): return u"\n".join(strip_common_indent(x.split(u"\n"))) 
+ 
+            fmt_code = fmt(code) 
+            fmt_pxds = {} 
             for key, value in pxds.items():
-                fmt_pxds[key] = fmt(value)
-            mod = t = parse_from_strings(name, fmt_code, fmt_pxds, level=level, initial_pos=initial_pos)
-            if level is None:
-                t = t.body # Make sure a StatListNode is at the top
-            if not isinstance(t, StatListNode):
-                t = StatListNode(pos=mod.pos, stats=[t])
-            for transform in pipeline:
-                if transform is None:
-                    continue
-                t = transform(t)
-            self.root = t
-        elif isinstance(code, Node):
+                fmt_pxds[key] = fmt(value) 
+            mod = t = parse_from_strings(name, fmt_code, fmt_pxds, level=level, initial_pos=initial_pos) 
+            if level is None: 
+                t = t.body # Make sure a StatListNode is at the top 
+            if not isinstance(t, StatListNode): 
+                t = StatListNode(pos=mod.pos, stats=[t]) 
+            for transform in pipeline: 
+                if transform is None: 
+                    continue 
+                t = transform(t) 
+            self.root = t 
+        elif isinstance(code, Node): 
             if pxds:
                 raise NotImplementedError()
-            self.root = code
-        else:
-            raise ValueError("Unrecognized code format (accepts unicode and Node)")
-        self.temps = temps
-
-    def copy(self):
-        return copy_code_tree(self.root)
-
+            self.root = code 
+        else: 
+            raise ValueError("Unrecognized code format (accepts unicode and Node)") 
+        self.temps = temps 
+ 
+    def copy(self): 
+        return copy_code_tree(self.root) 
+ 
     def substitute(self, nodes=None, temps=None, pos = None):
         if nodes is None:
             nodes = {}
         if temps is None:
             temps = []
-        return TemplateTransform()(self.root,
-                                   substitutions = nodes,
-                                   temps = self.temps + temps, pos = pos)
-
-
-class SetPosTransform(VisitorTransform):
-    def __init__(self, pos):
-        super(SetPosTransform, self).__init__()
-        self.pos = pos
-
-    def visit_Node(self, node):
-        node.pos = self.pos
-        self.visitchildren(node)
-        return node
+        return TemplateTransform()(self.root, 
+                                   substitutions = nodes, 
+                                   temps = self.temps + temps, pos = pos) 
+ 
+
+class SetPosTransform(VisitorTransform): 
+    def __init__(self, pos): 
+        super(SetPosTransform, self).__init__() 
+        self.pos = pos 
+ 
+    def visit_Node(self, node): 
+        node.pos = self.pos 
+        self.visitchildren(node) 
+        return node