class_docstr: 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.
class_docstr_tok: ["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","."]
code: 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
  
imports: from __future__ import absolute_import
  from .TreeFragment import parse_from_strings, StringParseContext
  from .None import Symtab
  from .None import Naming
  from .None import Code
label_desc: Use image node_id 5 for calling the CythonUtilityCode obj's underlying member method code with example usage: obj.get_tree(entries_only, cython_scope) and returns: tree, merge_scope_transform, module_node, module_node, module_node