Spaces:
Build error
Build error
| 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 | |
| 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 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: | |
| 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, | |
| 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. | |
| context_types = {} | |
| 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 | |
| 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() | |
| else: | |
| return False | |
| def _equality_params(self): | |
| outer_scope = self.outer_module_scope | |
| while isinstance(outer_scope, NonManglingModuleScope): | |
| outer_scope = outer_scope.outer_scope | |
| return self.impl, outer_scope, self.compiler_directives | |
| 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 | |
| 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) | |
| 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) | |
| def merge_scope(scope): | |
| def merge_scope_transform(module_node): | |
| module_node.scope.merge_in(scope) | |
| 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( | |
| pipeline, merge_scope(dep.tree.scope), | |
| before=ParseTreeTransforms.AnalyseDeclarationsTransform) | |
| if self.outer_module_scope: | |
| # inject outer module between utility code module and builtin module | |
| def scope_transform(module_node): | |
| module_node.scope.outer_scope = self.outer_module_scope | |
| return module_node | |
| pipeline = Pipeline.insert_into_pipeline( | |
| pipeline, scope_transform, | |
| before=ParseTreeTransforms.AnalyseDeclarationsTransform) | |
| if self.context_types: | |
| # inject types into module scope | |
| def scope_transform(module_node): | |
| for name, type in self.context_types.items(): | |
| entry = module_node.scope.declare_type(name, type, None, visibility='extern') | |
| entry.in_cinclude = True | |
| return module_node | |
| pipeline = Pipeline.insert_into_pipeline( | |
| pipeline, scope_transform, | |
| before=ParseTreeTransforms.AnalyseDeclarationsTransform) | |
| (err, tree) = Pipeline.run_pipeline(pipeline, tree, printtree=False) | |
| assert not err, err | |
| self.tree = tree | |
| return tree | |
| def put_code(self, output): | |
| pass | |
| 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 | |
| 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: | |
| 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) | |