diff options
| author | Anton Samokhvalov <pg83@yandex.ru> | 2022-02-10 16:45:17 +0300 |
|---|---|---|
| committer | Daniil Cherednik <dcherednik@yandex-team.ru> | 2022-02-10 16:45:17 +0300 |
| commit | d3a398281c6fd1d3672036cb2d63f842d2cb28c5 (patch) | |
| tree | dd4bd3ca0f36b817e96812825ffaf10d645803f2 /contrib/tools/cython/Cython/Compiler/ModuleNode.py | |
| parent | 72cb13b4aff9bc9cf22e49251bc8fd143f82538f (diff) | |
| download | ydb-d3a398281c6fd1d3672036cb2d63f842d2cb28c5.tar.gz | |
Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 2 of 2.
Diffstat (limited to 'contrib/tools/cython/Cython/Compiler/ModuleNode.py')
| -rw-r--r-- | contrib/tools/cython/Cython/Compiler/ModuleNode.py | 4352 |
1 files changed, 2176 insertions, 2176 deletions
diff --git a/contrib/tools/cython/Cython/Compiler/ModuleNode.py b/contrib/tools/cython/Cython/Compiler/ModuleNode.py index 5b69ca34af..cd7166408e 100644 --- a/contrib/tools/cython/Cython/Compiler/ModuleNode.py +++ b/contrib/tools/cython/Cython/Compiler/ModuleNode.py @@ -1,48 +1,48 @@ -# -# 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, +# +# 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 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 .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 .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 .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 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: @@ -56,73 +56,73 @@ def generate_c_code_config(env, options): 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) - +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): + 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 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) - + 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 @@ -134,217 +134,217 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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) + 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) + + 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() + 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 - + 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_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) + 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("") + 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") + 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("#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, + 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: + 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 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() + 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) + 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) + 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) + 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.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.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: + 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: + 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)) + 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: + 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: + 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) @@ -354,75 +354,75 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code_config=c_code_config, common_utility_include_dir=options.common_utility_include_dir, ) - globalstate.initialize_main_c_code() - h_code = globalstate['h_code'] - + 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) + + 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.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) + code = globalstate['all_the_rest'] - self.body.generate_function_definitions(env, code) + 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) - 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.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 + # 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_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) - + 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: @@ -441,190 +441,190 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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) + # 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 + 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() - + + 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: + for c_lineno, cython_lineno in enumerate(markers): + if cython_lineno > 0: d[cython_lineno].append(c_lineno + 1) - - tb.start('LineNumberMapping') + + 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) + 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 + 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) + 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) - + 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]) @@ -637,27 +637,27 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code.putln("") code.putln("#ifndef PY_SSIZE_T_CLEAN") - code.putln("#define 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("#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("#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") @@ -665,7 +665,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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) @@ -680,92 +680,92 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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("") + 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("") 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 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: + 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('#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('') 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;' % 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_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) - + 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_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 = [] + includes = [] for inc in sorted(env.c_includes.values(), key=IncludeCode.sortkey): if inc.location == inc.EARLY: if early: @@ -775,13 +775,13 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): inc.write(code) if early: code.putln_openmp("#include <omp.h>") - - def generate_filename_table(self, code): + + 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: + 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 @@ -789,160 +789,160 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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) + 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_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: + 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: + 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( + 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(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( + # 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(" {") + 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 + has_virtual_methods = False constructor = None destructor = None - for attr in scope.var_entries: + 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 ") + 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.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: @@ -1016,831 +1016,831 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 "" + 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: + 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("") + 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: + 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( + + 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(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 + + 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: + 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( + 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 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: + 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 + 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) + 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) + self.generate_getitem_int_function(scope, code) if scope.defines_any_special(["__setitem__", "__delitem__"]): - self.generate_ass_subscript_function(scope, code) + 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") + 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) + self.generate_ass_slice_function(scope, code) if scope.defines_any_special(["__getattr__", "__getattribute__"]): - self.generate_getattro_function(scope, code) + self.generate_getattro_function(scope, code) if scope.defines_any_special(["__setattr__", "__delattr__"]): - self.generate_setattro_function(scope, code) + self.generate_setattro_function(scope, code) if scope.defines_any_special(["__get__"]): - self.generate_descr_get_function(scope, code) + self.generate_descr_get_function(scope, code) if scope.defines_any_special(["__set__", "__delete__"]): - self.generate_descr_set_function(scope, code) + 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"), + 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( + + 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) + + 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) + 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: + 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: + + 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" + + 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;") + 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() - + 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 - + 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] - + _, (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 + 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))') + 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 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: + 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: + + 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 (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);") + 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("%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: + 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( + 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 + + 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 + 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) + + # 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("}") + code.putln("return 0;") code.putln("}") - - def generate_clear_function(self, scope, code, cclass_entry): + + 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 + 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.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( + + 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( + code.putln( "PyObject *r;") - code.putln( + code.putln( "PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;") - code.putln( + code.putln( "r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);") - code.putln( + code.putln( "Py_DECREF(x);") - code.putln( + 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( + 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( + code.putln( "if (v) {") - if set_entry: + 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( + 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( + code.putln( ' "Subscript assignment not supported by %.200s", Py_TYPE(o)->tp_name);') - code.putln( + code.putln( "return -1;") - code.putln( + code.putln( "}") - code.putln( + code.putln( "else {") - if del_entry: - code.putln( + 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( + 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( + code.putln( ' "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);') - code.putln( + code.putln( "return -1;") - code.putln( + 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( + 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( + code.putln( "if (v) {") - if set_entry: - code.putln( + 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( + 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( + code.putln( ' "2-element slice assignment not supported by %.200s", Py_TYPE(o)->tp_name);') - code.putln( + code.putln( "return -1;") - code.putln( + code.putln( "}") - code.putln( + code.putln( "else {") - if del_entry: - code.putln( + 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( + 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( + code.putln( ' "2-element slice deletion not supported by %.200s", Py_TYPE(o)->tp_name);') - code.putln( + code.putln( "return -1;") - code.putln( + code.putln( "}") - code.putln( - "}") - + code.putln( + "}") + def generate_richcmp_function(self, scope, code): if scope.lookup_here("__richcmp__"): # user implemented, nothing to do @@ -1911,15 +1911,15 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 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 + # Recursive lookup if tp is None: tp = scope.parent_type r = tp.scope.lookup_here(n) @@ -1931,17 +1931,17 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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( + 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( + if getattribute_entry is not None: + code.putln( "PyObject *v = %s(o, n);" % ( getattribute_entry.func_cname)) - else: + 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( @@ -1954,246 +1954,246 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): generic_getattr_cfunc = "__Pyx_PyObject_GenericGetAttr" else: generic_getattr_cfunc = "PyObject_GenericGetAttr" - code.putln( + 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( + 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( + 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( + code.putln( "if (v) {") - if set_entry: - code.putln( + 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( + 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( "}") - code.putln( + code.putln( "else {") - if del_entry: - code.putln( + 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( + 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( "}") - 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( + 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( + 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( + #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( + code.putln( "if (v) {") - if user_set_entry: - code.putln( + 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( + 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( + code.putln( "return -1;") - code.putln( + code.putln( "}") - code.putln( + code.putln( "else {") - if user_del_entry: - code.putln( + 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( + 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( + code.putln( "return -1;") - code.putln( + 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( + 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( + 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( + 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( + code.putln( "if (v) {") - if set_entry: - code.putln( + if set_entry: + code.putln( "return %s(o, v);" % ( set_entry.func_cname)) - else: - code.putln( + else: + code.putln( 'PyErr_SetString(PyExc_NotImplementedError, "__set__");') - code.putln( + code.putln( "return -1;") - code.putln( + code.putln( "}") - code.putln( + code.putln( "else {") - if del_entry: - code.putln( + if del_entry: + code.putln( "return %s(o);" % ( del_entry.func_cname)) - else: - code.putln( + else: + code.putln( 'PyErr_SetString(PyExc_NotImplementedError, "__del__");') - code.putln( + code.putln( "return -1;") - code.putln( + code.putln( + "}") + 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( + + 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 + 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("") + code.putln("") wrapper_code_writer = code.insertion_point() - code.putln( + code.putln( "static PyMethodDef %s[] = {" % ( env.method_table_cname)) - for entry in env.pyfunc_entries: + 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( + code.putln( "{0, 0, 0, 0}") - code.putln( - "};") - + code.putln( + "};") + if wrapper_code_writer.getvalue(): wrapper_code_writer.putln("") @@ -2213,31 +2213,31 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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[] = {" % + 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: + 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( + 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( + entry.name, + entry.getter_cname or "0", + entry.setter_cname or "0", + doc_code)) + code.putln( "{0, 0, 0, 0, 0}") - code.putln( - "};") - + 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. @@ -2246,29 +2246,29 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): if not entry.type.is_pyobject: entry.type.create_from_py_utility_code(env) - def generate_import_star(self, env, code): + def generate_import_star(self, env, code): env.use_utility_code(UtilityCode.load_cached("CStringEquals", "StringTools.c")) - code.putln() + 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("};") + 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("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()): @@ -2278,62 +2278,62 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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"))) + 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: + 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.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("") 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") + 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(header2) + code.putln("#else") code.putln("%s CYTHON_SMALL_CODE; /*proto*/" % header3) - code.putln(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("{") code.putln("return PyModuleDef_Init(&%s);" % Naming.pymoduledef_cname) code.putln("}") @@ -2352,14 +2352,14 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): # start of module init/exec function (pre/post PEP 489) code.putln("{") - tempdecl_code = code.insertion_point() - + 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.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 @@ -2388,11 +2388,11 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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_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") @@ -2402,80 +2402,80 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 ---*/") + + 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("/*--- 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 ---*/") + 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.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.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.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.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("/*--- 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") @@ -2484,57 +2484,57 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code.put_trace_call(header3, self.pos, nogil=not code.funcstate.gil_owned) code.funcstate.can_trace = True - self.body.generate_execution_code(code) - + 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.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) + 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.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('} 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() - + 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 @@ -2599,172 +2599,172 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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: + 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 (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 + + 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) + 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 + + 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)) + 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) + + # 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.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 + + 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( + 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") + 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*/" % @@ -2779,34 +2779,34 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code.putln("#endif") code.putln("") - code.putln("static struct PyModuleDef %s = {" % Naming.pymoduledef_cname) - code.putln(" PyModuleDef_HEAD_INIT,") + 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(" %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(" -1, /* m_size */") code.putln("#endif") - code.putln(" %s /* m_methods */," % env.method_table_cname) + 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(" 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") - 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" + # 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;" % ( @@ -2814,199 +2814,199 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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, + 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)) + 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.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.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): + + 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 + 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: + 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 + 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")) + 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: + 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( + + 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))) + 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) + 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.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( + + 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))) + 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))) + 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. + + 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: @@ -3016,88 +3016,88 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 = 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 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) - + 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 + 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] - + 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, + 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 + 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) - + 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 @@ -3107,41 +3107,41 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 + + 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)) - + 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): """ @@ -3179,51 +3179,51 @@ class ModuleImportGenerator(object): code.funcstate.release_temp(temp) -def generate_cfunction_declaration(entry, env, code, definition): - from_cy_utility = entry.used and entry.utility_code_definition +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 + 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( + 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 -# -#------------------------------------------------------------------------------------ - + 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") + +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") |