text: 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(t, 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
  
      @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
          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)
  