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

1 files changed, 159 insertions, 159 deletions

diff --git a/contrib/tools/cython/Cython/Compiler/UtilityCode.py b/contrib/tools/cython/Cython/Compiler/UtilityCode.py
index 98e9ab5bfb..401422222f 100644
--- a/contrib/tools/cython/Cython/Compiler/UtilityCode.py
+++ b/contrib/tools/cython/Cython/Compiler/UtilityCode.py
@@ -1,99 +1,99 @@
-from __future__ import absolute_import
-
-from .TreeFragment import parse_from_strings, StringParseContext
-from . import Symtab
-from . import Naming
-from . import Code
-
-
-class NonManglingModuleScope(Symtab.ModuleScope):
-
-    def __init__(self, prefix, *args, **kw):
-        self.prefix = prefix
-        self.cython_scope = None
+from __future__ import absolute_import 
+ 
+from .TreeFragment import parse_from_strings, StringParseContext 
+from . import Symtab 
+from . import Naming 
+from . import Code 
+ 
+ 
+class NonManglingModuleScope(Symtab.ModuleScope): 
+ 
+    def __init__(self, prefix, *args, **kw): 
+        self.prefix = prefix 
+        self.cython_scope = None 
         self.cpp = kw.pop('cpp', False)
-        Symtab.ModuleScope.__init__(self, *args, **kw)
-
-    def add_imported_entry(self, name, entry, pos):
-        entry.used = True
+        Symtab.ModuleScope.__init__(self, *args, **kw) 
+ 
+    def add_imported_entry(self, name, entry, pos): 
+        entry.used = True 
         return super(NonManglingModuleScope, self).add_imported_entry(name, entry, pos)
-
-    def mangle(self, prefix, name=None):
-        if name:
-            if prefix in (Naming.typeobj_prefix, Naming.func_prefix, Naming.var_prefix, Naming.pyfunc_prefix):
-                # Functions, classes etc. gets a manually defined prefix easily
-                # manually callable instead (the one passed to CythonUtilityCode)
-                prefix = self.prefix
-            return "%s%s" % (prefix, name)
-        else:
-            return Symtab.ModuleScope.mangle(self, prefix)
-
-
-class CythonUtilityCodeContext(StringParseContext):
-    scope = None
-
+ 
+    def mangle(self, prefix, name=None): 
+        if name: 
+            if prefix in (Naming.typeobj_prefix, Naming.func_prefix, Naming.var_prefix, Naming.pyfunc_prefix): 
+                # Functions, classes etc. gets a manually defined prefix easily 
+                # manually callable instead (the one passed to CythonUtilityCode) 
+                prefix = self.prefix 
+            return "%s%s" % (prefix, name) 
+        else: 
+            return Symtab.ModuleScope.mangle(self, prefix) 
+ 
+
+class CythonUtilityCodeContext(StringParseContext): 
+    scope = None 
+ 
     def find_module(self, module_name, relative_to=None, pos=None, need_pxd=True, absolute_fallback=True):
         if relative_to:
             raise AssertionError("Relative imports not supported in utility code.")
-        if module_name != self.module_name:
-            if module_name not in self.modules:
-                raise AssertionError("Only the cython cimport is supported.")
-            else:
-                return self.modules[module_name]
-
-        if self.scope is None:
+        if module_name != self.module_name: 
+            if module_name not in self.modules: 
+                raise AssertionError("Only the cython cimport is supported.") 
+            else: 
+                return self.modules[module_name] 
+ 
+        if self.scope is None: 
             self.scope = NonManglingModuleScope(
                 self.prefix, module_name, parent_module=None, context=self, cpp=self.cpp)
-
-        return self.scope
-
-
-class CythonUtilityCode(Code.UtilityCodeBase):
-    """
-    Utility code written in the Cython language itself.
-
-    The @cname decorator can set the cname for a function, method of cdef class.
-    Functions decorated with @cname('c_func_name') get the given cname.
-
-    For cdef classes the rules are as follows:
-        obj struct      -> <cname>_obj
-        obj type ptr    -> <cname>_type
-        methods         -> <class_cname>_<method_cname>
-
-    For methods the cname decorator is optional, but without the decorator the
-    methods will not be prototyped. See Cython.Compiler.CythonScope and
-    tests/run/cythonscope.pyx for examples.
-    """
-
-    is_cython_utility = True
-
-    def __init__(self, impl, name="__pyxutil", prefix="", requires=None,
+ 
+        return self.scope 
+ 
+ 
+class CythonUtilityCode(Code.UtilityCodeBase): 
+    """ 
+    Utility code written in the Cython language itself. 
+ 
+    The @cname decorator can set the cname for a function, method of cdef class. 
+    Functions decorated with @cname('c_func_name') get the given cname. 
+ 
+    For cdef classes the rules are as follows: 
+        obj struct      -> <cname>_obj 
+        obj type ptr    -> <cname>_type 
+        methods         -> <class_cname>_<method_cname> 
+ 
+    For methods the cname decorator is optional, but without the decorator the 
+    methods will not be prototyped. See Cython.Compiler.CythonScope and 
+    tests/run/cythonscope.pyx for examples. 
+    """ 
+ 
+    is_cython_utility = True 
+ 
+    def __init__(self, impl, name="__pyxutil", prefix="", requires=None, 
                  file=None, from_scope=None, context=None, compiler_directives=None,
                  outer_module_scope=None):
-        # 1) We need to delay the parsing/processing, so that all modules can be
-        #    imported without import loops
-        # 2) The same utility code object can be used for multiple source files;
-        #    while the generated node trees can be altered in the compilation of a
-        #    single file.
-        # Hence, delay any processing until later.
+        # 1) We need to delay the parsing/processing, so that all modules can be 
+        #    imported without import loops 
+        # 2) The same utility code object can be used for multiple source files; 
+        #    while the generated node trees can be altered in the compilation of a 
+        #    single file. 
+        # Hence, delay any processing until later. 
         context_types = {}
-        if context is not None:
+        if context is not None: 
             from .PyrexTypes import BaseType
             for key, value in context.items():
                 if isinstance(value, BaseType):
                     context[key] = key
                     context_types[key] = value
-            impl = Code.sub_tempita(impl, context, file, name)
-        self.impl = impl
-        self.name = name
-        self.file = file
-        self.prefix = prefix
-        self.requires = requires or []
-        self.from_scope = from_scope
+            impl = Code.sub_tempita(impl, context, file, name) 
+        self.impl = impl 
+        self.name = name 
+        self.file = file 
+        self.prefix = prefix 
+        self.requires = requires or [] 
+        self.from_scope = from_scope 
         self.outer_module_scope = outer_module_scope
         self.compiler_directives = compiler_directives
         self.context_types = context_types
-
+ 
     def __eq__(self, other):
         if isinstance(other, CythonUtilityCode):
             return self._equality_params() == other._equality_params()
@@ -109,51 +109,51 @@ class CythonUtilityCode(Code.UtilityCodeBase):
     def __hash__(self):
         return hash(self.impl)
 
-    def get_tree(self, entries_only=False, cython_scope=None):
-        from .AnalysedTreeTransforms import AutoTestDictTransform
-        # The AutoTestDictTransform creates the statement "__test__ = {}",
-        # which when copied into the main ModuleNode overwrites
-        # any __test__ in user code; not desired
-        excludes = [AutoTestDictTransform]
-
-        from . import Pipeline, ParseTreeTransforms
+    def get_tree(self, entries_only=False, cython_scope=None): 
+        from .AnalysedTreeTransforms import AutoTestDictTransform 
+        # The AutoTestDictTransform creates the statement "__test__ = {}", 
+        # which when copied into the main ModuleNode overwrites 
+        # any __test__ in user code; not desired 
+        excludes = [AutoTestDictTransform] 
+ 
+        from . import Pipeline, ParseTreeTransforms 
         context = CythonUtilityCodeContext(
             self.name, compiler_directives=self.compiler_directives,
             cpp=cython_scope.is_cpp() if cython_scope else False)
-        context.prefix = self.prefix
-        context.cython_scope = cython_scope
-        #context = StringParseContext(self.name)
+        context.prefix = self.prefix 
+        context.cython_scope = cython_scope 
+        #context = StringParseContext(self.name) 
         tree = parse_from_strings(
             self.name, self.impl, context=context, allow_struct_enum_decorator=True)
-        pipeline = Pipeline.create_pipeline(context, 'pyx', exclude_classes=excludes)
-
-        if entries_only:
-            p = []
-            for t in pipeline:
-                p.append(t)
-                if isinstance(p, ParseTreeTransforms.AnalyseDeclarationsTransform):
-                    break
-
-            pipeline = p
-
-        transform = ParseTreeTransforms.CnameDirectivesTransform(context)
-        # InterpretCompilerDirectives already does a cdef declarator check
-        #before = ParseTreeTransforms.DecoratorTransform
-        before = ParseTreeTransforms.InterpretCompilerDirectives
-        pipeline = Pipeline.insert_into_pipeline(pipeline, transform,
-                                                 before=before)
-
+        pipeline = Pipeline.create_pipeline(context, 'pyx', exclude_classes=excludes) 
+ 
+        if entries_only: 
+            p = [] 
+            for t in pipeline: 
+                p.append(t) 
+                if isinstance(p, ParseTreeTransforms.AnalyseDeclarationsTransform): 
+                    break 
+ 
+            pipeline = p 
+ 
+        transform = ParseTreeTransforms.CnameDirectivesTransform(context) 
+        # InterpretCompilerDirectives already does a cdef declarator check 
+        #before = ParseTreeTransforms.DecoratorTransform 
+        before = ParseTreeTransforms.InterpretCompilerDirectives 
+        pipeline = Pipeline.insert_into_pipeline(pipeline, transform, 
+                                                 before=before) 
+ 
         def merge_scope(scope):
             def merge_scope_transform(module_node):
                 module_node.scope.merge_in(scope)
-                return module_node
+                return module_node 
             return merge_scope_transform
-
+ 
         if self.from_scope:
             pipeline = Pipeline.insert_into_pipeline(
                 pipeline, merge_scope(self.from_scope),
                 before=ParseTreeTransforms.AnalyseDeclarationsTransform)
-
+ 
         for dep in self.requires:
             if isinstance(dep, CythonUtilityCode) and hasattr(dep, 'tree') and not cython_scope:
                 pipeline = Pipeline.insert_into_pipeline(
@@ -182,56 +182,56 @@ class CythonUtilityCode(Code.UtilityCodeBase):
                 pipeline, scope_transform,
                 before=ParseTreeTransforms.AnalyseDeclarationsTransform)
 
-        (err, tree) = Pipeline.run_pipeline(pipeline, tree, printtree=False)
-        assert not err, err
+        (err, tree) = Pipeline.run_pipeline(pipeline, tree, printtree=False) 
+        assert not err, err 
         self.tree = tree
-        return tree
-
-    def put_code(self, output):
-        pass
-
-    @classmethod
-    def load_as_string(cls, util_code_name, from_file=None, **kwargs):
-        """
-        Load a utility code as a string. Returns (proto, implementation)
-        """
-        util = cls.load(util_code_name, from_file, **kwargs)
-        return util.proto, util.impl # keep line numbers => no lstrip()
-
-    def declare_in_scope(self, dest_scope, used=False, cython_scope=None,
-                         whitelist=None):
-        """
-        Declare all entries from the utility code in dest_scope. Code will only
-        be included for used entries. If module_name is given, declare the
-        type entries with that name.
-        """
-        tree = self.get_tree(entries_only=True, cython_scope=cython_scope)
-
-        entries = tree.scope.entries
-        entries.pop('__name__')
-        entries.pop('__file__')
-        entries.pop('__builtins__')
-        entries.pop('__doc__')
-
+        return tree 
+ 
+    def put_code(self, output): 
+        pass 
+ 
+    @classmethod 
+    def load_as_string(cls, util_code_name, from_file=None, **kwargs): 
+        """ 
+        Load a utility code as a string. Returns (proto, implementation) 
+        """ 
+        util = cls.load(util_code_name, from_file, **kwargs) 
+        return util.proto, util.impl # keep line numbers => no lstrip() 
+ 
+    def declare_in_scope(self, dest_scope, used=False, cython_scope=None, 
+                         whitelist=None): 
+        """ 
+        Declare all entries from the utility code in dest_scope. Code will only 
+        be included for used entries. If module_name is given, declare the 
+        type entries with that name. 
+        """ 
+        tree = self.get_tree(entries_only=True, cython_scope=cython_scope) 
+ 
+        entries = tree.scope.entries 
+        entries.pop('__name__') 
+        entries.pop('__file__') 
+        entries.pop('__builtins__') 
+        entries.pop('__doc__') 
+ 
         for entry in entries.values():
-            entry.utility_code_definition = self
-            entry.used = used
-
-        original_scope = tree.scope
+            entry.utility_code_definition = self 
+            entry.used = used 
+ 
+        original_scope = tree.scope 
         dest_scope.merge_in(original_scope, merge_unused=True, whitelist=whitelist)
-        tree.scope = dest_scope
-
-        for dep in self.requires:
-            if dep.is_cython_utility:
+        tree.scope = dest_scope 
+ 
+        for dep in self.requires: 
+            if dep.is_cython_utility: 
                 dep.declare_in_scope(dest_scope, cython_scope=cython_scope)
-
-        return original_scope
-
-
-def declare_declarations_in_scope(declaration_string, env, private_type=True,
-                                  *args, **kwargs):
-    """
-    Declare some declarations given as Cython code in declaration_string
-    in scope env.
-    """
-    CythonUtilityCode(declaration_string, *args, **kwargs).declare_in_scope(env)
+ 
+        return original_scope 
+ 
+
+def declare_declarations_in_scope(declaration_string, env, private_type=True, 
+                                  *args, **kwargs): 
+    """ 
+    Declare some declarations given as Cython code in declaration_string 
+    in scope env. 
+    """ 
+    CythonUtilityCode(declaration_string, *args, **kwargs).declare_in_scope(env)