fix ya.make

1 files changed, 0 insertions, 3229 deletions

diff --git a/contrib/tools/cython/Cython/Compiler/ModuleNode.py b/contrib/tools/cython/Cython/Compiler/ModuleNode.py
deleted file mode 100644
index cd7166408e0..00000000000
--- a/contrib/tools/cython/Cython/Compiler/ModuleNode.py
+++ /dev/null
@@ -1,3229 +0,0 @@
-#
-#   Module parse tree node
-#
-
-from __future__ import absolute_import
-
-import cython
-cython.declare(Naming=object, Options=object, PyrexTypes=object, TypeSlots=object,
-               error=object, warning=object, py_object_type=object, UtilityCode=object,
-               EncodedString=object, re=object)
-
-from collections import defaultdict
-import json
-import operator
-import os
-import re
-
-from .PyrexTypes import CPtrType
-from . import Future
-from . import Annotate
-from . import Code
-from . import Naming
-from . import Nodes
-from . import Options
-from . import TypeSlots
-from . import PyrexTypes
-from . import Pythran
-
-from .Errors import error, warning
-from .PyrexTypes import py_object_type
-from ..Utils import open_new_file, replace_suffix, decode_filename, build_hex_version
-from .Code import UtilityCode, IncludeCode
-from .StringEncoding import EncodedString
-from .Pythran import has_np_pythran
-
-def check_c_declarations_pxd(module_node):
-    module_node.scope.check_c_classes_pxd()
-    return module_node
-
-
-def check_c_declarations(module_node):
-    module_node.scope.check_c_classes()
-    module_node.scope.check_c_functions()
-    return module_node
-
-
-def generate_c_code_config(env, options):
-    if Options.annotate or options.annotate:
-        emit_linenums = False
-    else:
-        emit_linenums = options.emit_linenums
-
-    return Code.CCodeConfig(
-        emit_linenums=emit_linenums,
-        emit_code_comments=env.directives['emit_code_comments'],
-        c_line_in_traceback=options.c_line_in_traceback)
-
-
-class ModuleNode(Nodes.Node, Nodes.BlockNode):
-    #  doc       string or None
-    #  body      StatListNode
-    #
-    #  referenced_modules   [ModuleScope]
-    #  full_module_name     string
-    #
-    #  scope                The module scope.
-    #  compilation_source   A CompilationSource (see Main)
-    #  directives           Top-level compiler directives
-
-    child_attrs = ["body"]
-    directives = None
-
-    def merge_in(self, tree, scope, merge_scope=False):
-        # Merges in the contents of another tree, and possibly scope. With the
-        # current implementation below, this must be done right prior
-        # to code generation.
-        #
-        # Note: This way of doing it seems strange -- I believe the
-        # right concept is to split ModuleNode into a ModuleNode and a
-        # CodeGenerator, and tell that CodeGenerator to generate code
-        # from multiple sources.
-        assert isinstance(self.body, Nodes.StatListNode)
-        if isinstance(tree, Nodes.StatListNode):
-            self.body.stats.extend(tree.stats)
-        else:
-            self.body.stats.append(tree)
-
-        self.scope.utility_code_list.extend(scope.utility_code_list)
-
-        for inc in scope.c_includes.values():
-            self.scope.process_include(inc)
-
-        def extend_if_not_in(L1, L2):
-            for x in L2:
-                if x not in L1:
-                    L1.append(x)
-
-        extend_if_not_in(self.scope.included_files, scope.included_files)
-
-        if merge_scope:
-            # Ensure that we don't generate import code for these entries!
-            for entry in scope.c_class_entries:
-                entry.type.module_name = self.full_module_name
-                entry.type.scope.directives["internal"] = True
-
-            self.scope.merge_in(scope)
-
-    def analyse_declarations(self, env):
-        if has_np_pythran(env):
-            Pythran.include_pythran_generic(env)
-        if self.directives:
-            env.old_style_globals = self.directives['old_style_globals']
-        if not Options.docstrings:
-            env.doc = self.doc = None
-        elif Options.embed_pos_in_docstring:
-            env.doc = EncodedString(u'File: %s (starting at line %s)' % Nodes.relative_position(self.pos))
-            if self.doc is not None:
-                env.doc = EncodedString(env.doc + u'\n' + self.doc)
-                env.doc.encoding = self.doc.encoding
-        else:
-            env.doc = self.doc
-        env.directives = self.directives
-
-        self.body.analyse_declarations(env)
-
-    def prepare_utility_code(self):
-        # prepare any utility code that must be created before code generation
-        # specifically: CythonUtilityCode
-        env = self.scope
-        if env.has_import_star:
-            self.create_import_star_conversion_utility_code(env)
-        for name, entry in sorted(env.entries.items()):
-            if (entry.create_wrapper and entry.scope is env
-                and entry.is_type and entry.type.is_enum):
-                    entry.type.create_type_wrapper(env)
-
-    def process_implementation(self, options, result):
-        env = self.scope
-        env.return_type = PyrexTypes.c_void_type
-        self.referenced_modules = []
-        self.find_referenced_modules(env, self.referenced_modules, {})
-        self.sort_cdef_classes(env)
-        self.generate_c_code(env, options, result)
-        self.generate_h_code(env, options, result)
-        self.generate_api_code(env, options, result)
-
-    def has_imported_c_functions(self):
-        for module in self.referenced_modules:
-            for entry in module.cfunc_entries:
-                if entry.defined_in_pxd:
-                    return 1
-        return 0
-
-    def generate_h_code(self, env, options, result):
-        def h_entries(entries, api=0, pxd=0):
-            return [entry for entry in entries
-                    if ((entry.visibility == 'public') or
-                        (api and entry.api) or
-                        (pxd and entry.defined_in_pxd))]
-        h_types = h_entries(env.type_entries, api=1)
-        h_vars = h_entries(env.var_entries)
-        h_funcs = h_entries(env.cfunc_entries)
-        h_extension_types = h_entries(env.c_class_entries)
-        if h_types or  h_vars or h_funcs or h_extension_types:
-            result.h_file = replace_suffix(result.c_file, ".h")
-            h_code = Code.CCodeWriter()
-            c_code_config = generate_c_code_config(env, options)
-            Code.GlobalState(h_code, self, c_code_config)
-            if options.generate_pxi:
-                result.i_file = replace_suffix(result.c_file, ".pxi")
-                i_code = Code.PyrexCodeWriter(result.i_file)
-            else:
-                i_code = None
-
-            h_code.put_generated_by()
-            h_guard = Naming.h_guard_prefix + self.api_name(env)
-            h_code.put_h_guard(h_guard)
-            h_code.putln("")
-            h_code.putln('#include "Python.h"')
-            self.generate_type_header_code(h_types, h_code)
-            if options.capi_reexport_cincludes:
-                self.generate_includes(env, [], h_code)
-            h_code.putln("")
-            api_guard = Naming.api_guard_prefix + self.api_name(env)
-            h_code.putln("#ifndef %s" % api_guard)
-            h_code.putln("")
-            self.generate_extern_c_macro_definition(h_code)
-            h_code.putln("")
-            self.generate_dl_import_macro(h_code)
-            if h_extension_types:
-                h_code.putln("")
-                for entry in h_extension_types:
-                    self.generate_cclass_header_code(entry.type, h_code)
-                    if i_code:
-                        self.generate_cclass_include_code(entry.type, i_code)
-            if h_funcs:
-                h_code.putln("")
-                for entry in h_funcs:
-                    self.generate_public_declaration(entry, h_code, i_code)
-            if h_vars:
-                h_code.putln("")
-                for entry in h_vars:
-                    self.generate_public_declaration(entry, h_code, i_code)
-            h_code.putln("")
-            h_code.putln("#endif /* !%s */" % api_guard)
-            h_code.putln("")
-            h_code.putln("/* WARNING: the interface of the module init function changed in CPython 3.5. */")
-            h_code.putln("/* It now returns a PyModuleDef instance instead of a PyModule instance. */")
-            h_code.putln("")
-            h_code.putln("#if PY_MAJOR_VERSION < 3")
-            init_name = 'init' + (options.init_suffix or env.module_name)
-            h_code.putln("PyMODINIT_FUNC %s(void);" % init_name)
-            h_code.putln("#else")
-            h_code.putln("PyMODINIT_FUNC %s(void);" % self.mod_init_func_cname('PyInit', env, options))
-            h_code.putln("#endif")
-            h_code.putln("")
-            h_code.putln("#endif /* !%s */" % h_guard)
-
-            f = open_new_file(result.h_file)
-            try:
-                h_code.copyto(f)
-            finally:
-                f.close()
-
-    def generate_public_declaration(self, entry, h_code, i_code):
-        h_code.putln("%s %s;" % (
-            Naming.extern_c_macro,
-            entry.type.declaration_code(entry.cname)))
-        if i_code:
-            i_code.putln("cdef extern %s" % (
-                entry.type.declaration_code(entry.cname, pyrex=1)))
-
-    def api_name(self, env):
-        return env.qualified_name.replace(".", "__")
-
-    def generate_api_code(self, env, options, result):
-        def api_entries(entries, pxd=0):
-            return [entry for entry in entries
-                    if entry.api or (pxd and entry.defined_in_pxd)]
-        api_vars = api_entries(env.var_entries)
-        api_funcs = api_entries(env.cfunc_entries)
-        api_extension_types = api_entries(env.c_class_entries)
-        if api_vars or api_funcs or api_extension_types:
-            result.api_file = replace_suffix(result.c_file, "_api.h")
-            h_code = Code.CCodeWriter()
-            c_code_config = generate_c_code_config(env, options)
-            Code.GlobalState(h_code, self, c_code_config)
-            h_code.put_generated_by()
-            api_guard = Naming.api_guard_prefix + self.api_name(env)
-            h_code.put_h_guard(api_guard)
-            # Work around https://bugs.python.org/issue4709
-            h_code.putln('#ifdef __MINGW64__')
-            h_code.putln('#define MS_WIN64')
-            h_code.putln('#endif')
-
-            h_code.putln('#include "Python.h"')
-            if result.h_file:
-                h_code.putln('#include "%s"' % os.path.basename(result.h_file))
-            if api_extension_types:
-                h_code.putln("")
-                for entry in api_extension_types:
-                    type = entry.type
-                    h_code.putln("static PyTypeObject *%s = 0;" % type.typeptr_cname)
-                    h_code.putln("#define %s (*%s)" % (
-                        type.typeobj_cname, type.typeptr_cname))
-            if api_funcs:
-                h_code.putln("")
-                for entry in api_funcs:
-                    type = CPtrType(entry.type)
-                    cname = env.mangle(Naming.func_prefix_api, entry.name)
-                    h_code.putln("static %s = 0;" % type.declaration_code(cname))
-                    h_code.putln("#define %s %s" % (entry.name, cname))
-            if api_vars:
-                h_code.putln("")
-                for entry in api_vars:
-                    type = CPtrType(entry.type)
-                    cname = env.mangle(Naming.varptr_prefix_api, entry.name)
-                    h_code.putln("static %s = 0;" %  type.declaration_code(cname))
-                    h_code.putln("#define %s (*%s)" % (entry.name, cname))
-            h_code.put(UtilityCode.load_as_string("PyIdentifierFromString", "ImportExport.c")[0])
-            if api_vars:
-                h_code.put(UtilityCode.load_as_string("VoidPtrImport", "ImportExport.c")[1])
-            if api_funcs:
-                h_code.put(UtilityCode.load_as_string("FunctionImport", "ImportExport.c")[1])
-            if api_extension_types:
-                h_code.put(UtilityCode.load_as_string("TypeImport", "ImportExport.c")[0])
-                h_code.put(UtilityCode.load_as_string("TypeImport", "ImportExport.c")[1])
-            h_code.putln("")
-            h_code.putln("static int import_%s(void) {" % self.api_name(env))
-            h_code.putln("PyObject *module = 0;")
-            h_code.putln('module = PyImport_ImportModule("%s");' % env.qualified_name)
-            h_code.putln("if (!module) goto bad;")
-            for entry in api_funcs:
-                cname = env.mangle(Naming.func_prefix_api, entry.name)
-                sig = entry.type.signature_string()
-                h_code.putln(
-                    'if (__Pyx_ImportFunction(module, "%s", (void (**)(void))&%s, "%s") < 0) goto bad;'
-                    % (entry.name, cname, sig))
-            for entry in api_vars:
-                cname = env.mangle(Naming.varptr_prefix_api, entry.name)
-                sig = entry.type.empty_declaration_code()
-                h_code.putln(
-                    'if (__Pyx_ImportVoidPtr(module, "%s", (void **)&%s, "%s") < 0) goto bad;'
-                    % (entry.name, cname, sig))
-            with ModuleImportGenerator(h_code, imported_modules={env.qualified_name: 'module'}) as import_generator:
-                for entry in api_extension_types:
-                    self.generate_type_import_call(entry.type, h_code, import_generator, error_code="goto bad;")
-            h_code.putln("Py_DECREF(module); module = 0;")
-            h_code.putln("return 0;")
-            h_code.putln("bad:")
-            h_code.putln("Py_XDECREF(module);")
-            h_code.putln("return -1;")
-            h_code.putln("}")
-            h_code.putln("")
-            h_code.putln("#endif /* !%s */" % api_guard)
-
-            f = open_new_file(result.api_file)
-            try:
-                h_code.copyto(f)
-            finally:
-                f.close()
-
-    def generate_cclass_header_code(self, type, h_code):
-        h_code.putln("%s %s %s;" % (
-            Naming.extern_c_macro,
-            PyrexTypes.public_decl("PyTypeObject", "DL_IMPORT"),
-            type.typeobj_cname))
-
-    def generate_cclass_include_code(self, type, i_code):
-        i_code.putln("cdef extern class %s.%s:" % (
-            type.module_name, type.name))
-        i_code.indent()
-        var_entries = type.scope.var_entries
-        if var_entries:
-            for entry in var_entries:
-                i_code.putln("cdef %s" % (
-                    entry.type.declaration_code(entry.cname, pyrex=1)))
-        else:
-            i_code.putln("pass")
-        i_code.dedent()
-
-    def generate_c_code(self, env, options, result):
-        modules = self.referenced_modules
-
-        if Options.annotate or options.annotate:
-            rootwriter = Annotate.AnnotationCCodeWriter()
-        else:
-            rootwriter = Code.CCodeWriter()
-
-        c_code_config = generate_c_code_config(env, options)
-
-        globalstate = Code.GlobalState(
-            rootwriter, self,
-            code_config=c_code_config,
-            common_utility_include_dir=options.common_utility_include_dir,
-        )
-        globalstate.initialize_main_c_code()
-        h_code = globalstate['h_code']
-
-        self.generate_module_preamble(env, options, modules, result.embedded_metadata, h_code)
-
-        globalstate.module_pos = self.pos
-        globalstate.directives = self.directives
-
-        globalstate.use_utility_code(refnanny_utility_code)
-
-        code = globalstate['before_global_var']
-        code.putln('#define __Pyx_MODULE_NAME "%s"' % self.full_module_name)
-        module_is_main = "%s%s" % (Naming.module_is_main, self.full_module_name.replace('.', '__'))
-        code.putln("extern int %s;" % module_is_main)
-        code.putln("int %s = 0;" % module_is_main)
-        code.putln("")
-        code.putln("/* Implementation of '%s' */" % env.qualified_name)
-
-        code = globalstate['late_includes']
-        code.putln("/* Late includes */")
-        self.generate_includes(env, modules, code, early=False)
-
-        code = globalstate['all_the_rest']
-
-        self.generate_cached_builtins_decls(env, code)
-        self.generate_lambda_definitions(env, code)
-        # generate normal variable and function definitions
-        self.generate_variable_definitions(env, code)
-
-        self.body.generate_function_definitions(env, code)
-
-        code.mark_pos(None)
-        self.generate_typeobj_definitions(env, code)
-        self.generate_method_table(env, code)
-        if env.has_import_star:
-            self.generate_import_star(env, code)
-        self.generate_pymoduledef_struct(env, options, code)
-
-        # initialise the macro to reduce the code size of one-time functionality
-        code.putln(UtilityCode.load_as_string("SmallCodeConfig", "ModuleSetupCode.c")[0].strip())
-
-        # init_globals is inserted before this
-        self.generate_module_init_func(modules[:-1], env, options, globalstate['init_module'])
-        self.generate_module_cleanup_func(env, globalstate['cleanup_module'])
-        if Options.embed:
-            self.generate_main_method(env, globalstate['main_method'])
-        self.generate_filename_table(globalstate['filename_table'])
-
-        self.generate_declarations_for_modules(env, modules, globalstate)
-        h_code.write('\n')
-
-        for utilcode in env.utility_code_list[:]:
-            globalstate.use_utility_code(utilcode)
-        globalstate.finalize_main_c_code()
-
-        f = open_new_file(result.c_file)
-        try:
-            rootwriter.copyto(f)
-        finally:
-            f.close()
-        result.c_file_generated = 1
-        if options.gdb_debug:
-            self._serialize_lineno_map(env, rootwriter)
-        if Options.annotate or options.annotate:
-            self._generate_annotations(rootwriter, result, options)
-
-    def _generate_annotations(self, rootwriter, result, options):
-        self.annotate(rootwriter)
-
-        coverage_xml_filename = Options.annotate_coverage_xml or options.annotate_coverage_xml
-        if coverage_xml_filename and os.path.exists(coverage_xml_filename):
-            try:
-                import xml.etree.cElementTree as ET
-            except ImportError:
-                import xml.etree.ElementTree as ET
-            coverage_xml = ET.parse(coverage_xml_filename).getroot()
-            if hasattr(coverage_xml, 'iter'):
-                iterator = coverage_xml.iter()  # Python 2.7 & 3.2+
-            else:
-                iterator = coverage_xml.getiterator()
-            for el in iterator:
-                el.tail = None  # save some memory
-        else:
-            coverage_xml = None
-
-        rootwriter.save_annotation(result.main_source_file, result.c_file, coverage_xml=coverage_xml)
-
-        # if we included files, additionally generate one annotation file for each
-        if not self.scope.included_files:
-            return
-
-        search_include_file = self.scope.context.search_include_directories
-        target_dir = os.path.abspath(os.path.dirname(result.c_file))
-        for included_file in self.scope.included_files:
-            target_file = os.path.abspath(os.path.join(target_dir, included_file))
-            target_file_dir = os.path.dirname(target_file)
-            if not target_file_dir.startswith(target_dir):
-                # any other directories may not be writable => avoid trying
-                continue
-            source_file = search_include_file(included_file, "", self.pos, include=True)
-            if not source_file:
-                continue
-            if target_file_dir != target_dir and not os.path.exists(target_file_dir):
-                try:
-                    os.makedirs(target_file_dir)
-                except OSError as e:
-                    import errno
-                    if e.errno != errno.EEXIST:
-                        raise
-            rootwriter.save_annotation(source_file, target_file, coverage_xml=coverage_xml)
-
-    def _serialize_lineno_map(self, env, ccodewriter):
-        tb = env.context.gdb_debug_outputwriter
-        markers = ccodewriter.buffer.allmarkers()
-
-        d = defaultdict(list)
-        for c_lineno, cython_lineno in enumerate(markers):
-            if cython_lineno > 0:
-                d[cython_lineno].append(c_lineno + 1)
-
-        tb.start('LineNumberMapping')
-        for cython_lineno, c_linenos in sorted(d.items()):
-            tb.add_entry(
-                'LineNumber',
-                c_linenos=' '.join(map(str, c_linenos)),
-                cython_lineno=str(cython_lineno),
-            )
-        tb.end('LineNumberMapping')
-        tb.serialize()
-
-    def find_referenced_modules(self, env, module_list, modules_seen):
-        if env not in modules_seen:
-            modules_seen[env] = 1
-            for imported_module in env.cimported_modules:
-                self.find_referenced_modules(imported_module, module_list, modules_seen)
-            module_list.append(env)
-
-    def sort_types_by_inheritance(self, type_dict, type_order, getkey):
-        # copy the types into a list moving each parent type before
-        # its first child
-        type_list = []
-        for i, key in enumerate(type_order):
-            new_entry = type_dict[key]
-
-            # collect all base classes to check for children
-            hierarchy = set()
-            base = new_entry
-            while base:
-                base_type = base.type.base_type
-                if not base_type:
-                    break
-                base_key = getkey(base_type)
-                hierarchy.add(base_key)
-                base = type_dict.get(base_key)
-            new_entry.base_keys = hierarchy
-
-            # find the first (sub-)subclass and insert before that
-            for j in range(i):
-                entry = type_list[j]
-                if key in entry.base_keys:
-                    type_list.insert(j, new_entry)
-                    break
-            else:
-                type_list.append(new_entry)
-        return type_list
-
-    def sort_type_hierarchy(self, module_list, env):
-        # poor developer's OrderedDict
-        vtab_dict, vtab_dict_order = {}, []
-        vtabslot_dict, vtabslot_dict_order = {}, []
-
-        for module in module_list:
-            for entry in module.c_class_entries:
-                if entry.used and not entry.in_cinclude:
-                    type = entry.type
-                    key = type.vtabstruct_cname
-                    if not key:
-                        continue
-                    if key in vtab_dict:
-                        # FIXME: this should *never* happen, but apparently it does
-                        # for Cython generated utility code
-                        from .UtilityCode import NonManglingModuleScope
-                        assert isinstance(entry.scope, NonManglingModuleScope), str(entry.scope)
-                        assert isinstance(vtab_dict[key].scope, NonManglingModuleScope), str(vtab_dict[key].scope)
-                    else:
-                        vtab_dict[key] = entry
-                        vtab_dict_order.append(key)
-            all_defined_here = module is env
-            for entry in module.type_entries:
-                if entry.used and (all_defined_here or entry.defined_in_pxd):
-                    type = entry.type
-                    if type.is_extension_type and not entry.in_cinclude:
-                        type = entry.type
-                        key = type.objstruct_cname
-                        assert key not in vtabslot_dict, key
-                        vtabslot_dict[key] = entry
-                        vtabslot_dict_order.append(key)
-
-        def vtabstruct_cname(entry_type):
-            return entry_type.vtabstruct_cname
-        vtab_list = self.sort_types_by_inheritance(
-            vtab_dict, vtab_dict_order, vtabstruct_cname)
-
-        def objstruct_cname(entry_type):
-            return entry_type.objstruct_cname
-        vtabslot_list = self.sort_types_by_inheritance(
-            vtabslot_dict, vtabslot_dict_order, objstruct_cname)
-
-        return (vtab_list, vtabslot_list)
-
-    def sort_cdef_classes(self, env):
-        key_func = operator.attrgetter('objstruct_cname')
-        entry_dict, entry_order = {}, []
-        for entry in env.c_class_entries:
-            key = key_func(entry.type)
-            assert key not in entry_dict, key
-            entry_dict[key] = entry
-            entry_order.append(key)
-        env.c_class_entries[:] = self.sort_types_by_inheritance(
-            entry_dict, entry_order, key_func)
-
-    def generate_type_definitions(self, env, modules, vtab_list, vtabslot_list, code):
-        # TODO: Why are these separated out?
-        for entry in vtabslot_list:
-            self.generate_objstruct_predeclaration(entry.type, code)
-        vtabslot_entries = set(vtabslot_list)
-        ctuple_names = set()
-        for module in modules:
-            definition = module is env
-            type_entries = []
-            for entry in module.type_entries:
-                if entry.type.is_ctuple and entry.used:
-                    if entry.name not in ctuple_names:
-                        ctuple_names.add(entry.name)
-                        type_entries.append(entry)
-                elif definition or entry.defined_in_pxd:
-                    type_entries.append(entry)
-            type_entries = [t for t in type_entries if t not in vtabslot_entries]
-            self.generate_type_header_code(type_entries, code)
-        for entry in vtabslot_list:
-            self.generate_objstruct_definition(entry.type, code)
-            self.generate_typeobj_predeclaration(entry, code)
-        for entry in vtab_list:
-            self.generate_typeobj_predeclaration(entry, code)
-            self.generate_exttype_vtable_struct(entry, code)
-            self.generate_exttype_vtabptr_declaration(entry, code)
-            self.generate_exttype_final_methods_declaration(entry, code)
-
-    def generate_declarations_for_modules(self, env, modules, globalstate):
-        typecode = globalstate['type_declarations']
-        typecode.putln("")
-        typecode.putln("/*--- Type declarations ---*/")
-        # This is to work around the fact that array.h isn't part of the C-API,
-        # but we need to declare it earlier than utility code.
-        if 'cpython.array' in [m.qualified_name for m in modules]:
-            typecode.putln('#ifndef _ARRAYARRAY_H')
-            typecode.putln('struct arrayobject;')
-            typecode.putln('typedef struct arrayobject arrayobject;')
-            typecode.putln('#endif')
-        vtab_list, vtabslot_list = self.sort_type_hierarchy(modules, env)
-        self.generate_type_definitions(
-            env, modules, vtab_list, vtabslot_list, typecode)
-        modulecode = globalstate['module_declarations']
-        for module in modules:
-            defined_here = module is env
-            modulecode.putln("")
-            modulecode.putln("/* Module declarations from '%s' */" % module.qualified_name)
-            self.generate_c_class_declarations(module, modulecode, defined_here)
-            self.generate_cvariable_declarations(module, modulecode, defined_here)
-            self.generate_cfunction_declarations(module, modulecode, defined_here)
-
-    def _put_setup_code(self, code, name):
-        code.put(UtilityCode.load_as_string(name, "ModuleSetupCode.c")[1])
-
-    def generate_module_preamble(self, env, options, cimported_modules, metadata, code):
-        code.put_generated_by()
-        if metadata:
-            code.putln("/* BEGIN: Cython Metadata")
-            code.putln(json.dumps(metadata, indent=4, sort_keys=True))
-            code.putln("END: Cython Metadata */")
-            code.putln("")
-
-        code.putln("#ifndef PY_SSIZE_T_CLEAN")
-        code.putln("#define PY_SSIZE_T_CLEAN")
-        code.putln("#endif /* PY_SSIZE_T_CLEAN */")
-
-        for inc in sorted(env.c_includes.values(), key=IncludeCode.sortkey):
-            if inc.location == inc.INITIAL:
-                inc.write(code)
-        code.putln("#ifndef Py_PYTHON_H")
-        code.putln("    #error Python headers needed to compile C extensions, "
-                   "please install development version of Python.")
-        code.putln("#elif PY_VERSION_HEX < 0x02060000 || "
-                   "(0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)")
-        code.putln("    #error Cython requires Python 2.6+ or Python 3.3+.")
-        code.putln("#else")
-        code.globalstate["end"].putln("#endif /* Py_PYTHON_H */")
-
-        from .. import __version__
-        code.putln('#define CYTHON_ABI "%s"' % __version__.replace('.', '_'))
-        code.putln('#define CYTHON_HEX_VERSION %s' % build_hex_version(__version__))
-        code.putln("#define CYTHON_FUTURE_DIVISION %d" % (
-            Future.division in env.context.future_directives))
-
-        self._put_setup_code(code, "CModulePreamble")
-        if env.context.options.cplus:
-            self._put_setup_code(code, "CppInitCode")
-        else:
-            self._put_setup_code(code, "CInitCode")
-        self._put_setup_code(code, "PythonCompatibility")
-        self._put_setup_code(code, "MathInitCode")
-
-        # Using "(void)cname" to prevent "unused" warnings.
-        if options.c_line_in_traceback:
-            cinfo = "%s = %s; (void)%s; " % (Naming.clineno_cname, Naming.line_c_macro, Naming.clineno_cname)
-        else:
-            cinfo = ""
-        code.putln("#define __PYX_MARK_ERR_POS(f_index, lineno) \\")
-        code.putln("    { %s = %s[f_index]; (void)%s; %s = lineno; (void)%s; %s}" % (
-            Naming.filename_cname, Naming.filetable_cname, Naming.filename_cname,
-            Naming.lineno_cname, Naming.lineno_cname,
-            cinfo
-        ))
-        code.putln("#define __PYX_ERR(f_index, lineno, Ln_error) \\")
-        code.putln("    { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }")
-
-        code.putln("")
-        self.generate_extern_c_macro_definition(code)
-        code.putln("")
-
-        code.putln("#define %s" % Naming.h_guard_prefix + self.api_name(env))
-        code.putln("#define %s" % Naming.api_guard_prefix + self.api_name(env))
-        code.putln("/* Early includes */")
-        self.generate_includes(env, cimported_modules, code, late=False)
-        code.putln("")
-        code.putln("#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)")
-        code.putln("#define CYTHON_WITHOUT_ASSERTIONS")
-        code.putln("#endif")
-        code.putln("")
-
-        if env.directives['ccomplex']:
-            code.putln("")
-            code.putln("#if !defined(CYTHON_CCOMPLEX)")
-            code.putln("#define CYTHON_CCOMPLEX 1")
-            code.putln("#endif")
-            code.putln("")
-        code.put(UtilityCode.load_as_string("UtilityFunctionPredeclarations", "ModuleSetupCode.c")[0])
-
-        c_string_type = env.directives['c_string_type']
-        c_string_encoding = env.directives['c_string_encoding']
-        if c_string_type not in ('bytes', 'bytearray') and not c_string_encoding:
-            error(self.pos, "a default encoding must be provided if c_string_type is not a byte type")
-        code.putln('#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII %s' % int(c_string_encoding == 'ascii'))
-        code.putln('#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 %s' %
-                int(c_string_encoding.replace('-', '').lower() == 'utf8'))
-        if c_string_encoding == 'default':
-            code.putln('#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 1')
-        else:
-            code.putln('#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT '
-                    '(PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)')
-            code.putln('#define __PYX_DEFAULT_STRING_ENCODING "%s"' % c_string_encoding)
-        if c_string_type == 'bytearray':
-            c_string_func_name = 'ByteArray'
-        else:
-            c_string_func_name = c_string_type.title()
-        code.putln('#define __Pyx_PyObject_FromString __Pyx_Py%s_FromString' % c_string_func_name)
-        code.putln('#define __Pyx_PyObject_FromStringAndSize __Pyx_Py%s_FromStringAndSize' % c_string_func_name)
-        code.put(UtilityCode.load_as_string("TypeConversions", "TypeConversion.c")[0])
-
-        # These utility functions are assumed to exist and used elsewhere.
-        PyrexTypes.c_long_type.create_to_py_utility_code(env)
-        PyrexTypes.c_long_type.create_from_py_utility_code(env)
-        PyrexTypes.c_int_type.create_from_py_utility_code(env)
-
-        code.put(Nodes.branch_prediction_macros)
-        code.putln('static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }')
-        code.putln('')
-        code.putln('static PyObject *%s = NULL;' % env.module_cname)
-        code.putln('static PyObject *%s;' % env.module_dict_cname)
-        code.putln('static PyObject *%s;' % Naming.builtins_cname)
-        code.putln('static PyObject *%s = NULL;' % Naming.cython_runtime_cname)
-        code.putln('static PyObject *%s;' % Naming.empty_tuple)
-        code.putln('static PyObject *%s;' % Naming.empty_bytes)
-        code.putln('static PyObject *%s;' % Naming.empty_unicode)
-        if Options.pre_import is not None:
-            code.putln('static PyObject *%s;' % Naming.preimport_cname)
-        code.putln('static int %s;' % Naming.lineno_cname)
-        code.putln('static int %s = 0;' % Naming.clineno_cname)
-        code.putln('static const char * %s= %s;' % (Naming.cfilenm_cname, Naming.file_c_macro))
-        code.putln('static const char *%s;' % Naming.filename_cname)
-
-        env.use_utility_code(UtilityCode.load_cached("FastTypeChecks", "ModuleSetupCode.c"))
-        if has_np_pythran(env):
-            env.use_utility_code(UtilityCode.load_cached("PythranConversion", "CppSupport.cpp"))
-
-    def generate_extern_c_macro_definition(self, code):
-        name = Naming.extern_c_macro
-        code.putln("#ifndef %s" % name)
-        code.putln("  #ifdef __cplusplus")
-        code.putln('    #define %s extern "C"' % name)
-        code.putln("  #else")
-        code.putln("    #define %s extern" % name)
-        code.putln("  #endif")
-        code.putln("#endif")
-
-    def generate_dl_import_macro(self, code):
-        code.putln("#ifndef DL_IMPORT")
-        code.putln("  #define DL_IMPORT(_T) _T")
-        code.putln("#endif")
-
-    def generate_includes(self, env, cimported_modules, code, early=True, late=True):
-        includes = []
-        for inc in sorted(env.c_includes.values(), key=IncludeCode.sortkey):
-            if inc.location == inc.EARLY:
-                if early:
-                    inc.write(code)
-            elif inc.location == inc.LATE:
-                if late:
-                    inc.write(code)
-        if early:
-            code.putln_openmp("#include <omp.h>")
-
-    def generate_filename_table(self, code):
-        from os.path import isabs, basename
-        code.putln("")
-        code.putln("static const char *%s[] = {" % Naming.filetable_cname)
-        if code.globalstate.filename_list:
-            for source_desc in code.globalstate.filename_list:
-                file_path = source_desc.get_filenametable_entry()
-                if Options.source_root:
-                    # If source root specified, dump description - it's source root relative filename
-                    file_path = source_desc.get_description()
-                if isabs(file_path):
-                    file_path = basename(file_path)  # never include absolute paths
-                escaped_filename = file_path.replace("\\", "\\\\").replace('"', r'\"')
-                code.putln('"%s",' % escaped_filename)
-        else:
-            # Some C compilers don't like an empty array
-            code.putln("0")
-        code.putln("};")
-
-    def generate_type_predeclarations(self, env, code):
-        pass
-
-    def generate_type_header_code(self, type_entries, code):
-        # Generate definitions of structs/unions/enums/typedefs/objstructs.
-        #self.generate_gcc33_hack(env, code) # Is this still needed?
-        # Forward declarations
-        for entry in type_entries:
-            if not entry.in_cinclude:
-                #print "generate_type_header_code:", entry.name, repr(entry.type) ###
-                type = entry.type
-                if type.is_typedef: # Must test this first!
-                    pass
-                elif type.is_struct_or_union or type.is_cpp_class:
-                    self.generate_struct_union_predeclaration(entry, code)
-                elif type.is_ctuple and entry.used:
-                    self.generate_struct_union_predeclaration(entry.type.struct_entry, code)
-                elif type.is_extension_type:
-                    self.generate_objstruct_predeclaration(type, code)
-        # Actual declarations
-        for entry in type_entries:
-            if not entry.in_cinclude:
-                #print "generate_type_header_code:", entry.name, repr(entry.type) ###
-                type = entry.type
-                if type.is_typedef: # Must test this first!
-                    self.generate_typedef(entry, code)
-                elif type.is_enum:
-                    self.generate_enum_definition(entry, code)
-                elif type.is_struct_or_union:
-                    self.generate_struct_union_definition(entry, code)
-                elif type.is_ctuple and entry.used:
-                    self.generate_struct_union_definition(entry.type.struct_entry, code)
-                elif type.is_cpp_class:
-                    self.generate_cpp_class_definition(entry, code)
-                elif type.is_extension_type:
-                    self.generate_objstruct_definition(type, code)
-
-    def generate_gcc33_hack(self, env, code):
-        # Workaround for spurious warning generation in gcc 3.3
-        code.putln("")
-        for entry in env.c_class_entries:
-            type = entry.type
-            if not type.typedef_flag:
-                name = type.objstruct_cname
-                if name.startswith("__pyx_"):
-                    tail = name[6:]
-                else:
-                    tail = name
-                code.putln("typedef struct %s __pyx_gcc33_%s;" % (
-                    name, tail))
-
-    def generate_typedef(self, entry, code):
-        base_type = entry.type.typedef_base_type
-        if base_type.is_numeric:
-            try:
-                writer = code.globalstate['numeric_typedefs']
-            except KeyError:
-                writer = code
-        else:
-            writer = code
-        writer.mark_pos(entry.pos)
-        writer.putln("typedef %s;" % base_type.declaration_code(entry.cname))
-
-    def sue_predeclaration(self, type, kind, name):
-        if type.typedef_flag:
-            return "%s %s;\ntypedef %s %s %s;" % (
-                kind, name,
-                kind, name, name)
-        else:
-            return "%s %s;" % (kind, name)
-
-    def generate_struct_union_predeclaration(self, entry, code):
-        type = entry.type
-        if type.is_cpp_class and type.templates:
-            code.putln("template <typename %s>" % ", typename ".join(
-                [T.empty_declaration_code() for T in type.templates]))
-        code.putln(self.sue_predeclaration(type, type.kind, type.cname))
-
-    def sue_header_footer(self, type, kind, name):
-        header = "%s %s {" % (kind, name)
-        footer = "};"
-        return header, footer
-
-    def generate_struct_union_definition(self, entry, code):
-        code.mark_pos(entry.pos)
-        type = entry.type
-        scope = type.scope
-        if scope:
-            kind = type.kind
-            packed = type.is_struct and type.packed
-            if packed:
-                kind = "%s %s" % (type.kind, "__Pyx_PACKED")
-                code.globalstate.use_utility_code(packed_struct_utility_code)
-            header, footer = \
-                self.sue_header_footer(type, kind, type.cname)
-            if packed:
-                code.putln("#if defined(__SUNPRO_C)")
-                code.putln("  #pragma pack(1)")
-                code.putln("#elif !defined(__GNUC__)")
-                code.putln("  #pragma pack(push, 1)")
-                code.putln("#endif")
-            code.putln(header)
-            var_entries = scope.var_entries
-            if not var_entries:
-                error(entry.pos, "Empty struct or union definition not allowed outside a 'cdef extern from' block")
-            for attr in var_entries:
-                code.putln(
-                    "%s;" % attr.type.declaration_code(attr.cname))
-            code.putln(footer)
-            if packed:
-                code.putln("#if defined(__SUNPRO_C)")
-                code.putln("  #pragma pack()")
-                code.putln("#elif !defined(__GNUC__)")
-                code.putln("  #pragma pack(pop)")
-                code.putln("#endif")
-
-    def generate_cpp_class_definition(self, entry, code):
-        code.mark_pos(entry.pos)
-        type = entry.type
-        scope = type.scope
-        if scope:
-            if type.templates:
-                code.putln("template <class %s>" % ", class ".join(
-                    [T.empty_declaration_code() for T in type.templates]))
-            # Just let everything be public.
-            code.put("struct %s" % type.cname)
-            if type.base_classes:
-                base_class_decl = ", public ".join(
-                    [base_class.empty_declaration_code() for base_class in type.base_classes])
-                code.put(" : public %s" % base_class_decl)
-            code.putln(" {")
-            py_attrs = [e for e in scope.entries.values()
-                        if e.type.is_pyobject and not e.is_inherited]
-            has_virtual_methods = False
-            constructor = None
-            destructor = None
-            for attr in scope.var_entries:
-                if attr.type.is_cfunction:
-                    code.put("inline ")
-                if attr.type.is_cfunction and attr.type.is_static_method:
-                    code.put("static ")
-                elif attr.name == "<init>":
-                    constructor = attr
-                elif attr.name == "<del>":
-                    destructor = attr
-                elif attr.type.is_cfunction:
-                    code.put("virtual ")
-                    has_virtual_methods = True
-                code.putln("%s;" % attr.type.declaration_code(attr.cname))
-            is_implementing = 'init_module' in code.globalstate.parts
-            if constructor or py_attrs:
-                if constructor:
-                    arg_decls = []
-                    arg_names = []
-                    for arg in constructor.type.original_args[
-                            :len(constructor.type.args)-constructor.type.optional_arg_count]:
-                        arg_decls.append(arg.declaration_code())
-                        arg_names.append(arg.cname)
-                    if constructor.type.optional_arg_count:
-                        arg_decls.append(constructor.type.op_arg_struct.declaration_code(Naming.optional_args_cname))
-                        arg_names.append(Naming.optional_args_cname)
-                    if not arg_decls:
-                        arg_decls = ["void"]
-                else:
-                    arg_decls = ["void"]
-                    arg_names = []
-                if is_implementing:
-                  code.putln("%s(%s) {" % (type.cname, ", ".join(arg_decls)))
-                  if py_attrs:
-                      code.put_ensure_gil()
-                      for attr in py_attrs:
-                          code.put_init_var_to_py_none(attr, nanny=False);
-                  if constructor:
-                      code.putln("%s(%s);" % (constructor.cname, ", ".join(arg_names)))
-                  if py_attrs:
-                      code.put_release_ensured_gil()
-                  code.putln("}")
-                else:
-                  code.putln("%s(%s);" % (type.cname, ", ".join(arg_decls)))
-            if destructor or py_attrs or has_virtual_methods:
-                if has_virtual_methods:
-                    code.put("virtual ")
-                if is_implementing:
-                  code.putln("~%s() {" % type.cname)
-                  if py_attrs:
-                      code.put_ensure_gil()
-                  if destructor:
-                      code.putln("%s();" % destructor.cname)
-                  if py_attrs:
-                      for attr in py_attrs:
-                          code.put_var_xdecref(attr, nanny=False);
-                      code.put_release_ensured_gil()
-                  code.putln("}")
-                else:
-                  code.putln("~%s();" % type.cname)
-            if py_attrs:
-                # Also need copy constructor and assignment operators.
-                if is_implementing:
-                  code.putln("%s(const %s& __Pyx_other) {" % (type.cname, type.cname))
-                  code.put_ensure_gil()
-                  for attr in scope.var_entries:
-                      if not attr.type.is_cfunction:
-                          code.putln("%s = __Pyx_other.%s;" % (attr.cname, attr.cname))
-                          code.put_var_incref(attr, nanny=False)
-                  code.put_release_ensured_gil()
-                  code.putln("}")
-                  code.putln("%s& operator=(const %s& __Pyx_other) {" % (type.cname, type.cname))
-                  code.putln("if (this != &__Pyx_other) {")
-                  code.put_ensure_gil()
-                  for attr in scope.var_entries:
-                      if not attr.type.is_cfunction:
-                          code.put_var_xdecref(attr, nanny=False);
-                          code.putln("%s = __Pyx_other.%s;" % (attr.cname, attr.cname))
-                          code.put_var_incref(attr, nanny=False)
-                  code.put_release_ensured_gil()
-                  code.putln("}")
-                  code.putln("return *this;")
-                  code.putln("}")
-                else:
-                  code.putln("%s(const %s& __Pyx_other);" % (type.cname, type.cname))
-                  code.putln("%s& operator=(const %s& __Pyx_other);" % (type.cname, type.cname))
-            code.putln("};")
-
-    def generate_enum_definition(self, entry, code):
-        code.mark_pos(entry.pos)
-        type = entry.type
-        name = entry.cname or entry.name or ""
-        header, footer = self.sue_header_footer(type, "enum", name)
-        code.putln(header)
-        enum_values = entry.enum_values
-        if not enum_values:
-            error(entry.pos, "Empty enum definition not allowed outside a 'cdef extern from' block")
-        else:
-            last_entry = enum_values[-1]
-            # this does not really generate code, just builds the result value
-            for value_entry in enum_values:
-                if value_entry.value_node is not None:
-                    value_entry.value_node.generate_evaluation_code(code)
-
-            for value_entry in enum_values:
-                if value_entry.value_node is None:
-                    value_code = value_entry.cname
-                else:
-                    value_code = ("%s = %s" % (
-                        value_entry.cname,
-                        value_entry.value_node.result()))
-                if value_entry is not last_entry:
-                    value_code += ","
-                code.putln(value_code)
-        code.putln(footer)
-        if entry.type.typedef_flag:
-            # Not pre-declared.
-            code.putln("typedef enum %s %s;" % (name, name))
-
-    def generate_typeobj_predeclaration(self, entry, code):
-        code.putln("")
-        name = entry.type.typeobj_cname
-        if name:
-            if entry.visibility == 'extern' and not entry.in_cinclude:
-                code.putln("%s %s %s;" % (
-                    Naming.extern_c_macro,
-                    PyrexTypes.public_decl("PyTypeObject", "DL_IMPORT"),
-                    name))
-            elif entry.visibility == 'public':
-                code.putln("%s %s %s;" % (
-                    Naming.extern_c_macro,
-                    PyrexTypes.public_decl("PyTypeObject", "DL_EXPORT"),
-                    name))
-            # ??? Do we really need the rest of this? ???
-            #else:
-            #    code.putln("static PyTypeObject %s;" % name)
-
-    def generate_exttype_vtable_struct(self, entry, code):
-        if not entry.used:
-            return
-
-        code.mark_pos(entry.pos)
-        # Generate struct declaration for an extension type's vtable.
-        type = entry.type
-        scope = type.scope
-
-        self.specialize_fused_types(scope)
-
-        if type.vtabstruct_cname:
-            code.putln("")
-            code.putln("struct %s {" % type.vtabstruct_cname)
-            if type.base_type and type.base_type.vtabstruct_cname:
-                code.putln("struct %s %s;" % (
-                    type.base_type.vtabstruct_cname,
-                    Naming.obj_base_cname))
-            for method_entry in scope.cfunc_entries:
-                if not method_entry.is_inherited:
-                    code.putln("%s;" % method_entry.type.declaration_code("(*%s)" % method_entry.cname))
-            code.putln("};")
-
-    def generate_exttype_vtabptr_declaration(self, entry, code):
-        if not entry.used:
-            return
-
-        code.mark_pos(entry.pos)
-        # Generate declaration of pointer to an extension type's vtable.
-        type = entry.type
-        if type.vtabptr_cname:
-            code.putln("static struct %s *%s;" % (
-                type.vtabstruct_cname,
-                type.vtabptr_cname))
-
-    def generate_exttype_final_methods_declaration(self, entry, code):
-        if not entry.used:
-            return
-
-        code.mark_pos(entry.pos)
-        # Generate final methods prototypes
-        type = entry.type
-        for method_entry in entry.type.scope.cfunc_entries:
-            if not method_entry.is_inherited and method_entry.final_func_cname:
-                declaration = method_entry.type.declaration_code(
-                    method_entry.final_func_cname)
-                modifiers = code.build_function_modifiers(method_entry.func_modifiers)
-                code.putln("static %s%s;" % (modifiers, declaration))
-
-    def generate_objstruct_predeclaration(self, type, code):
-        if not type.scope:
-            return
-        code.putln(self.sue_predeclaration(type, "struct", type.objstruct_cname))
-
-    def generate_objstruct_definition(self, type, code):
-        code.mark_pos(type.pos)
-        # Generate object struct definition for an
-        # extension type.
-        if not type.scope:
-            return # Forward declared but never defined
-        header, footer = \
-            self.sue_header_footer(type, "struct", type.objstruct_cname)
-        code.putln(header)
-        base_type = type.base_type
-        if base_type:
-            basestruct_cname = base_type.objstruct_cname
-            if basestruct_cname == "PyTypeObject":
-                # User-defined subclasses of type are heap allocated.
-                basestruct_cname = "PyHeapTypeObject"
-            code.putln(
-                "%s%s %s;" % (
-                    ("struct ", "")[base_type.typedef_flag],
-                    basestruct_cname,
-                    Naming.obj_base_cname))
-        else:
-            code.putln(
-                "PyObject_HEAD")
-        if type.vtabslot_cname and not (type.base_type and type.base_type.vtabslot_cname):
-            code.putln(
-                "struct %s *%s;" % (
-                    type.vtabstruct_cname,
-                    type.vtabslot_cname))
-        for attr in type.scope.var_entries:
-            if attr.is_declared_generic:
-                attr_type = py_object_type
-            else:
-                attr_type = attr.type
-            code.putln(
-                "%s;" % attr_type.declaration_code(attr.cname))
-        code.putln(footer)
-        if type.objtypedef_cname is not None:
-            # Only for exposing public typedef name.
-            code.putln("typedef struct %s %s;" % (type.objstruct_cname, type.objtypedef_cname))
-
-    def generate_c_class_declarations(self, env, code, definition):
-        for entry in env.c_class_entries:
-            if definition or entry.defined_in_pxd:
-                code.putln("static PyTypeObject *%s = 0;" % (
-                    entry.type.typeptr_cname))
-
-    def generate_cvariable_declarations(self, env, code, definition):
-        if env.is_cython_builtin:
-            return
-        for entry in env.var_entries:
-            if (entry.in_cinclude or entry.in_closure or
-                    (entry.visibility == 'private' and not (entry.defined_in_pxd or entry.used))):
-                continue
-
-            storage_class = None
-            dll_linkage = None
-            init = None
-
-            if entry.visibility == 'extern':
-                storage_class = Naming.extern_c_macro
-                dll_linkage = "DL_IMPORT"
-            elif entry.visibility == 'public':
-                storage_class = Naming.extern_c_macro
-                if definition:
-                    dll_linkage = "DL_EXPORT"
-                else:
-                    dll_linkage = "DL_IMPORT"
-            elif entry.visibility == 'private':
-                storage_class = "static"
-                dll_linkage = None
-                if entry.init is not None:
-                    init = entry.type.literal_code(entry.init)
-            type = entry.type
-            cname = entry.cname
-
-            if entry.defined_in_pxd and not definition:
-                storage_class = "static"
-                dll_linkage = None
-                type = CPtrType(type)
-                cname = env.mangle(Naming.varptr_prefix, entry.name)
-                init = 0
-
-            if storage_class:
-                code.put("%s " % storage_class)
-            code.put(type.declaration_code(
-                cname, dll_linkage=dll_linkage))
-            if init is not None:
-                code.put_safe(" = %s" % init)
-            code.putln(";")
-            if entry.cname != cname:
-                code.putln("#define %s (*%s)" % (entry.cname, cname))
-
-    def generate_cfunction_declarations(self, env, code, definition):
-        for entry in env.cfunc_entries:
-            if entry.used or (entry.visibility == 'public' or entry.api):
-                generate_cfunction_declaration(entry, env, code, definition)
-
-    def generate_variable_definitions(self, env, code):
-        for entry in env.var_entries:
-            if not entry.in_cinclude and entry.visibility == "public":
-                code.put(entry.type.declaration_code(entry.cname))
-                if entry.init is not None:
-                    init = entry.type.literal_code(entry.init)
-                    code.put_safe(" = %s" % init)
-                code.putln(";")
-
-    def generate_typeobj_definitions(self, env, code):
-        full_module_name = env.qualified_name
-        for entry in env.c_class_entries:
-            #print "generate_typeobj_definitions:", entry.name
-            #print "...visibility =", entry.visibility
-            if entry.visibility != 'extern':
-                type = entry.type
-                scope = type.scope
-                if scope: # could be None if there was an error
-                    if not scope.directives['c_api_binop_methods']:
-                        error(self.pos,
-                              "The 'c_api_binop_methods' directive is only supported for forward compatibility"
-                              " and must be True.")
-                    self.generate_exttype_vtable(scope, code)
-                    self.generate_new_function(scope, code, entry)
-                    self.generate_dealloc_function(scope, code)
-                    if scope.needs_gc():
-                        self.generate_traverse_function(scope, code, entry)
-                        if scope.needs_tp_clear():
-                            self.generate_clear_function(scope, code, entry)
-                    if scope.defines_any_special(["__getitem__"]):
-                        self.generate_getitem_int_function(scope, code)
-                    if scope.defines_any_special(["__setitem__", "__delitem__"]):
-                        self.generate_ass_subscript_function(scope, code)
-                    if scope.defines_any_special(["__getslice__", "__setslice__", "__delslice__"]):
-                        warning(self.pos,
-                                "__getslice__, __setslice__, and __delslice__ are not supported by Python 3, "
-                                "use __getitem__, __setitem__, and __delitem__ instead", 1)
-                        code.putln("#if PY_MAJOR_VERSION >= 3")
-                        code.putln("#error __getslice__, __setslice__, and __delslice__ not supported in Python 3.")
-                        code.putln("#endif")
-                    if scope.defines_any_special(["__setslice__", "__delslice__"]):
-                        self.generate_ass_slice_function(scope, code)
-                    if scope.defines_any_special(["__getattr__", "__getattribute__"]):
-                        self.generate_getattro_function(scope, code)
-                    if scope.defines_any_special(["__setattr__", "__delattr__"]):
-                        self.generate_setattro_function(scope, code)
-                    if scope.defines_any_special(["__get__"]):
-                        self.generate_descr_get_function(scope, code)
-                    if scope.defines_any_special(["__set__", "__delete__"]):
-                        self.generate_descr_set_function(scope, code)
-                    if not scope.is_closure_class_scope and scope.defines_any(["__dict__"]):
-                        self.generate_dict_getter_function(scope, code)
-                    if scope.defines_any_special(TypeSlots.richcmp_special_methods):
-                        self.generate_richcmp_function(scope, code)
-                    self.generate_property_accessors(scope, code)
-                    self.generate_method_table(scope, code)
-                    self.generate_getset_table(scope, code)
-                    self.generate_typeobj_definition(full_module_name, entry, code)
-
-    def generate_exttype_vtable(self, scope, code):
-        # Generate the definition of an extension type's vtable.
-        type = scope.parent_type
-        if type.vtable_cname:
-            code.putln("static struct %s %s;" % (
-                type.vtabstruct_cname,
-                type.vtable_cname))
-
-    def generate_self_cast(self, scope, code):
-        type = scope.parent_type
-        code.putln(
-            "%s = (%s)o;" % (
-                type.declaration_code("p"),
-                type.empty_declaration_code()))
-
-    def generate_new_function(self, scope, code, cclass_entry):
-        tp_slot = TypeSlots.ConstructorSlot("tp_new", '__new__')
-        slot_func = scope.mangle_internal("tp_new")
-        type = scope.parent_type
-        base_type = type.base_type
-
-        have_entries, (py_attrs, py_buffers, memoryview_slices) = \
-                        scope.get_refcounted_entries()
-        is_final_type = scope.parent_type.is_final_type
-        if scope.is_internal:
-            # internal classes (should) never need None inits, normal zeroing will do
-            py_attrs = []
-        cpp_class_attrs = [entry for entry in scope.var_entries
-                           if entry.type.is_cpp_class]
-
-        new_func_entry = scope.lookup_here("__new__")
-        if base_type or (new_func_entry and new_func_entry.is_special
-                         and not new_func_entry.trivial_signature):
-            unused_marker = ''
-        else:
-            unused_marker = 'CYTHON_UNUSED '
-
-        if base_type:
-            freelist_size = 0  # not currently supported
-        else:
-            freelist_size = scope.directives.get('freelist', 0)
-        freelist_name = scope.mangle_internal(Naming.freelist_name)
-        freecount_name = scope.mangle_internal(Naming.freecount_name)
-
-        decls = code.globalstate['decls']
-        decls.putln("static PyObject *%s(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/" %
-                    slot_func)
-        code.putln("")
-        if freelist_size:
-            code.putln("static %s[%d];" % (
-                scope.parent_type.declaration_code(freelist_name),
-                freelist_size))
-            code.putln("static int %s = 0;" % freecount_name)
-            code.putln("")
-        code.putln(
-            "static PyObject *%s(PyTypeObject *t, %sPyObject *a, %sPyObject *k) {" % (
-                slot_func, unused_marker, unused_marker))
-
-        need_self_cast = (type.vtabslot_cname or
-                          (py_buffers or memoryview_slices or py_attrs) or
-                          cpp_class_attrs)
-        if need_self_cast:
-            code.putln("%s;" % scope.parent_type.declaration_code("p"))
-        if base_type:
-            tp_new = TypeSlots.get_base_slot_function(scope, tp_slot)
-            if tp_new is None:
-                tp_new = "%s->tp_new" % base_type.typeptr_cname
-            code.putln("PyObject *o = %s(t, a, k);" % tp_new)
-        else:
-            code.putln("PyObject *o;")
-            if freelist_size:
-                code.globalstate.use_utility_code(
-                    UtilityCode.load_cached("IncludeStringH", "StringTools.c"))
-                if is_final_type:
-                    type_safety_check = ''
-                else:
-                    type_safety_check = ' & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0)'
-                obj_struct = type.declaration_code("", deref=True)
-                code.putln(
-                    "if (CYTHON_COMPILING_IN_CPYTHON && likely((%s > 0) & (t->tp_basicsize == sizeof(%s))%s)) {" % (
-                        freecount_name, obj_struct, type_safety_check))
-                code.putln("o = (PyObject*)%s[--%s];" % (
-                    freelist_name, freecount_name))
-                code.putln("memset(o, 0, sizeof(%s));" % obj_struct)
-                code.putln("(void) PyObject_INIT(o, t);")
-                if scope.needs_gc():
-                    code.putln("PyObject_GC_Track(o);")
-                code.putln("} else {")
-            if not is_final_type:
-                code.putln("if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {")
-            code.putln("o = (*t->tp_alloc)(t, 0);")
-            if not is_final_type:
-                code.putln("} else {")
-                code.putln("o = (PyObject *) PyBaseObject_Type.tp_new(t, %s, 0);" % Naming.empty_tuple)
-                code.putln("}")
-        code.putln("if (unlikely(!o)) return 0;")
-        if freelist_size and not base_type:
-            code.putln('}')
-        if need_self_cast:
-            code.putln("p = %s;" % type.cast_code("o"))
-        #if need_self_cast:
-        #    self.generate_self_cast(scope, code)
-
-        # from this point on, ensure DECREF(o) on failure
-        needs_error_cleanup = False
-
-        if type.vtabslot_cname:
-            vtab_base_type = type
-            while vtab_base_type.base_type and vtab_base_type.base_type.vtabstruct_cname:
-                vtab_base_type = vtab_base_type.base_type
-            if vtab_base_type is not type:
-                struct_type_cast = "(struct %s*)" % vtab_base_type.vtabstruct_cname
-            else:
-                struct_type_cast = ""
-            code.putln("p->%s = %s%s;" % (
-                type.vtabslot_cname,
-                struct_type_cast, type.vtabptr_cname))
-
-        for entry in cpp_class_attrs:
-            code.putln("new((void*)&(p->%s)) %s();" % (
-                entry.cname, entry.type.empty_declaration_code()))
-
-        for entry in py_attrs:
-            if entry.name == "__dict__":
-                needs_error_cleanup = True
-                code.put("p->%s = PyDict_New(); if (unlikely(!p->%s)) goto bad;" % (
-                    entry.cname, entry.cname))
-            else:
-                code.put_init_var_to_py_none(entry, "p->%s", nanny=False)
-
-        for entry in memoryview_slices:
-            code.putln("p->%s.data = NULL;" % entry.cname)
-            code.putln("p->%s.memview = NULL;" % entry.cname)
-
-        for entry in py_buffers:
-            code.putln("p->%s.obj = NULL;" % entry.cname)
-
-        if cclass_entry.cname == '__pyx_memoryviewslice':
-            code.putln("p->from_slice.memview = NULL;")
-
-        if new_func_entry and new_func_entry.is_special:
-            if new_func_entry.trivial_signature:
-                cinit_args = "o, %s, NULL" % Naming.empty_tuple
-            else:
-                cinit_args = "o, a, k"
-            needs_error_cleanup = True
-            code.putln("if (unlikely(%s(%s) < 0)) goto bad;" % (
-                new_func_entry.func_cname, cinit_args))
-
-        code.putln(
-            "return o;")
-        if needs_error_cleanup:
-            code.putln("bad:")
-            code.put_decref_clear("o", py_object_type, nanny=False)
-            code.putln("return NULL;")
-        code.putln(
-            "}")
-
-    def generate_dealloc_function(self, scope, code):
-        tp_slot = TypeSlots.ConstructorSlot("tp_dealloc", '__dealloc__')
-        slot_func = scope.mangle_internal("tp_dealloc")
-        base_type = scope.parent_type.base_type
-        if tp_slot.slot_code(scope) != slot_func:
-            return  # never used
-
-        slot_func_cname = scope.mangle_internal("tp_dealloc")
-        code.putln("")
-        code.putln(
-            "static void %s(PyObject *o) {" % slot_func_cname)
-
-        is_final_type = scope.parent_type.is_final_type
-        needs_gc = scope.needs_gc()
-
-        weakref_slot = scope.lookup_here("__weakref__") if not scope.is_closure_class_scope else None
-        if weakref_slot not in scope.var_entries:
-            weakref_slot = None
-
-        dict_slot = scope.lookup_here("__dict__") if not scope.is_closure_class_scope else None
-        if dict_slot not in scope.var_entries:
-            dict_slot = None
-
-        _, (py_attrs, _, memoryview_slices) = scope.get_refcounted_entries()
-        cpp_class_attrs = [entry for entry in scope.var_entries
-                           if entry.type.is_cpp_class]
-
-        if py_attrs or cpp_class_attrs or memoryview_slices or weakref_slot or dict_slot:
-            self.generate_self_cast(scope, code)
-
-        if not is_final_type:
-            # in Py3.4+, call tp_finalize() as early as possible
-            code.putln("#if CYTHON_USE_TP_FINALIZE")
-            if needs_gc:
-                finalised_check = '!_PyGC_FINALIZED(o)'
-            else:
-                finalised_check = (
-                    '(!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))')
-            code.putln(
-                "if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)"
-                " && Py_TYPE(o)->tp_finalize) && %s) {" % finalised_check)
-            # if instance was resurrected by finaliser, return
-            code.putln("if (PyObject_CallFinalizerFromDealloc(o)) return;")
-            code.putln("}")
-            code.putln("#endif")
-
-        if needs_gc:
-            # We must mark this object as (gc) untracked while tearing
-            # it down, lest the garbage collection is invoked while
-            # running this destructor.
-            code.putln("PyObject_GC_UnTrack(o);")
-
-        # call the user's __dealloc__
-        self.generate_usr_dealloc_call(scope, code)
-
-        if weakref_slot:
-            code.putln("if (p->__weakref__) PyObject_ClearWeakRefs(o);")
-
-        if dict_slot:
-            code.putln("if (p->__dict__) PyDict_Clear(p->__dict__);")
-
-        for entry in cpp_class_attrs:
-            code.putln("__Pyx_call_destructor(p->%s);" % entry.cname)
-
-        for entry in py_attrs:
-            code.put_xdecref_clear("p->%s" % entry.cname, entry.type, nanny=False,
-                                   clear_before_decref=True)
-
-        for entry in memoryview_slices:
-            code.put_xdecref_memoryviewslice("p->%s" % entry.cname,
-                                             have_gil=True)
-
-        if base_type:
-            if needs_gc:
-                # The base class deallocator probably expects this to be tracked,
-                # so undo the untracking above.
-                if base_type.scope and base_type.scope.needs_gc():
-                    code.putln("PyObject_GC_Track(o);")
-                else:
-                    code.putln("#if CYTHON_USE_TYPE_SLOTS")
-                    code.putln("if (PyType_IS_GC(Py_TYPE(o)->tp_base))")
-                    code.putln("#endif")
-                    code.putln("PyObject_GC_Track(o);")
-
-            tp_dealloc = TypeSlots.get_base_slot_function(scope, tp_slot)
-            if tp_dealloc is not None:
-                code.putln("%s(o);" % tp_dealloc)
-            elif base_type.is_builtin_type:
-                code.putln("%s->tp_dealloc(o);" % base_type.typeptr_cname)
-            else:
-                # This is an externally defined type.  Calling through the
-                # cimported base type pointer directly interacts badly with
-                # the module cleanup, which may already have cleared it.
-                # In that case, fall back to traversing the type hierarchy.
-                base_cname = base_type.typeptr_cname
-                code.putln("if (likely(%s)) %s->tp_dealloc(o); "
-                           "else __Pyx_call_next_tp_dealloc(o, %s);" % (
-                               base_cname, base_cname, slot_func_cname))
-                code.globalstate.use_utility_code(
-                    UtilityCode.load_cached("CallNextTpDealloc", "ExtensionTypes.c"))
-        else:
-            freelist_size = scope.directives.get('freelist', 0)
-            if freelist_size:
-                freelist_name = scope.mangle_internal(Naming.freelist_name)
-                freecount_name = scope.mangle_internal(Naming.freecount_name)
-
-                if is_final_type:
-                    type_safety_check = ''
-                else:
-                    type_safety_check = (
-                        ' & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0)')
-
-                type = scope.parent_type
-                code.putln(
-                    "if (CYTHON_COMPILING_IN_CPYTHON && ((%s < %d) & (Py_TYPE(o)->tp_basicsize == sizeof(%s))%s)) {" % (
-                        freecount_name,
-                        freelist_size,
-                        type.declaration_code("", deref=True),
-                        type_safety_check))
-                code.putln("%s[%s++] = %s;" % (
-                    freelist_name, freecount_name, type.cast_code("o")))
-                code.putln("} else {")
-            code.putln("(*Py_TYPE(o)->tp_free)(o);")
-            if freelist_size:
-                code.putln("}")
-        code.putln(
-            "}")
-
-    def generate_usr_dealloc_call(self, scope, code):
-        entry = scope.lookup_here("__dealloc__")
-        if not entry:
-            return
-
-        code.putln("{")
-        code.putln("PyObject *etype, *eval, *etb;")
-        code.putln("PyErr_Fetch(&etype, &eval, &etb);")
-        # increase the refcount while we are calling into user code
-        # to prevent recursive deallocation
-        code.putln("__Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1);")
-        code.putln("%s(o);" % entry.func_cname)
-        code.putln("__Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1);")
-        code.putln("PyErr_Restore(etype, eval, etb);")
-        code.putln("}")
-
-    def generate_traverse_function(self, scope, code, cclass_entry):
-        tp_slot = TypeSlots.GCDependentSlot("tp_traverse")
-        slot_func = scope.mangle_internal("tp_traverse")
-        base_type = scope.parent_type.base_type
-        if tp_slot.slot_code(scope) != slot_func:
-            return  # never used
-        code.putln("")
-        code.putln(
-            "static int %s(PyObject *o, visitproc v, void *a) {" % slot_func)
-
-        have_entries, (py_attrs, py_buffers, memoryview_slices) = (
-            scope.get_refcounted_entries(include_gc_simple=False))
-
-        if base_type or py_attrs:
-            code.putln("int e;")
-
-        if py_attrs or py_buffers:
-            self.generate_self_cast(scope, code)
-
-        if base_type:
-            # want to call it explicitly if possible so inlining can be performed
-            static_call = TypeSlots.get_base_slot_function(scope, tp_slot)
-            if static_call:
-                code.putln("e = %s(o, v, a); if (e) return e;" % static_call)
-            elif base_type.is_builtin_type:
-                base_cname = base_type.typeptr_cname
-                code.putln("if (!%s->tp_traverse); else { e = %s->tp_traverse(o,v,a); if (e) return e; }" % (
-                    base_cname, base_cname))
-            else:
-                # This is an externally defined type.  Calling through the
-                # cimported base type pointer directly interacts badly with
-                # the module cleanup, which may already have cleared it.
-                # In that case, fall back to traversing the type hierarchy.
-                base_cname = base_type.typeptr_cname
-                code.putln(
-                    "e = ((likely(%s)) ? ((%s->tp_traverse) ? %s->tp_traverse(o, v, a) : 0) : "
-                    "__Pyx_call_next_tp_traverse(o, v, a, %s)); if (e) return e;" % (
-                        base_cname, base_cname, base_cname, slot_func))
-                code.globalstate.use_utility_code(
-                    UtilityCode.load_cached("CallNextTpTraverse", "ExtensionTypes.c"))
-
-        for entry in py_attrs:
-            var_code = "p->%s" % entry.cname
-            var_as_pyobject = PyrexTypes.typecast(py_object_type, entry.type, var_code)
-            code.putln("if (%s) {" % var_code)
-            code.putln("e = (*v)(%s, a); if (e) return e;" % var_as_pyobject)
-            code.putln("}")
-
-        # Traverse buffer exporting objects.
-        # Note: not traversing memoryview attributes of memoryview slices!
-        # When triggered by the GC, it would cause multiple visits (gc_refs
-        # subtractions which is not matched by its reference count!)
-        for entry in py_buffers:
-            cname = entry.cname + ".obj"
-            code.putln("if (p->%s) {" % cname)
-            code.putln("e = (*v)(p->%s, a); if (e) return e;" % cname)
-            code.putln("}")
-
-        code.putln("return 0;")
-        code.putln("}")
-
-    def generate_clear_function(self, scope, code, cclass_entry):
-        tp_slot = TypeSlots.get_slot_by_name("tp_clear")
-        slot_func = scope.mangle_internal("tp_clear")
-        base_type = scope.parent_type.base_type
-        if tp_slot.slot_code(scope) != slot_func:
-            return # never used
-
-        have_entries, (py_attrs, py_buffers, memoryview_slices) = (
-            scope.get_refcounted_entries(include_gc_simple=False))
-
-        if py_attrs or py_buffers or base_type:
-            unused = ''
-        else:
-            unused = 'CYTHON_UNUSED '
-
-        code.putln("")
-        code.putln("static int %s(%sPyObject *o) {" % (slot_func, unused))
-
-        if py_attrs and Options.clear_to_none:
-            code.putln("PyObject* tmp;")
-
-        if py_attrs or py_buffers:
-            self.generate_self_cast(scope, code)
-
-        if base_type:
-            # want to call it explicitly if possible so inlining can be performed
-            static_call = TypeSlots.get_base_slot_function(scope, tp_slot)
-            if static_call:
-                code.putln("%s(o);" % static_call)
-            elif base_type.is_builtin_type:
-                base_cname = base_type.typeptr_cname
-                code.putln("if (!%s->tp_clear); else %s->tp_clear(o);" % (
-                    base_cname, base_cname))
-            else:
-                # This is an externally defined type.  Calling through the
-                # cimported base type pointer directly interacts badly with
-                # the module cleanup, which may already have cleared it.
-                # In that case, fall back to traversing the type hierarchy.
-                base_cname = base_type.typeptr_cname
-                code.putln(
-                    "if (likely(%s)) { if (%s->tp_clear) %s->tp_clear(o); } else __Pyx_call_next_tp_clear(o, %s);" % (
-                        base_cname, base_cname, base_cname, slot_func))
-                code.globalstate.use_utility_code(
-                    UtilityCode.load_cached("CallNextTpClear", "ExtensionTypes.c"))
-
-        if Options.clear_to_none:
-            for entry in py_attrs:
-                name = "p->%s" % entry.cname
-                code.putln("tmp = ((PyObject*)%s);" % name)
-                if entry.is_declared_generic:
-                    code.put_init_to_py_none(name, py_object_type, nanny=False)
-                else:
-                    code.put_init_to_py_none(name, entry.type, nanny=False)
-                code.putln("Py_XDECREF(tmp);")
-        else:
-            for entry in py_attrs:
-                code.putln("Py_CLEAR(p->%s);" % entry.cname)
-
-        for entry in py_buffers:
-            # Note: shouldn't this call __Pyx_ReleaseBuffer ??
-            code.putln("Py_CLEAR(p->%s.obj);" % entry.cname)
-
-        if cclass_entry.cname == '__pyx_memoryviewslice':
-            code.putln("__PYX_XDEC_MEMVIEW(&p->from_slice, 1);")
-
-        code.putln("return 0;")
-        code.putln("}")
-
-    def generate_getitem_int_function(self, scope, code):
-        # This function is put into the sq_item slot when
-        # a __getitem__ method is present. It converts its
-        # argument to a Python integer and calls mp_subscript.
-        code.putln(
-            "static PyObject *%s(PyObject *o, Py_ssize_t i) {" % (
-                scope.mangle_internal("sq_item")))
-        code.putln(
-            "PyObject *r;")
-        code.putln(
-            "PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;")
-        code.putln(
-            "r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);")
-        code.putln(
-            "Py_DECREF(x);")
-        code.putln(
-            "return r;")
-        code.putln(
-            "}")
-
-    def generate_ass_subscript_function(self, scope, code):
-        # Setting and deleting an item are both done through
-        # the ass_subscript method, so we dispatch to user's __setitem__
-        # or __delitem__, or raise an exception.
-        base_type = scope.parent_type.base_type
-        set_entry = scope.lookup_here("__setitem__")
-        del_entry = scope.lookup_here("__delitem__")
-        code.putln("")
-        code.putln(
-            "static int %s(PyObject *o, PyObject *i, PyObject *v) {" % (
-                scope.mangle_internal("mp_ass_subscript")))
-        code.putln(
-            "if (v) {")
-        if set_entry:
-            code.putln("return %s(o, i, v);" % set_entry.func_cname)
-        else:
-            self.generate_guarded_basetype_call(
-                base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code)
-            code.putln(
-                "PyErr_Format(PyExc_NotImplementedError,")
-            code.putln(
-                '  "Subscript assignment not supported by %.200s", Py_TYPE(o)->tp_name);')
-            code.putln(
-                "return -1;")
-        code.putln(
-            "}")
-        code.putln(
-            "else {")
-        if del_entry:
-            code.putln(
-                "return %s(o, i);" % (
-                    del_entry.func_cname))
-        else:
-            self.generate_guarded_basetype_call(
-                base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code)
-            code.putln(
-                "PyErr_Format(PyExc_NotImplementedError,")
-            code.putln(
-                '  "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);')
-            code.putln(
-                "return -1;")
-        code.putln(
-            "}")
-        code.putln(
-            "}")
-
-    def generate_guarded_basetype_call(
-            self, base_type, substructure, slot, args, code):
-        if base_type:
-            base_tpname = base_type.typeptr_cname
-            if substructure:
-                code.putln(
-                    "if (%s->%s && %s->%s->%s)" % (
-                        base_tpname, substructure, base_tpname, substructure, slot))
-                code.putln(
-                    "  return %s->%s->%s(%s);" % (
-                        base_tpname, substructure, slot, args))
-            else:
-                code.putln(
-                    "if (%s->%s)" % (
-                        base_tpname, slot))
-                code.putln(
-                    "  return %s->%s(%s);" % (
-                        base_tpname, slot, args))
-
-    def generate_ass_slice_function(self, scope, code):
-        # Setting and deleting a slice are both done through
-        # the ass_slice method, so we dispatch to user's __setslice__
-        # or __delslice__, or raise an exception.
-        base_type = scope.parent_type.base_type
-        set_entry = scope.lookup_here("__setslice__")
-        del_entry = scope.lookup_here("__delslice__")
-        code.putln("")
-        code.putln(
-            "static int %s(PyObject *o, Py_ssize_t i, Py_ssize_t j, PyObject *v) {" % (
-                scope.mangle_internal("sq_ass_slice")))
-        code.putln(
-            "if (v) {")
-        if set_entry:
-            code.putln(
-                "return %s(o, i, j, v);" % (
-                    set_entry.func_cname))
-        else:
-            self.generate_guarded_basetype_call(
-                base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)
-            code.putln(
-                "PyErr_Format(PyExc_NotImplementedError,")
-            code.putln(
-                '  "2-element slice assignment not supported by %.200s", Py_TYPE(o)->tp_name);')
-            code.putln(
-                "return -1;")
-        code.putln(
-            "}")
-        code.putln(
-            "else {")
-        if del_entry:
-            code.putln(
-                "return %s(o, i, j);" % (
-                    del_entry.func_cname))
-        else:
-            self.generate_guarded_basetype_call(
-                base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)
-            code.putln(
-                "PyErr_Format(PyExc_NotImplementedError,")
-            code.putln(
-                '  "2-element slice deletion not supported by %.200s", Py_TYPE(o)->tp_name);')
-            code.putln(
-                "return -1;")
-        code.putln(
-            "}")
-        code.putln(
-            "}")
-
-    def generate_richcmp_function(self, scope, code):
-        if scope.lookup_here("__richcmp__"):
-            # user implemented, nothing to do
-            return
-        # otherwise, we have to generate it from the Python special methods
-        richcmp_cfunc = scope.mangle_internal("tp_richcompare")
-        code.putln("")
-        code.putln("static PyObject *%s(PyObject *o1, PyObject *o2, int op) {" % richcmp_cfunc)
-        code.putln("switch (op) {")
-
-        class_scopes = []
-        cls = scope.parent_type
-        while cls is not None and not cls.entry.visibility == 'extern':
-            class_scopes.append(cls.scope)
-            cls = cls.scope.parent_type.base_type
-        assert scope in class_scopes
-
-        extern_parent = None
-        if cls and cls.entry.visibility == 'extern':
-            # need to call up into base classes as we may not know all implemented comparison methods
-            extern_parent = cls if cls.typeptr_cname else scope.parent_type.base_type
-
-        eq_entry = None
-        has_ne = False
-        for cmp_method in TypeSlots.richcmp_special_methods:
-            for class_scope in class_scopes:
-                entry = class_scope.lookup_here(cmp_method)
-                if entry is not None:
-                    break
-            else:
-                continue
-
-            cmp_type = cmp_method.strip('_').upper()  # e.g. "__eq__" -> EQ
-            code.putln("case Py_%s: {" % cmp_type)
-            if cmp_method == '__eq__':
-                eq_entry = entry
-                # Python itself does not do this optimisation, it seems...
-                #code.putln("if (o1 == o2) return __Pyx_NewRef(Py_True);")
-            elif cmp_method == '__ne__':
-                has_ne = True
-                # Python itself does not do this optimisation, it seems...
-                #code.putln("if (o1 == o2) return __Pyx_NewRef(Py_False);")
-            code.putln("return %s(o1, o2);" % entry.func_cname)
-            code.putln("}")
-
-        if eq_entry and not has_ne and not extern_parent:
-            code.putln("case Py_NE: {")
-            code.putln("PyObject *ret;")
-            # Python itself does not do this optimisation, it seems...
-            #code.putln("if (o1 == o2) return __Pyx_NewRef(Py_False);")
-            code.putln("ret = %s(o1, o2);" % eq_entry.func_cname)
-            code.putln("if (likely(ret && ret != Py_NotImplemented)) {")
-            code.putln("int b = __Pyx_PyObject_IsTrue(ret); Py_DECREF(ret);")
-            code.putln("if (unlikely(b < 0)) return NULL;")
-            code.putln("ret = (b) ? Py_False : Py_True;")
-            code.putln("Py_INCREF(ret);")
-            code.putln("}")
-            code.putln("return ret;")
-            code.putln("}")
-
-        code.putln("default: {")
-        if extern_parent and extern_parent.typeptr_cname:
-            code.putln("if (likely(%s->tp_richcompare)) return %s->tp_richcompare(o1, o2, op);" % (
-                extern_parent.typeptr_cname, extern_parent.typeptr_cname))
-        code.putln("return __Pyx_NewRef(Py_NotImplemented);")
-        code.putln("}")
-
-        code.putln("}")  # switch
-        code.putln("}")
-
-    def generate_getattro_function(self, scope, code):
-        # First try to get the attribute using __getattribute__, if defined, or
-        # PyObject_GenericGetAttr.
-        #
-        # If that raises an AttributeError, call the __getattr__ if defined.
-        #
-        # In both cases, defined can be in this class, or any base class.
-        def lookup_here_or_base(n, tp=None, extern_return=None):
-            # Recursive lookup
-            if tp is None:
-                tp = scope.parent_type
-            r = tp.scope.lookup_here(n)
-            if r is None:
-                if tp.is_external and extern_return is not None:
-                    return extern_return
-                if tp.base_type is not None:
-                    return lookup_here_or_base(n, tp.base_type)
-            return r
-
-        has_instance_dict = lookup_here_or_base("__dict__", extern_return="extern")
-        getattr_entry = lookup_here_or_base("__getattr__")
-        getattribute_entry = lookup_here_or_base("__getattribute__")
-        code.putln("")
-        code.putln(
-            "static PyObject *%s(PyObject *o, PyObject *n) {" % (
-                scope.mangle_internal("tp_getattro")))
-        if getattribute_entry is not None:
-            code.putln(
-                "PyObject *v = %s(o, n);" % (
-                    getattribute_entry.func_cname))
-        else:
-            if not has_instance_dict and scope.parent_type.is_final_type:
-                # Final with no dict => use faster type attribute lookup.
-                code.globalstate.use_utility_code(
-                    UtilityCode.load_cached("PyObject_GenericGetAttrNoDict", "ObjectHandling.c"))
-                generic_getattr_cfunc = "__Pyx_PyObject_GenericGetAttrNoDict"
-            elif not has_instance_dict or has_instance_dict == "extern":
-                # No dict in the known ancestors, but don't know about extern ancestors or subtypes.
-                code.globalstate.use_utility_code(
-                    UtilityCode.load_cached("PyObject_GenericGetAttr", "ObjectHandling.c"))
-                generic_getattr_cfunc = "__Pyx_PyObject_GenericGetAttr"
-            else:
-                generic_getattr_cfunc = "PyObject_GenericGetAttr"
-            code.putln(
-                "PyObject *v = %s(o, n);" % generic_getattr_cfunc)
-        if getattr_entry is not None:
-            code.putln(
-                "if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) {")
-            code.putln(
-                "PyErr_Clear();")
-            code.putln(
-                "v = %s(o, n);" % (
-                    getattr_entry.func_cname))
-            code.putln(
-                "}")
-        code.putln(
-            "return v;")
-        code.putln(
-            "}")
-
-    def generate_setattro_function(self, scope, code):
-        # Setting and deleting an attribute are both done through
-        # the setattro method, so we dispatch to user's __setattr__
-        # or __delattr__ or fall back on PyObject_GenericSetAttr.
-        base_type = scope.parent_type.base_type
-        set_entry = scope.lookup_here("__setattr__")
-        del_entry = scope.lookup_here("__delattr__")
-        code.putln("")
-        code.putln(
-            "static int %s(PyObject *o, PyObject *n, PyObject *v) {" % (
-                scope.mangle_internal("tp_setattro")))
-        code.putln(
-            "if (v) {")
-        if set_entry:
-            code.putln(
-                "return %s(o, n, v);" % (
-                    set_entry.func_cname))
-        else:
-            self.generate_guarded_basetype_call(
-                base_type, None, "tp_setattro", "o, n, v", code)
-            code.putln(
-                "return PyObject_GenericSetAttr(o, n, v);")
-        code.putln(
-            "}")
-        code.putln(
-            "else {")
-        if del_entry:
-            code.putln(
-                "return %s(o, n);" % (
-                    del_entry.func_cname))
-        else:
-            self.generate_guarded_basetype_call(
-                base_type, None, "tp_setattro", "o, n, v", code)
-            code.putln(
-                "return PyObject_GenericSetAttr(o, n, 0);")
-        code.putln(
-            "}")
-        code.putln(
-            "}")
-
-    def generate_descr_get_function(self, scope, code):
-        # The __get__ function of a descriptor object can be
-        # called with NULL for the second or third arguments
-        # under some circumstances, so we replace them with
-        # None in that case.
-        user_get_entry = scope.lookup_here("__get__")
-        code.putln("")
-        code.putln(
-            "static PyObject *%s(PyObject *o, PyObject *i, PyObject *c) {" % (
-                scope.mangle_internal("tp_descr_get")))
-        code.putln(
-            "PyObject *r = 0;")
-        code.putln(
-            "if (!i) i = Py_None;")
-        code.putln(
-            "if (!c) c = Py_None;")
-        #code.put_incref("i", py_object_type)
-        #code.put_incref("c", py_object_type)
-        code.putln(
-            "r = %s(o, i, c);" % (
-                user_get_entry.func_cname))
-        #code.put_decref("i", py_object_type)
-        #code.put_decref("c", py_object_type)
-        code.putln(
-            "return r;")
-        code.putln(
-            "}")
-
-    def generate_descr_set_function(self, scope, code):
-        # Setting and deleting are both done through the __set__
-        # method of a descriptor, so we dispatch to user's __set__
-        # or __delete__ or raise an exception.
-        base_type = scope.parent_type.base_type
-        user_set_entry = scope.lookup_here("__set__")
-        user_del_entry = scope.lookup_here("__delete__")
-        code.putln("")
-        code.putln(
-            "static int %s(PyObject *o, PyObject *i, PyObject *v) {" % (
-                scope.mangle_internal("tp_descr_set")))
-        code.putln(
-            "if (v) {")
-        if user_set_entry:
-            code.putln(
-                "return %s(o, i, v);" % (
-                    user_set_entry.func_cname))
-        else:
-            self.generate_guarded_basetype_call(
-                base_type, None, "tp_descr_set", "o, i, v", code)
-            code.putln(
-                'PyErr_SetString(PyExc_NotImplementedError, "__set__");')
-            code.putln(
-                "return -1;")
-        code.putln(
-            "}")
-        code.putln(
-            "else {")
-        if user_del_entry:
-            code.putln(
-                "return %s(o, i);" % (
-                    user_del_entry.func_cname))
-        else:
-            self.generate_guarded_basetype_call(
-                base_type, None, "tp_descr_set", "o, i, v", code)
-            code.putln(
-                'PyErr_SetString(PyExc_NotImplementedError, "__delete__");')
-            code.putln(
-                "return -1;")
-        code.putln(
-            "}")
-        code.putln(
-            "}")
-
-    def generate_property_accessors(self, cclass_scope, code):
-        for entry in cclass_scope.property_entries:
-            property_scope = entry.scope
-            if property_scope.defines_any(["__get__"]):
-                self.generate_property_get_function(entry, code)
-            if property_scope.defines_any(["__set__", "__del__"]):
-                self.generate_property_set_function(entry, code)
-
-    def generate_property_get_function(self, property_entry, code):
-        property_scope = property_entry.scope
-        property_entry.getter_cname = property_scope.parent_scope.mangle(
-            Naming.prop_get_prefix, property_entry.name)
-        get_entry = property_scope.lookup_here("__get__")
-        code.putln("")
-        code.putln(
-            "static PyObject *%s(PyObject *o, CYTHON_UNUSED void *x) {" % (
-                property_entry.getter_cname))
-        code.putln(
-            "return %s(o);" % (
-                get_entry.func_cname))
-        code.putln(
-            "}")
-
-    def generate_property_set_function(self, property_entry, code):
-        property_scope = property_entry.scope
-        property_entry.setter_cname = property_scope.parent_scope.mangle(
-            Naming.prop_set_prefix, property_entry.name)
-        set_entry = property_scope.lookup_here("__set__")
-        del_entry = property_scope.lookup_here("__del__")
-        code.putln("")
-        code.putln(
-            "static int %s(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {" % (
-                property_entry.setter_cname))
-        code.putln(
-            "if (v) {")
-        if set_entry:
-            code.putln(
-                "return %s(o, v);" % (
-                    set_entry.func_cname))
-        else:
-            code.putln(
-                'PyErr_SetString(PyExc_NotImplementedError, "__set__");')
-            code.putln(
-                "return -1;")
-        code.putln(
-            "}")
-        code.putln(
-            "else {")
-        if del_entry:
-            code.putln(
-                "return %s(o);" % (
-                    del_entry.func_cname))
-        else:
-            code.putln(
-                'PyErr_SetString(PyExc_NotImplementedError, "__del__");')
-            code.putln(
-                "return -1;")
-        code.putln(
-            "}")
-        code.putln(
-            "}")
-
-    def generate_typeobj_definition(self, modname, entry, code):
-        type = entry.type
-        scope = type.scope
-        for suite in TypeSlots.substructures:
-            suite.generate_substructure(scope, code)
-        code.putln("")
-        if entry.visibility == 'public':
-            header = "DL_EXPORT(PyTypeObject) %s = {"
-        else:
-            header = "static PyTypeObject %s = {"
-        #code.putln(header % scope.parent_type.typeobj_cname)
-        code.putln(header % type.typeobj_cname)
-        code.putln(
-            "PyVarObject_HEAD_INIT(0, 0)")
-        code.putln(
-            '"%s.%s", /*tp_name*/' % (
-                self.full_module_name, scope.class_name))
-        if type.typedef_flag:
-            objstruct = type.objstruct_cname
-        else:
-            objstruct = "struct %s" % type.objstruct_cname
-        code.putln(
-            "sizeof(%s), /*tp_basicsize*/" % objstruct)
-        code.putln(
-            "0, /*tp_itemsize*/")
-        for slot in TypeSlots.slot_table:
-            slot.generate(scope, code)
-        code.putln(
-            "};")
-
-    def generate_method_table(self, env, code):
-        if env.is_c_class_scope and not env.pyfunc_entries:
-            return
-        binding = env.directives['binding']
-
-        code.putln("")
-        wrapper_code_writer = code.insertion_point()
-
-        code.putln(
-            "static PyMethodDef %s[] = {" % (
-                env.method_table_cname))
-        for entry in env.pyfunc_entries:
-            if not entry.fused_cfunction and not (binding and entry.is_overridable):
-                code.put_pymethoddef(entry, ",", wrapper_code_writer=wrapper_code_writer)
-        code.putln(
-            "{0, 0, 0, 0}")
-        code.putln(
-            "};")
-
-        if wrapper_code_writer.getvalue():
-            wrapper_code_writer.putln("")
-
-    def generate_dict_getter_function(self, scope, code):
-        dict_attr = scope.lookup_here("__dict__")
-        if not dict_attr or not dict_attr.is_variable:
-            return
-        func_name = scope.mangle_internal("__dict__getter")
-        dict_name = dict_attr.cname
-        code.putln("")
-        code.putln("static PyObject *%s(PyObject *o, CYTHON_UNUSED void *x) {" % func_name)
-        self.generate_self_cast(scope, code)
-        code.putln("if (unlikely(!p->%s)){" % dict_name)
-        code.putln("p->%s = PyDict_New();" % dict_name)
-        code.putln("}")
-        code.putln("Py_XINCREF(p->%s);" % dict_name)
-        code.putln("return p->%s;" % dict_name)
-        code.putln("}")
-
-    def generate_getset_table(self, env, code):
-        if env.property_entries:
-            code.putln("")
-            code.putln(
-                "static struct PyGetSetDef %s[] = {" %
-                env.getset_table_cname)
-            for entry in env.property_entries:
-                doc = entry.doc
-                if doc:
-                    if doc.is_unicode:
-                        doc = doc.as_utf8_string()
-                    doc_code = doc.as_c_string_literal()
-                else:
-                    doc_code = "0"
-                code.putln(
-                    '{(char *)"%s", %s, %s, (char *)%s, 0},' % (
-                        entry.name,
-                        entry.getter_cname or "0",
-                        entry.setter_cname or "0",
-                        doc_code))
-            code.putln(
-                "{0, 0, 0, 0, 0}")
-            code.putln(
-                "};")
-
-    def create_import_star_conversion_utility_code(self, env):
-        # Create all conversion helpers that are needed for "import *" assignments.
-        # Must be done before code generation to support CythonUtilityCode.
-        for name, entry in sorted(env.entries.items()):
-            if entry.is_cglobal and entry.used:
-                if not entry.type.is_pyobject:
-                    entry.type.create_from_py_utility_code(env)
-
-    def generate_import_star(self, env, code):
-        env.use_utility_code(UtilityCode.load_cached("CStringEquals", "StringTools.c"))
-        code.putln()
-        code.enter_cfunc_scope()  # as we need labels
-        code.putln("static int %s(PyObject *o, PyObject* py_name, char *name) {" % Naming.import_star_set)
-
-        code.putln("static const char* internal_type_names[] = {")
-        for name, entry in sorted(env.entries.items()):
-            if entry.is_type:
-                code.putln('"%s",' % name)
-        code.putln("0")
-        code.putln("};")
-
-        code.putln("const char** type_name = internal_type_names;")
-        code.putln("while (*type_name) {")
-        code.putln("if (__Pyx_StrEq(name, *type_name)) {")
-        code.putln('PyErr_Format(PyExc_TypeError, "Cannot overwrite C type %s", name);')
-        code.putln('goto bad;')
-        code.putln("}")
-        code.putln("type_name++;")
-        code.putln("}")
-
-        old_error_label = code.new_error_label()
-        code.putln("if (0);")  # so the first one can be "else if"
-        msvc_count = 0
-        for name, entry in sorted(env.entries.items()):
-            if entry.is_cglobal and entry.used and not entry.type.is_const:
-                msvc_count += 1
-                if msvc_count % 100 == 0:
-                    code.putln("#ifdef _MSC_VER")
-                    code.putln("if (0);  /* Workaround for MSVC C1061. */")
-                    code.putln("#endif")
-                code.putln('else if (__Pyx_StrEq(name, "%s")) {' % name)
-                if entry.type.is_pyobject:
-                    if entry.type.is_extension_type or entry.type.is_builtin_type:
-                        code.putln("if (!(%s)) %s;" % (
-                            entry.type.type_test_code("o"),
-                            code.error_goto(entry.pos)))
-                    code.putln("Py_INCREF(o);")
-                    code.put_decref(entry.cname, entry.type, nanny=False)
-                    code.putln("%s = %s;" % (
-                        entry.cname,
-                        PyrexTypes.typecast(entry.type, py_object_type, "o")))
-                elif entry.type.create_from_py_utility_code(env):
-                    # if available, utility code was already created in self.prepare_utility_code()
-                    code.putln(entry.type.from_py_call_code(
-                        'o', entry.cname, entry.pos, code))
-                else:
-                    code.putln('PyErr_Format(PyExc_TypeError, "Cannot convert Python object %s to %s");' % (
-                        name, entry.type))
-                    code.putln(code.error_goto(entry.pos))
-                code.putln("}")
-        code.putln("else {")
-        code.putln("if (PyObject_SetAttr(%s, py_name, o) < 0) goto bad;" % Naming.module_cname)
-        code.putln("}")
-        code.putln("return 0;")
-        if code.label_used(code.error_label):
-            code.put_label(code.error_label)
-            # This helps locate the offending name.
-            code.put_add_traceback(self.full_module_name)
-        code.error_label = old_error_label
-        code.putln("bad:")
-        code.putln("return -1;")
-        code.putln("}")
-        code.putln("")
-        code.putln(UtilityCode.load_as_string("ImportStar", "ImportExport.c")[1])
-        code.exit_cfunc_scope()  # done with labels
-
-    def generate_module_init_func(self, imported_modules, env, options, code):
-        subfunction = self.mod_init_subfunction(self.pos, self.scope, code)
-
-        code.enter_cfunc_scope(self.scope)
-        code.putln("")
-        code.putln(UtilityCode.load_as_string("PyModInitFuncType", "ModuleSetupCode.c")[0])
-        init_name = 'init' + (options.init_suffix or env.module_name)
-        header2 = "__Pyx_PyMODINIT_FUNC %s(void)" % init_name
-        header3 = "__Pyx_PyMODINIT_FUNC %s(void)" % self.mod_init_func_cname('PyInit', env, options)
-        code.putln("#if PY_MAJOR_VERSION < 3")
-        # Optimise for small code size as the module init function is only executed once.
-        code.putln("%s CYTHON_SMALL_CODE; /*proto*/" % header2)
-        code.putln(header2)
-        code.putln("#else")
-        code.putln("%s CYTHON_SMALL_CODE; /*proto*/" % header3)
-        code.putln(header3)
-
-        # CPython 3.5+ supports multi-phase module initialisation (gives access to __spec__, __file__, etc.)
-        code.putln("#if CYTHON_PEP489_MULTI_PHASE_INIT")
-        code.putln("{")
-        code.putln("return PyModuleDef_Init(&%s);" % Naming.pymoduledef_cname)
-        code.putln("}")
-
-        mod_create_func = UtilityCode.load_as_string("ModuleCreationPEP489", "ModuleSetupCode.c")[1]
-        code.put(mod_create_func)
-
-        code.putln("")
-        # main module init code lives in Py_mod_exec function, not in PyInit function
-        code.putln("static CYTHON_SMALL_CODE int %s(PyObject *%s)" % (
-            self.mod_init_func_cname(Naming.pymodule_exec_func_cname, env),
-            Naming.pymodinit_module_arg))
-        code.putln("#endif")  # PEP489
-
-        code.putln("#endif")  # Py3
-
-        # start of module init/exec function (pre/post PEP 489)
-        code.putln("{")
-
-        tempdecl_code = code.insertion_point()
-
-        profile = code.globalstate.directives['profile']
-        linetrace = code.globalstate.directives['linetrace']
-        if profile or linetrace:
-            code.globalstate.use_utility_code(UtilityCode.load_cached("Profile", "Profile.c"))
-
-        code.put_declare_refcount_context()
-        code.putln("#if CYTHON_PEP489_MULTI_PHASE_INIT")
-        # Most extension modules simply can't deal with it, and Cython isn't ready either.
-        # See issues listed here: https://docs.python.org/3/c-api/init.html#sub-interpreter-support
-        code.putln("if (%s) {" % Naming.module_cname)
-        # Hack: enforce single initialisation.
-        code.putln("if (%s == %s) return 0;" % (
-            Naming.module_cname,
-            Naming.pymodinit_module_arg,
-        ))
-        code.putln('PyErr_SetString(PyExc_RuntimeError,'
-                   ' "Module \'%s\' has already been imported. Re-initialisation is not supported.");' %
-                   env.module_name)
-        code.putln("return -1;")
-        code.putln("}")
-        code.putln("#elif PY_MAJOR_VERSION >= 3")
-        # Hack: enforce single initialisation also on reimports under different names on Python 3 (with PEP 3121/489).
-        code.putln("if (%s) return __Pyx_NewRef(%s);" % (
-            Naming.module_cname,
-            Naming.module_cname,
-        ))
-        code.putln("#endif")
-
-        if profile or linetrace:
-            tempdecl_code.put_trace_declarations()
-            code.put_trace_frame_init()
-
-        refnanny_import_code = UtilityCode.load_as_string("ImportRefnannyAPI", "ModuleSetupCode.c")[1]
-        code.putln(refnanny_import_code.rstrip())
-        code.put_setup_refcount_context(header3)
-
-        env.use_utility_code(UtilityCode.load("CheckBinaryVersion", "ModuleSetupCode.c"))
-        code.put_error_if_neg(self.pos, "__Pyx_check_binary_version()")
-
-        code.putln("#ifdef __Pxy_PyFrame_Initialize_Offsets")
-        code.putln("__Pxy_PyFrame_Initialize_Offsets();")
-        code.putln("#endif")
-        code.putln("%s = PyTuple_New(0); %s" % (
-            Naming.empty_tuple, code.error_goto_if_null(Naming.empty_tuple, self.pos)))
-        code.putln("%s = PyBytes_FromStringAndSize(\"\", 0); %s" % (
-            Naming.empty_bytes, code.error_goto_if_null(Naming.empty_bytes, self.pos)))
-        code.putln("%s = PyUnicode_FromStringAndSize(\"\", 0); %s" % (
-            Naming.empty_unicode, code.error_goto_if_null(Naming.empty_unicode, self.pos)))
-
-        for ext_type in ('CyFunction', 'FusedFunction', 'Coroutine', 'Generator', 'AsyncGen', 'StopAsyncIteration'):
-            code.putln("#ifdef __Pyx_%s_USED" % ext_type)
-            code.put_error_if_neg(self.pos, "__pyx_%s_init()" % ext_type)
-            code.putln("#endif")
-
-        code.putln("/*--- Library function declarations ---*/")
-        if env.directives['np_pythran']:
-            code.put_error_if_neg(self.pos, "_import_array()")
-
-        code.putln("/*--- Threads initialization code ---*/")
-        code.putln("#if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 "
-                   "&& defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS")
-        code.putln("PyEval_InitThreads();")
-        code.putln("#endif")
-
-        code.putln("/*--- Module creation code ---*/")
-        self.generate_module_creation_code(env, options, code)
-
-        code.putln("/*--- Initialize various global constants etc. ---*/")
-        code.put_error_if_neg(self.pos, "__Pyx_InitGlobals()")
-
-        code.putln("#if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || "
-                   "__PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)")
-        code.put_error_if_neg(self.pos, "__Pyx_init_sys_getdefaultencoding_params()")
-        code.putln("#endif")
-
-        code.putln("if (%s%s) {" % (Naming.module_is_main, self.full_module_name.replace('.', '__')))
-        code.put_error_if_neg(self.pos, 'PyObject_SetAttr(%s, %s, %s)' % (
-            env.module_cname,
-            code.intern_identifier(EncodedString("__name__")),
-            code.intern_identifier(EncodedString("__main__"))))
-        code.putln("}")
-
-        # set up __file__ and __path__, then add the module to sys.modules
-        self.generate_module_import_setup(env, code)
-
-        if Options.cache_builtins:
-            code.putln("/*--- Builtin init code ---*/")
-            code.put_error_if_neg(self.pos, "__Pyx_InitCachedBuiltins()")
-
-        code.putln("/*--- Constants init code ---*/")
-        code.put_error_if_neg(self.pos, "__Pyx_InitCachedConstants()")
-
-        code.putln("/*--- Global type/function init code ---*/")
-
-        with subfunction("Global init code") as inner_code:
-            self.generate_global_init_code(env, inner_code)
-
-        with subfunction("Variable export code") as inner_code:
-            self.generate_c_variable_export_code(env, inner_code)
-
-        with subfunction("Function export code") as inner_code:
-            self.generate_c_function_export_code(env, inner_code)
-
-        with subfunction("Type init code") as inner_code:
-            self.generate_type_init_code(env, inner_code)
-
-        with subfunction("Type import code") as inner_code:
-            for module in imported_modules:
-                self.generate_type_import_code_for_module(module, env, inner_code)
-
-        with subfunction("Variable import code") as inner_code:
-            for module in imported_modules:
-                self.generate_c_variable_import_code_for_module(module, env, inner_code)
-
-        with subfunction("Function import code") as inner_code:
-            for module in imported_modules:
-                self.specialize_fused_types(module)
-                self.generate_c_function_import_code_for_module(module, env, inner_code)
-
-        code.putln("/*--- Execution code ---*/")
-        code.mark_pos(None)
-
-        code.putln("#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)")
-        code.put_error_if_neg(self.pos, "__Pyx_patch_abc()")
-        code.putln("#endif")
-
-        if profile or linetrace:
-            code.put_trace_call(header3, self.pos, nogil=not code.funcstate.gil_owned)
-            code.funcstate.can_trace = True
-
-        self.body.generate_execution_code(code)
-
-        if profile or linetrace:
-            code.funcstate.can_trace = False
-            code.put_trace_return("Py_None", nogil=not code.funcstate.gil_owned)
-
-        code.putln()
-        code.putln("/*--- Wrapped vars code ---*/")
-        self.generate_wrapped_entries_code(env, code)
-        code.putln()
-
-        if Options.generate_cleanup_code:
-            code.globalstate.use_utility_code(
-                UtilityCode.load_cached("RegisterModuleCleanup", "ModuleSetupCode.c"))
-            code.putln("if (__Pyx_RegisterCleanup()) %s;" % code.error_goto(self.pos))
-
-        code.put_goto(code.return_label)
-        code.put_label(code.error_label)
-        for cname, type in code.funcstate.all_managed_temps():
-            code.put_xdecref(cname, type)
-        code.putln('if (%s) {' % env.module_cname)
-        code.putln('if (%s) {' % env.module_dict_cname)
-        code.put_add_traceback("init %s" % env.qualified_name)
-        code.globalstate.use_utility_code(Nodes.traceback_utility_code)
-        # Module reference and module dict are in global variables which might still be needed
-        # for cleanup, atexit code, etc., so leaking is better than crashing.
-        # At least clearing the module dict here might be a good idea, but could still break
-        # user code in atexit or other global registries.
-        ##code.put_decref_clear(env.module_dict_cname, py_object_type, nanny=False)
-        code.putln('}')
-        code.put_decref_clear(env.module_cname, py_object_type, nanny=False, clear_before_decref=True)
-        code.putln('} else if (!PyErr_Occurred()) {')
-        code.putln('PyErr_SetString(PyExc_ImportError, "init %s");' % env.qualified_name)
-        code.putln('}')
-        code.put_label(code.return_label)
-
-        code.put_finish_refcount_context()
-
-        code.putln("#if CYTHON_PEP489_MULTI_PHASE_INIT")
-        code.putln("return (%s != NULL) ? 0 : -1;" % env.module_cname)
-        code.putln("#elif PY_MAJOR_VERSION >= 3")
-        code.putln("return %s;" % env.module_cname)
-        code.putln("#else")
-        code.putln("return;")
-        code.putln("#endif")
-        code.putln('}')
-
-        tempdecl_code.put_temp_declarations(code.funcstate)
-
-        code.exit_cfunc_scope()
-
-    def mod_init_subfunction(self, pos, scope, orig_code):
-        """
-        Return a context manager that allows deviating the module init code generation
-        into a separate function and instead inserts a call to it.
-
-        Can be reused sequentially to create multiple functions.
-        The functions get inserted at the point where the context manager was created.
-        The call gets inserted where the context manager is used (on entry).
-        """
-        prototypes = orig_code.insertion_point()
-        prototypes.putln("")
-        function_code = orig_code.insertion_point()
-        function_code.putln("")
-
-        class ModInitSubfunction(object):
-            def __init__(self, code_type):
-                cname = '_'.join(code_type.lower().split())
-                assert re.match("^[a-z0-9_]+$", cname)
-                self.cfunc_name = "__Pyx_modinit_%s" % cname
-                self.description = code_type
-                self.tempdecl_code = None
-                self.call_code = None
-
-            def __enter__(self):
-                self.call_code = orig_code.insertion_point()
-                code = function_code
-                code.enter_cfunc_scope(scope)
-                prototypes.putln("static CYTHON_SMALL_CODE int %s(void); /*proto*/" % self.cfunc_name)
-                code.putln("static int %s(void) {" % self.cfunc_name)
-                code.put_declare_refcount_context()
-                self.tempdecl_code = code.insertion_point()
-                code.put_setup_refcount_context(self.cfunc_name)
-                # Leave a grepable marker that makes it easy to find the generator source.
-                code.putln("/*--- %s ---*/" % self.description)
-                return code
-
-            def __exit__(self, *args):
-                code = function_code
-                code.put_finish_refcount_context()
-                code.putln("return 0;")
-
-                self.tempdecl_code.put_temp_declarations(code.funcstate)
-                self.tempdecl_code = None
-
-                needs_error_handling = code.label_used(code.error_label)
-                if needs_error_handling:
-                    code.put_label(code.error_label)
-                    for cname, type in code.funcstate.all_managed_temps():
-                        code.put_xdecref(cname, type)
-                    code.put_finish_refcount_context()
-                    code.putln("return -1;")
-                code.putln("}")
-                code.exit_cfunc_scope()
-                code.putln("")
-
-                if needs_error_handling:
-                    self.call_code.putln(
-                        self.call_code.error_goto_if_neg("%s()" % self.cfunc_name, pos))
-                else:
-                    self.call_code.putln("(void)%s();" % self.cfunc_name)
-                self.call_code = None
-
-        return ModInitSubfunction
-
-    def generate_module_import_setup(self, env, code):
-        module_path = env.directives['set_initial_path']
-        if module_path == 'SOURCEFILE':
-            module_path = self.pos[0].filename
-
-        if module_path:
-            code.putln('if (!CYTHON_PEP489_MULTI_PHASE_INIT) {')
-            code.putln('if (PyObject_SetAttrString(%s, "__file__", %s) < 0) %s;' % (
-                env.module_cname,
-                code.globalstate.get_py_string_const(
-                    EncodedString(decode_filename(module_path))).cname,
-                code.error_goto(self.pos)))
-            code.putln("}")
-
-            if env.is_package:
-                # set __path__ to mark the module as package
-                code.putln('if (!CYTHON_PEP489_MULTI_PHASE_INIT) {')
-                temp = code.funcstate.allocate_temp(py_object_type, True)
-                code.putln('%s = Py_BuildValue("[O]", %s); %s' % (
-                    temp,
-                    code.globalstate.get_py_string_const(
-                        EncodedString(decode_filename(
-                            os.path.dirname(module_path)))).cname,
-                    code.error_goto_if_null(temp, self.pos)))
-                code.put_gotref(temp)
-                code.putln(
-                    'if (PyObject_SetAttrString(%s, "__path__", %s) < 0) %s;' % (
-                        env.module_cname, temp, code.error_goto(self.pos)))
-                code.put_decref_clear(temp, py_object_type)
-                code.funcstate.release_temp(temp)
-                code.putln("}")
-
-        elif env.is_package:
-            # packages require __path__, so all we can do is try to figure
-            # out the module path at runtime by rerunning the import lookup
-            code.putln("if (!CYTHON_PEP489_MULTI_PHASE_INIT) {")
-            package_name, _ = self.full_module_name.rsplit('.', 1)
-            if '.' in package_name:
-                parent_name = '"%s"' % (package_name.rsplit('.', 1)[0],)
-            else:
-                parent_name = 'NULL'
-            code.globalstate.use_utility_code(UtilityCode.load(
-                "SetPackagePathFromImportLib", "ImportExport.c"))
-            code.putln(code.error_goto_if_neg(
-                '__Pyx_SetPackagePathFromImportLib(%s, %s)' % (
-                    parent_name,
-                    code.globalstate.get_py_string_const(
-                        EncodedString(env.module_name)).cname),
-                self.pos))
-            code.putln("}")
-
-        # CPython may not have put us into sys.modules yet, but relative imports and reimports require it
-        fq_module_name = self.full_module_name
-        if fq_module_name.endswith('.__init__'):
-            fq_module_name = fq_module_name[:-len('.__init__')]
-        code.putln("#if PY_MAJOR_VERSION >= 3")
-        code.putln("{")
-        code.putln("PyObject *modules = PyImport_GetModuleDict(); %s" %
-                   code.error_goto_if_null("modules", self.pos))
-        code.putln('if (!PyDict_GetItemString(modules, "%s")) {' % fq_module_name)
-        code.putln(code.error_goto_if_neg('PyDict_SetItemString(modules, "%s", %s)' % (
-            fq_module_name, env.module_cname), self.pos))
-        code.putln("}")
-        code.putln("}")
-        code.putln("#endif")
-
-    def generate_module_cleanup_func(self, env, code):
-        if not Options.generate_cleanup_code:
-            return
-
-        code.putln('static void %s(CYTHON_UNUSED PyObject *self) {' %
-                   Naming.cleanup_cname)
-        code.enter_cfunc_scope(env)
-
-        if Options.generate_cleanup_code >= 2:
-            code.putln("/*--- Global cleanup code ---*/")
-            rev_entries = list(env.var_entries)
-            rev_entries.reverse()
-            for entry in rev_entries:
-                if entry.visibility != 'extern':
-                    if entry.type.is_pyobject and entry.used:
-                        code.put_xdecref_clear(
-                            entry.cname, entry.type,
-                            clear_before_decref=True,
-                            nanny=False)
-        code.putln("__Pyx_CleanupGlobals();")
-        if Options.generate_cleanup_code >= 3:
-            code.putln("/*--- Type import cleanup code ---*/")
-            for ext_type in sorted(env.types_imported, key=operator.attrgetter('typeptr_cname')):
-                code.put_xdecref_clear(
-                    ext_type.typeptr_cname, ext_type,
-                    clear_before_decref=True,
-                    nanny=False)
-        if Options.cache_builtins:
-            code.putln("/*--- Builtin cleanup code ---*/")
-            for entry in env.cached_builtins:
-                code.put_xdecref_clear(
-                    entry.cname, PyrexTypes.py_object_type,
-                    clear_before_decref=True,
-                    nanny=False)
-        code.putln("/*--- Intern cleanup code ---*/")
-        code.put_decref_clear(Naming.empty_tuple,
-                              PyrexTypes.py_object_type,
-                              clear_before_decref=True,
-                              nanny=False)
-        for entry in env.c_class_entries:
-            cclass_type = entry.type
-            if cclass_type.is_external or cclass_type.base_type:
-                continue
-            if cclass_type.scope.directives.get('freelist', 0):
-                scope = cclass_type.scope
-                freelist_name = scope.mangle_internal(Naming.freelist_name)
-                freecount_name = scope.mangle_internal(Naming.freecount_name)
-                code.putln("while (%s > 0) {" % freecount_name)
-                code.putln("PyObject* o = (PyObject*)%s[--%s];" % (
-                    freelist_name, freecount_name))
-                code.putln("(*Py_TYPE(o)->tp_free)(o);")
-                code.putln("}")
-#        for entry in env.pynum_entries:
-#            code.put_decref_clear(entry.cname,
-#                                  PyrexTypes.py_object_type,
-#                                  nanny=False)
-#        for entry in env.all_pystring_entries:
-#            if entry.is_interned:
-#                code.put_decref_clear(entry.pystring_cname,
-#                                      PyrexTypes.py_object_type,
-#                                      nanny=False)
-#        for entry in env.default_entries:
-#            if entry.type.is_pyobject and entry.used:
-#                code.putln("Py_DECREF(%s); %s = 0;" % (
-#                    code.entry_as_pyobject(entry), entry.cname))
-        if Options.pre_import is not None:
-            code.put_decref_clear(Naming.preimport_cname, py_object_type,
-                                  nanny=False, clear_before_decref=True)
-        for cname in [env.module_dict_cname, Naming.cython_runtime_cname, Naming.builtins_cname]:
-            code.put_decref_clear(cname, py_object_type, nanny=False, clear_before_decref=True)
-
-    def generate_main_method(self, env, code):
-        module_is_main = "%s%s" % (Naming.module_is_main, self.full_module_name.replace('.', '__'))
-        if Options.embed == "main":
-            wmain = "wmain"
-        else:
-            wmain = Options.embed
-        main_method = UtilityCode.load_cached("MainFunction", "Embed.c")
-        code.globalstate.use_utility_code(
-            main_method.specialize(
-                module_name=env.module_name,
-                module_is_main=module_is_main,
-                main_method=Options.embed,
-                wmain_method=wmain))
-
-    def mod_init_func_cname(self, prefix, env, options=None):
-        return '%s_%s' % (prefix, options and options.init_suffix or env.module_name)
-
-    def generate_pymoduledef_struct(self, env, options, code):
-        if env.doc:
-            doc = "%s" % code.get_string_const(env.doc)
-        else:
-            doc = "0"
-        if Options.generate_cleanup_code:
-            cleanup_func = "(freefunc)%s" % Naming.cleanup_cname
-        else:
-            cleanup_func = 'NULL'
-
-        code.putln("")
-        code.putln("#if PY_MAJOR_VERSION >= 3")
-        code.putln("#if CYTHON_PEP489_MULTI_PHASE_INIT")
-        exec_func_cname = self.mod_init_func_cname(Naming.pymodule_exec_func_cname, env)
-        code.putln("static PyObject* %s(PyObject *spec, PyModuleDef *def); /*proto*/" %
-                   Naming.pymodule_create_func_cname)
-        code.putln("static int %s(PyObject* module); /*proto*/" % exec_func_cname)
-
-        code.putln("static PyModuleDef_Slot %s[] = {" % Naming.pymoduledef_slots_cname)
-        code.putln("{Py_mod_create, (void*)%s}," % Naming.pymodule_create_func_cname)
-        code.putln("{Py_mod_exec, (void*)%s}," % exec_func_cname)
-        code.putln("{0, NULL}")
-        code.putln("};")
-        code.putln("#endif")
-
-        code.putln("")
-        code.putln("static struct PyModuleDef %s = {" % Naming.pymoduledef_cname)
-        code.putln("  PyModuleDef_HEAD_INIT,")
-        code.putln('  "%s",' % (options.module_name or env.module_name))
-        code.putln("  %s, /* m_doc */" % doc)
-        code.putln("#if CYTHON_PEP489_MULTI_PHASE_INIT")
-        code.putln("  0, /* m_size */")
-        code.putln("#else")
-        code.putln("  -1, /* m_size */")
-        code.putln("#endif")
-        code.putln("  %s /* m_methods */," % env.method_table_cname)
-        code.putln("#if CYTHON_PEP489_MULTI_PHASE_INIT")
-        code.putln("  %s, /* m_slots */" % Naming.pymoduledef_slots_cname)
-        code.putln("#else")
-        code.putln("  NULL, /* m_reload */")
-        code.putln("#endif")
-        code.putln("  NULL, /* m_traverse */")
-        code.putln("  NULL, /* m_clear */")
-        code.putln("  %s /* m_free */" % cleanup_func)
-        code.putln("};")
-        code.putln("#endif")
-
-    def generate_module_creation_code(self, env, options, code):
-        # Generate code to create the module object and
-        # install the builtins.
-        if env.doc:
-            doc = "%s" % code.get_string_const(env.doc)
-        else:
-            doc = "0"
-
-        code.putln("#if CYTHON_PEP489_MULTI_PHASE_INIT")
-        code.putln("%s = %s;" % (
-            env.module_cname,
-            Naming.pymodinit_module_arg))
-        code.put_incref(env.module_cname, py_object_type, nanny=False)
-        code.putln("#else")
-        code.putln("#if PY_MAJOR_VERSION < 3")
-        code.putln(
-            '%s = Py_InitModule4("%s", %s, %s, 0, PYTHON_API_VERSION); Py_XINCREF(%s);' % (
-                env.module_cname,
-                options.module_name or env.module_name,
-                env.method_table_cname,
-                doc,
-                env.module_cname))
-        code.putln("#else")
-        code.putln(
-            "%s = PyModule_Create(&%s);" % (
-                env.module_cname,
-                Naming.pymoduledef_cname))
-        code.putln("#endif")
-        code.putln(code.error_goto_if_null(env.module_cname, self.pos))
-        code.putln("#endif")  # CYTHON_PEP489_MULTI_PHASE_INIT
-
-        code.putln(
-            "%s = PyModule_GetDict(%s); %s" % (
-                env.module_dict_cname, env.module_cname,
-                code.error_goto_if_null(env.module_dict_cname, self.pos)))
-        code.put_incref(env.module_dict_cname, py_object_type, nanny=False)
-
-        code.putln(
-            '%s = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); %s' % (
-                Naming.builtins_cname,
-                code.error_goto_if_null(Naming.builtins_cname, self.pos)))
-        code.put_incref(Naming.builtins_cname, py_object_type, nanny=False)
-        code.putln(
-            '%s = PyImport_AddModule((char *) "cython_runtime"); %s' % (
-                Naming.cython_runtime_cname,
-                code.error_goto_if_null(Naming.cython_runtime_cname, self.pos)))
-        code.put_incref(Naming.cython_runtime_cname, py_object_type, nanny=False)
-        code.putln(
-            'if (PyObject_SetAttrString(%s, "__builtins__", %s) < 0) %s;' % (
-                env.module_cname,
-                Naming.builtins_cname,
-                code.error_goto(self.pos)))
-        if Options.pre_import is not None:
-            code.putln(
-                '%s = PyImport_AddModule("%s"); %s' % (
-                    Naming.preimport_cname,
-                    Options.pre_import,
-                    code.error_goto_if_null(Naming.preimport_cname, self.pos)))
-            code.put_incref(Naming.preimport_cname, py_object_type, nanny=False)
-
-    def generate_global_init_code(self, env, code):
-        # Generate code to initialise global PyObject *
-        # variables to None.
-        for entry in env.var_entries:
-            if entry.visibility != 'extern':
-                if entry.used:
-                    entry.type.global_init_code(entry, code)
-
-    def generate_wrapped_entries_code(self, env, code):
-        for name, entry in sorted(env.entries.items()):
-            if (entry.create_wrapper
-                    and not entry.is_type
-                    and entry.scope is env):
-                if not entry.type.create_to_py_utility_code(env):
-                    error(entry.pos, "Cannot convert '%s' to Python object" % entry.type)
-                code.putln("{")
-                code.putln("PyObject* wrapped = %s(%s);"  % (
-                    entry.type.to_py_function,
-                    entry.cname))
-                code.putln(code.error_goto_if_null("wrapped", entry.pos))
-                code.putln(
-                    'if (PyObject_SetAttrString(%s, "%s", wrapped) < 0) %s;' % (
-                        env.module_cname,
-                        name,
-                        code.error_goto(entry.pos)))
-                code.putln("}")
-
-    def generate_c_variable_export_code(self, env, code):
-        # Generate code to create PyCFunction wrappers for exported C functions.
-        entries = []
-        for entry in env.var_entries:
-            if (entry.api
-                    or entry.defined_in_pxd
-                    or (Options.cimport_from_pyx and not entry.visibility == 'extern')):
-                entries.append(entry)
-        if entries:
-            env.use_utility_code(UtilityCode.load_cached("VoidPtrExport", "ImportExport.c"))
-            for entry in entries:
-                signature = entry.type.empty_declaration_code()
-                name = code.intern_identifier(entry.name)
-                code.putln('if (__Pyx_ExportVoidPtr(%s, (void *)&%s, "%s") < 0) %s' % (
-                    name, entry.cname, signature,
-                    code.error_goto(self.pos)))
-
-    def generate_c_function_export_code(self, env, code):
-        # Generate code to create PyCFunction wrappers for exported C functions.
-        entries = []
-        for entry in env.cfunc_entries:
-            if (entry.api
-                    or entry.defined_in_pxd
-                    or (Options.cimport_from_pyx and not entry.visibility == 'extern')):
-                entries.append(entry)
-        if entries:
-            env.use_utility_code(
-                UtilityCode.load_cached("FunctionExport", "ImportExport.c"))
-            # Note: while this looks like it could be more cheaply stored and read from a struct array,
-            # investigation shows that the resulting binary is smaller with repeated functions calls.
-            for entry in entries:
-                signature = entry.type.signature_string()
-                code.putln('if (__Pyx_ExportFunction("%s", (void (*)(void))%s, "%s") < 0) %s' % (
-                    entry.name,
-                    entry.cname,
-                    signature,
-                    code.error_goto(self.pos)))
-
-    def generate_type_import_code_for_module(self, module, env, code):
-        # Generate type import code for all exported extension types in
-        # an imported module.
-        #if module.c_class_entries:
-        with ModuleImportGenerator(code) as import_generator:
-            for entry in module.c_class_entries:
-                if entry.defined_in_pxd:
-                    self.generate_type_import_code(env, entry.type, entry.pos, code, import_generator)
-
-    def specialize_fused_types(self, pxd_env):
-        """
-        If fused c(p)def functions are defined in an imported pxd, but not
-        used in this implementation file, we still have fused entries and
-        not specialized ones. This method replaces any fused entries with their
-        specialized ones.
-        """
-        for entry in pxd_env.cfunc_entries[:]:
-            if entry.type.is_fused:
-                # This call modifies the cfunc_entries in-place
-                entry.type.get_all_specialized_function_types()
-
-    def generate_c_variable_import_code_for_module(self, module, env, code):
-        # Generate import code for all exported C functions in a cimported module.
-        entries = []
-        for entry in module.var_entries:
-            if entry.defined_in_pxd:
-                entries.append(entry)
-        if entries:
-            env.use_utility_code(
-                UtilityCode.load_cached("VoidPtrImport", "ImportExport.c"))
-            temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
-            code.putln(
-                '%s = PyImport_ImportModule("%s"); if (!%s) %s' % (
-                    temp,
-                    module.qualified_name,
-                    temp,
-                    code.error_goto(self.pos)))
-            code.put_gotref(temp)
-            for entry in entries:
-                if env is module:
-                    cname = entry.cname
-                else:
-                    cname = module.mangle(Naming.varptr_prefix, entry.name)
-                signature = entry.type.empty_declaration_code()
-                code.putln(
-                    'if (__Pyx_ImportVoidPtr(%s, "%s", (void **)&%s, "%s") < 0) %s' % (
-                        temp, entry.name, cname, signature,
-                        code.error_goto(self.pos)))
-            code.put_decref_clear(temp, py_object_type)
-            code.funcstate.release_temp(temp)
-
-    def generate_c_function_import_code_for_module(self, module, env, code):
-        # Generate import code for all exported C functions in a cimported module.
-        entries = []
-        for entry in module.cfunc_entries:
-            if entry.defined_in_pxd and entry.used:
-                entries.append(entry)
-        if entries:
-            env.use_utility_code(
-                UtilityCode.load_cached("FunctionImport", "ImportExport.c"))
-            temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
-            code.putln(
-                '%s = PyImport_ImportModule("%s"); if (!%s) %s' % (
-                    temp,
-                    module.qualified_name,
-                    temp,
-                    code.error_goto(self.pos)))
-            code.put_gotref(temp)
-            for entry in entries:
-                code.putln(
-                    'if (__Pyx_ImportFunction(%s, "%s", (void (**)(void))&%s, "%s") < 0) %s' % (
-                        temp,
-                        entry.name,
-                        entry.cname,
-                        entry.type.signature_string(),
-                        code.error_goto(self.pos)))
-            code.put_decref_clear(temp, py_object_type)
-            code.funcstate.release_temp(temp)
-
-    def generate_type_init_code(self, env, code):
-        # Generate type import code for extern extension types
-        # and type ready code for non-extern ones.
-        with ModuleImportGenerator(code) as import_generator:
-            for entry in env.c_class_entries:
-                if entry.visibility == 'extern' and not entry.utility_code_definition:
-                    self.generate_type_import_code(env, entry.type, entry.pos, code, import_generator)
-                else:
-                    self.generate_base_type_import_code(env, entry, code, import_generator)
-                    self.generate_exttype_vtable_init_code(entry, code)
-                    if entry.type.early_init:
-                        self.generate_type_ready_code(entry, code)
-
-    def generate_base_type_import_code(self, env, entry, code, import_generator):
-        base_type = entry.type.base_type
-        if (base_type and base_type.module_name != env.qualified_name and not
-                base_type.is_builtin_type and not entry.utility_code_definition):
-            self.generate_type_import_code(env, base_type, self.pos, code, import_generator)
-
-    def generate_type_import_code(self, env, type, pos, code, import_generator):
-        # If not already done, generate code to import the typeobject of an
-        # extension type defined in another module, and extract its C method
-        # table pointer if any.
-        if type in env.types_imported:
-            return
-        if type.name not in Code.ctypedef_builtins_map:
-            # see corresponding condition in generate_type_import_call() below!
-            code.globalstate.use_utility_code(
-                UtilityCode.load_cached("TypeImport", "ImportExport.c"))
-        self.generate_type_import_call(type, code, import_generator, error_pos=pos)
-        if type.vtabptr_cname:
-            code.globalstate.use_utility_code(
-                UtilityCode.load_cached('GetVTable', 'ImportExport.c'))
-            code.putln("%s = (struct %s*)__Pyx_GetVtable(%s->tp_dict); %s" % (
-                type.vtabptr_cname,
-                type.vtabstruct_cname,
-                type.typeptr_cname,
-                code.error_goto_if_null(type.vtabptr_cname, pos)))
-        env.types_imported.add(type)
-
-    def generate_type_import_call(self, type, code, import_generator, error_code=None, error_pos=None):
-        if type.typedef_flag:
-            objstruct = type.objstruct_cname
-        else:
-            objstruct = "struct %s" % type.objstruct_cname
-        sizeof_objstruct = objstruct
-        module_name = type.module_name
-        condition = replacement = None
-        if module_name not in ('__builtin__', 'builtins'):
-            module_name = '"%s"' % module_name
-        elif type.name in Code.ctypedef_builtins_map:
-            # Fast path for special builtins, don't actually import
-            ctypename = Code.ctypedef_builtins_map[type.name]
-            code.putln('%s = %s;' % (type.typeptr_cname, ctypename))
-            return
-        else:
-            module_name = '__Pyx_BUILTIN_MODULE_NAME'
-            if type.name in Code.non_portable_builtins_map:
-                condition, replacement = Code.non_portable_builtins_map[type.name]
-            if objstruct in Code.basicsize_builtins_map:
-                # Some builtin types have a tp_basicsize which differs from sizeof(...):
-                sizeof_objstruct = Code.basicsize_builtins_map[objstruct]
-
-        if not error_code:
-            assert error_pos is not None
-            error_code = code.error_goto(error_pos)
-
-        module = import_generator.imported_module(module_name, error_code)
-        code.put('%s = __Pyx_ImportType(%s, %s,' % (
-            type.typeptr_cname,
-            module,
-            module_name))
-
-        if condition and replacement:
-            code.putln("")  # start in new line
-            code.putln("#if %s" % condition)
-            code.putln('"%s",' % replacement)
-            code.putln("#else")
-            code.putln('"%s",' % type.name)
-            code.putln("#endif")
-        else:
-            code.put(' "%s", ' % type.name)
-
-        if sizeof_objstruct != objstruct:
-            if not condition:
-                code.putln("")  # start in new line
-            code.putln("#if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000")
-            code.putln('sizeof(%s),' % objstruct)
-            code.putln("#else")
-            code.putln('sizeof(%s),' % sizeof_objstruct)
-            code.putln("#endif")
-        else:
-            code.put('sizeof(%s), ' % objstruct)
-
-        # check_size
-        if type.check_size and type.check_size in ('error', 'warn', 'ignore'):
-            check_size = type.check_size
-        elif not type.is_external or type.is_subclassed:
-            check_size = 'error'
-        else:
-            raise RuntimeError("invalid value for check_size '%s' when compiling %s.%s" % (
-                type.check_size, module_name, type.name))
-        code.putln('__Pyx_ImportType_CheckSize_%s);' % check_size.title())
-
-        code.putln(' if (!%s) %s' % (type.typeptr_cname, error_code))
-
-    def generate_type_ready_code(self, entry, code):
-        Nodes.CClassDefNode.generate_type_ready_code(entry, code)
-
-    def generate_exttype_vtable_init_code(self, entry, code):
-        # Generate code to initialise the C method table of an
-        # extension type.
-        type = entry.type
-        if type.vtable_cname:
-            code.putln(
-                "%s = &%s;" % (
-                    type.vtabptr_cname,
-                    type.vtable_cname))
-            if type.base_type and type.base_type.vtabptr_cname:
-                code.putln(
-                    "%s.%s = *%s;" % (
-                        type.vtable_cname,
-                        Naming.obj_base_cname,
-                        type.base_type.vtabptr_cname))
-
-            c_method_entries = [
-                entry for entry in type.scope.cfunc_entries
-                if entry.func_cname]
-            if c_method_entries:
-                for meth_entry in c_method_entries:
-                    cast = meth_entry.type.signature_cast_string()
-                    code.putln(
-                        "%s.%s = %s%s;" % (
-                            type.vtable_cname,
-                            meth_entry.cname,
-                            cast,
-                            meth_entry.func_cname))
-
-
-class ModuleImportGenerator(object):
-    """
-    Helper to generate module import while importing external types.
-    This is used to avoid excessive re-imports of external modules when multiple types are looked up.
-    """
-    def __init__(self, code, imported_modules=None):
-        self.code = code
-        self.imported = {}
-        if imported_modules:
-            for name, cname in imported_modules.items():
-                self.imported['"%s"' % name] = cname
-        self.temps = []  # remember original import order for freeing
-
-    def imported_module(self, module_name_string, error_code):
-        if module_name_string in self.imported:
-            return self.imported[module_name_string]
-
-        code = self.code
-        temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
-        self.temps.append(temp)
-        code.putln('%s = PyImport_ImportModule(%s); if (unlikely(!%s)) %s' % (
-            temp, module_name_string, temp, error_code))
-        code.put_gotref(temp)
-        self.imported[module_name_string] = temp
-        return temp
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *exc):
-        code = self.code
-        for temp in self.temps:
-            code.put_decref_clear(temp, py_object_type)
-            code.funcstate.release_temp(temp)
-
-
-def generate_cfunction_declaration(entry, env, code, definition):
-    from_cy_utility = entry.used and entry.utility_code_definition
-    if entry.used and entry.inline_func_in_pxd or (not entry.in_cinclude and (
-            definition or entry.defined_in_pxd or entry.visibility == 'extern' or from_cy_utility)):
-        if entry.visibility == 'extern':
-            storage_class = Naming.extern_c_macro
-            dll_linkage = "DL_IMPORT"
-        elif entry.visibility == 'public':
-            storage_class = Naming.extern_c_macro
-            dll_linkage = None
-        elif entry.visibility == 'private':
-            storage_class = "static"
-            dll_linkage = None
-        else:
-            storage_class = "static"
-            dll_linkage = None
-        type = entry.type
-
-        if entry.defined_in_pxd and not definition:
-            storage_class = "static"
-            dll_linkage = None
-            type = CPtrType(type)
-
-        header = type.declaration_code(
-            entry.cname, dll_linkage=dll_linkage)
-        modifiers = code.build_function_modifiers(entry.func_modifiers)
-        code.putln("%s %s%s; /*proto*/" % (
-            storage_class,
-            modifiers,
-            header))
-
-#------------------------------------------------------------------------------------
-#
-#  Runtime support code
-#
-#------------------------------------------------------------------------------------
-
-refnanny_utility_code = UtilityCode.load("Refnanny", "ModuleSetupCode.c")
-
-packed_struct_utility_code = UtilityCode(proto="""
-#if defined(__GNUC__)
-#define __Pyx_PACKED __attribute__((__packed__))
-#else
-#define __Pyx_PACKED
-#endif
-""", impl="", proto_block='utility_code_proto_before_types')
-
-capsule_utility_code = UtilityCode.load("Capsule")