| # |
| # Module parse tree node |
| # |
| |
| import cython |
| cython.declare(Naming=object, Options=object, PyrexTypes=object, TypeSlots=object, |
| error=object, warning=object, py_object_type=object, UtilityCode=object, |
| EncodedString=object) |
| |
| import os |
| import operator |
| from PyrexTypes import CPtrType |
| import Future |
| |
| import Annotate |
| import Code |
| import Naming |
| import Nodes |
| import Options |
| import TypeSlots |
| import Version |
| import PyrexTypes |
| |
| from Errors import error, warning |
| from PyrexTypes import py_object_type |
| from Cython.Utils import open_new_file, replace_suffix, decode_filename |
| from Code import UtilityCode |
| from StringEncoding import EncodedString |
| |
| |
| |
| 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 |
| |
| 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) |
| |
| 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.include_files, scope.include_files) |
| extend_if_not_in(self.scope.included_files, scope.included_files) |
| extend_if_not_in(self.scope.python_include_files, |
| scope.python_include_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 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 self.doc is None: |
| env.doc = EncodedString(env.doc + u'\n' + self.doc) |
| env.doc.encoding = self.doc.encoding |
| else: |
| env.doc = self.doc |
| env.directives = self.directives |
| self.body.analyse_declarations(env) |
| |
| def 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, result) |
| |
| def has_imported_c_functions(self): |
| for module in self.referenced_modules: |
| for entry in module.cfunc_entries: |
| if entry.defined_in_pxd: |
| return 1 |
| return 0 |
| |
| def generate_h_code(self, env, options, result): |
| def h_entries(entries, api=0, pxd=0): |
| return [entry for entry in entries |
| if ((entry.visibility == 'public') or |
| (api and entry.api) or |
| (pxd and entry.defined_in_pxd))] |
| h_types = h_entries(env.type_entries, api=1) |
| h_vars = h_entries(env.var_entries) |
| h_funcs = h_entries(env.cfunc_entries) |
| h_extension_types = h_entries(env.c_class_entries) |
| if (h_types or h_vars or h_funcs or h_extension_types): |
| result.h_file = replace_suffix(result.c_file, ".h") |
| h_code = Code.CCodeWriter() |
| Code.GlobalState(h_code, self) |
| 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_guard = Naming.h_guard_prefix + self.api_name(env) |
| h_code.put_h_guard(h_guard) |
| h_code.putln("") |
| 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) |
| 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("#if PY_MAJOR_VERSION < 3") |
| h_code.putln("PyMODINIT_FUNC init%s(void);" % env.module_name) |
| h_code.putln("#else") |
| h_code.putln("PyMODINIT_FUNC PyInit_%s(void);" % env.module_name) |
| 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, dll_linkage = "DL_IMPORT"))) |
| if i_code: |
| i_code.putln("cdef extern %s" % |
| entry.type.declaration_code(entry.cname, pyrex = 1)) |
| |
| def api_name(self, env): |
| return env.qualified_name.replace(".", "__") |
| |
| def generate_api_code(self, env, 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() |
| Code.GlobalState(h_code, self) |
| api_guard = Naming.api_guard_prefix + self.api_name(env) |
| h_code.put_h_guard(api_guard) |
| 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, entry.name) |
| h_code.putln("static %s = 0;" % type.declaration_code(cname)) |
| h_code.putln("#define %s %s" % (entry.name, cname)) |
| if api_vars: |
| h_code.putln("") |
| for entry in api_vars: |
| type = CPtrType(entry.type) |
| cname = env.mangle(Naming.varptr_prefix, 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]) |
| h_code.put(UtilityCode.load_as_string("ModuleImport", "ImportExport.c")[1]) |
| 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")[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 = __Pyx_ImportModule("%s");' % env.qualified_name) |
| h_code.putln("if (!module) goto bad;") |
| for entry in api_funcs: |
| cname = env.mangle(Naming.func_prefix, entry.name) |
| sig = entry.type.signature_string() |
| h_code.putln( |
| 'if (__Pyx_ImportFunction(module, "%s", (void (**)(void))&%s, "%s") < 0) goto bad;' |
| % (entry.name, cname, sig)) |
| for entry in api_vars: |
| cname = env.mangle(Naming.varptr_prefix, entry.name) |
| sig = entry.type.declaration_code("") |
| h_code.putln( |
| 'if (__Pyx_ImportVoidPtr(module, "%s", (void **)&%s, "%s") < 0) goto bad;' |
| % (entry.name, cname, sig)) |
| h_code.putln("Py_DECREF(module); module = 0;") |
| for entry in api_extension_types: |
| self.generate_type_import_call( |
| entry.type, h_code, |
| "if (!%s) goto bad;" % entry.type.typeptr_cname) |
| 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: |
| emit_linenums = False |
| rootwriter = Annotate.AnnotationCCodeWriter() |
| else: |
| emit_linenums = options.emit_linenums |
| rootwriter = Code.CCodeWriter(emit_linenums=emit_linenums, c_line_in_traceback=options.c_line_in_traceback) |
| globalstate = Code.GlobalState(rootwriter, self, emit_linenums, options.common_utility_include_dir) |
| globalstate.initialize_main_c_code() |
| h_code = globalstate['h_code'] |
| |
| self.generate_module_preamble(env, modules, 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) |
| code.putln("int %s%s = 0;" % (Naming.module_is_main, self.full_module_name.replace('.', '__'))) |
| code.putln("") |
| code.putln("/* Implementation of '%s' */" % env.qualified_name) |
| |
| code = globalstate['all_the_rest'] |
| |
| self.generate_cached_builtins_decls(env, code) |
| self.generate_lambda_definitions(env, code) |
| # generate normal variable and function definitions |
| self.generate_variable_definitions(env, code) |
| self.body.generate_function_definitions(env, code) |
| code.mark_pos(None) |
| self.generate_typeobj_definitions(env, code) |
| self.generate_method_table(env, code) |
| if env.has_import_star: |
| self.generate_import_star(env, code) |
| self.generate_pymoduledef_struct(env, code) |
| |
| # init_globals is inserted before this |
| self.generate_module_init_func(modules[:-1], env, globalstate['init_module']) |
| self.generate_module_cleanup_func(env, globalstate['cleanup_module']) |
| if Options.embed: |
| self.generate_main_method(env, globalstate['main_method']) |
| self.generate_filename_table(globalstate['filename_table']) |
| |
| self.generate_declarations_for_modules(env, modules, globalstate) |
| h_code.write('\n') |
| |
| for utilcode in env.utility_code_list[:]: |
| globalstate.use_utility_code(utilcode) |
| globalstate.finalize_main_c_code() |
| |
| f = open_new_file(result.c_file) |
| try: |
| rootwriter.copyto(f) |
| finally: |
| f.close() |
| result.c_file_generated = 1 |
| if options.gdb_debug: |
| self._serialize_lineno_map(env, rootwriter) |
| if Options.annotate or options.annotate: |
| self._generate_annotations(rootwriter, result) |
| |
| def _generate_annotations(self, rootwriter, result): |
| self.annotate(rootwriter) |
| rootwriter.save_annotation(result.main_source_file, result.c_file) |
| |
| # 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, e: |
| import errno |
| if e.errno != errno.EEXIST: |
| raise |
| rootwriter.save_annotation(source_file, target_file) |
| |
| def _serialize_lineno_map(self, env, ccodewriter): |
| tb = env.context.gdb_debug_outputwriter |
| markers = ccodewriter.buffer.allmarkers() |
| |
| d = {} |
| for c_lineno, cython_lineno in enumerate(markers): |
| if cython_lineno > 0: |
| d.setdefault(cython_lineno, []).append(c_lineno + 1) |
| |
| tb.start('LineNumberMapping') |
| for cython_lineno, c_linenos in sorted(d.iteritems()): |
| attrs = { |
| 'c_linenos': ' '.join(map(str, c_linenos)), |
| 'cython_lineno': str(cython_lineno), |
| } |
| tb.start('LineNumber', attrs) |
| tb.end('LineNumber') |
| 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 Cython.Compiler.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) |
| for module in modules: |
| definition = module is env |
| if definition: |
| type_entries = module.type_entries |
| else: |
| type_entries = [] |
| for entry in module.type_entries: |
| if entry.defined_in_pxd: |
| type_entries.append(entry) |
| type_entries = [t for t in type_entries if t not in vtabslot_entries] |
| self.generate_type_header_code(type_entries, code) |
| for entry in vtabslot_list: |
| self.generate_objstruct_definition(entry.type, code) |
| self.generate_typeobj_predeclaration(entry, code) |
| for entry in vtab_list: |
| self.generate_typeobj_predeclaration(entry, code) |
| self.generate_exttype_vtable_struct(entry, code) |
| self.generate_exttype_vtabptr_declaration(entry, code) |
| self.generate_exttype_final_methods_declaration(entry, code) |
| |
| def generate_declarations_for_modules(self, env, modules, globalstate): |
| typecode = globalstate['type_declarations'] |
| typecode.putln("") |
| typecode.putln("/*--- Type declarations ---*/") |
| # This is to work around the fact that array.h isn't part of the C-API, |
| # but we need to declare it earlier than utility code. |
| if 'cpython.array' in [m.qualified_name for m in modules]: |
| typecode.putln('#ifndef _ARRAYARRAY_H') |
| typecode.putln('struct arrayobject;') |
| typecode.putln('typedef struct arrayobject arrayobject;') |
| typecode.putln('#endif') |
| vtab_list, vtabslot_list = self.sort_type_hierarchy(modules, env) |
| self.generate_type_definitions( |
| env, modules, vtab_list, vtabslot_list, typecode) |
| modulecode = globalstate['module_declarations'] |
| for module in modules: |
| defined_here = module is env |
| modulecode.putln("") |
| modulecode.putln("/* Module declarations from '%s' */" % module.qualified_name) |
| self.generate_c_class_declarations(module, modulecode, defined_here) |
| self.generate_cvariable_declarations(module, modulecode, defined_here) |
| self.generate_cfunction_declarations(module, modulecode, defined_here) |
| |
| def generate_module_preamble(self, env, cimported_modules, code): |
| code.putln("/* Generated by Cython %s */" % Version.watermark) |
| code.putln("") |
| code.putln("#define PY_SSIZE_T_CLEAN") |
| |
| # sizeof(PyLongObject.ob_digit[0]) may have been determined dynamically |
| # at compile time in CPython, in which case we can't know the correct |
| # storage size for an installed system. We can rely on it only if |
| # pyconfig.h defines it statically, i.e. if it was set by "configure". |
| # Once we include "Python.h", it will come up with its own idea about |
| # a suitable value, which may or may not match the real one. |
| code.putln("#ifndef CYTHON_USE_PYLONG_INTERNALS") |
| code.putln("#ifdef PYLONG_BITS_IN_DIGIT") |
| # assume it's an incorrect left-over |
| code.putln("#define CYTHON_USE_PYLONG_INTERNALS 0") |
| code.putln("#else") |
| code.putln('#include "pyconfig.h"') |
| code.putln("#ifdef PYLONG_BITS_IN_DIGIT") |
| code.putln("#define CYTHON_USE_PYLONG_INTERNALS 1") |
| code.putln("#else") |
| code.putln("#define CYTHON_USE_PYLONG_INTERNALS 0") |
| code.putln("#endif") |
| code.putln("#endif") |
| code.putln("#endif") |
| |
| for filename in env.python_include_files: |
| code.putln('#include "%s"' % filename) |
| 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 < 0x02040000") |
| code.putln(" #error Cython requires Python 2.4+.") |
| code.putln("#else") |
| code.globalstate["end"].putln("#endif /* Py_PYTHON_H */") |
| |
| from Cython import __version__ |
| code.putln('#define CYTHON_ABI "%s"' % __version__.replace('.', '_')) |
| |
| code.put(UtilityCode.load_as_string("CModulePreamble", "ModuleSetupCode.c")[1]) |
| |
| code.put(""" |
| #if PY_MAJOR_VERSION >= 3 |
| #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) |
| #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) |
| #else |
| """) |
| if Future.division in env.context.future_directives: |
| code.putln(" #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)") |
| code.putln(" #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)") |
| else: |
| code.putln(" #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y)") |
| code.putln(" #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y)") |
| code.putln("#endif") |
| |
| code.putln("") |
| self.generate_extern_c_macro_definition(code) |
| code.putln("") |
| |
| code.putln("#if defined(WIN32) || defined(MS_WINDOWS)") |
| code.putln("#define _USE_MATH_DEFINES") |
| code.putln("#endif") |
| code.putln("#include <math.h>") |
| |
| code.putln("#define %s" % Naming.h_guard_prefix + self.api_name(env)) |
| code.putln("#define %s" % Naming.api_guard_prefix + self.api_name(env)) |
| self.generate_includes(env, cimported_modules, code) |
| code.putln("") |
| code.putln("#ifdef PYREX_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')) |
| 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 0') |
| 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('') |
| code.putln('static PyObject *%s;' % 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;' % Naming.empty_tuple) |
| code.putln('static PyObject *%s;' % Naming.empty_bytes) |
| 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) |
| |
| 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_includes(self, env, cimported_modules, code): |
| includes = [] |
| for filename in env.include_files: |
| byte_decoded_filenname = str(filename) |
| if byte_decoded_filenname[0] == '<' and byte_decoded_filenname[-1] == '>': |
| code.putln('#include %s' % byte_decoded_filenname) |
| else: |
| code.putln('#include "%s"' % byte_decoded_filenname) |
| |
| code.putln_openmp("#include <omp.h>") |
| |
| def generate_filename_table(self, code): |
| code.putln("") |
| code.putln("static const char *%s[] = {" % Naming.filetable_cname) |
| if code.globalstate.filename_list: |
| for source_desc in code.globalstate.filename_list: |
| filename = os.path.basename(source_desc.get_filenametable_entry()) |
| escaped_filename = filename.replace("\\", "\\\\").replace('"', r'\"') |
| code.putln('"%s",' % escaped_filename) |
| else: |
| # Some C compilers don't like an empty array |
| code.putln("0") |
| code.putln("};") |
| |
| def generate_type_predeclarations(self, env, code): |
| pass |
| |
| def generate_type_header_code(self, type_entries, code): |
| # Generate definitions of structs/unions/enums/typedefs/objstructs. |
| #self.generate_gcc33_hack(env, code) # Is this still needed? |
| # Forward declarations |
| for entry in type_entries: |
| if not entry.in_cinclude: |
| #print "generate_type_header_code:", entry.name, repr(entry.type) ### |
| type = entry.type |
| if type.is_typedef: # Must test this first! |
| pass |
| elif type.is_struct_or_union or type.is_cpp_class: |
| self.generate_struct_union_predeclaration(entry, code) |
| elif type.is_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_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.declaration_code("") for T in type.templates])) |
| code.putln(self.sue_predeclaration(type, type.kind, type.cname)) |
| |
| def sue_header_footer(self, type, kind, name): |
| header = "%s %s {" % (kind, name) |
| footer = "};" |
| return header, footer |
| |
| def generate_struct_union_definition(self, entry, code): |
| code.mark_pos(entry.pos) |
| type = entry.type |
| scope = type.scope |
| if scope: |
| kind = type.kind |
| packed = type.is_struct and type.packed |
| if packed: |
| kind = "%s %s" % (type.kind, "__Pyx_PACKED") |
| code.globalstate.use_utility_code(packed_struct_utility_code) |
| header, footer = \ |
| self.sue_header_footer(type, kind, type.cname) |
| if packed: |
| code.putln("#if defined(__SUNPRO_C)") |
| code.putln(" #pragma pack(1)") |
| code.putln("#elif !defined(__GNUC__)") |
| code.putln(" #pragma pack(push, 1)") |
| code.putln("#endif") |
| code.putln(header) |
| var_entries = scope.var_entries |
| if not var_entries: |
| error(entry.pos, |
| "Empty struct or union definition not allowed outside a" |
| " 'cdef extern from' block") |
| for attr in var_entries: |
| code.putln( |
| "%s;" % |
| attr.type.declaration_code(attr.cname)) |
| code.putln(footer) |
| if packed: |
| code.putln("#if defined(__SUNPRO_C)") |
| code.putln(" #pragma pack()") |
| code.putln("#elif !defined(__GNUC__)") |
| code.putln(" #pragma pack(pop)") |
| code.putln("#endif") |
| |
| def generate_cpp_class_definition(self, entry, code): |
| code.mark_pos(entry.pos) |
| type = entry.type |
| scope = type.scope |
| if scope: |
| if type.templates: |
| code.putln("template <class %s>" % ", class ".join([T.declaration_code("") for T in type.templates])) |
| # Just let everything be public. |
| code.put("struct %s" % type.cname) |
| if type.base_classes: |
| base_class_decl = ", public ".join( |
| [base_class.declaration_code("") for base_class in type.base_classes]) |
| code.put(" : public %s" % base_class_decl) |
| code.putln(" {") |
| has_virtual_methods = False |
| has_destructor = False |
| for attr in scope.var_entries: |
| if attr.type.is_cfunction and attr.name != "<init>": |
| code.put("virtual ") |
| has_virtual_methods = True |
| if attr.cname[0] == '~': |
| has_destructor = True |
| code.putln( |
| "%s;" % |
| attr.type.declaration_code(attr.cname)) |
| if has_virtual_methods and not has_destructor: |
| code.put("virtual ~%s() { }" % type.cname) |
| code.putln("};") |
| |
| def generate_enum_definition(self, entry, code): |
| code.mark_pos(entry.pos) |
| type = entry.type |
| name = entry.cname or entry.name or "" |
| header, footer = \ |
| self.sue_header_footer(type, "enum", name) |
| code.putln(header) |
| enum_values = entry.enum_values |
| if not enum_values: |
| error(entry.pos, |
| "Empty enum definition not allowed outside a" |
| " 'cdef extern from' block") |
| else: |
| last_entry = enum_values[-1] |
| # this does not really generate code, just builds the result value |
| for value_entry in enum_values: |
| if value_entry.value_node is not None: |
| value_entry.value_node.generate_evaluation_code(code) |
| |
| for value_entry in enum_values: |
| if value_entry.value_node is None: |
| value_code = value_entry.cname |
| else: |
| value_code = ("%s = %s" % ( |
| value_entry.cname, |
| value_entry.value_node.result())) |
| if value_entry is not last_entry: |
| value_code += "," |
| code.putln(value_code) |
| code.putln(footer) |
| if entry.type.typedef_flag: |
| # Not pre-declared. |
| code.putln("typedef enum %s %s;" % (name, name)) |
| |
| def generate_typeobj_predeclaration(self, entry, code): |
| code.putln("") |
| name = entry.type.typeobj_cname |
| if name: |
| if entry.visibility == 'extern' and not entry.in_cinclude: |
| code.putln("%s %s %s;" % ( |
| Naming.extern_c_macro, |
| PyrexTypes.public_decl("PyTypeObject", "DL_IMPORT"), |
| name)) |
| elif entry.visibility == 'public': |
| code.putln("%s %s %s;" % ( |
| Naming.extern_c_macro, |
| PyrexTypes.public_decl("PyTypeObject", "DL_EXPORT"), |
| name)) |
| # ??? Do we really need the rest of this? ??? |
| #else: |
| # code.putln("static PyTypeObject %s;" % name) |
| |
| def generate_exttype_vtable_struct(self, entry, code): |
| if not entry.used: |
| return |
| |
| code.mark_pos(entry.pos) |
| # Generate struct declaration for an extension type's vtable. |
| type = entry.type |
| scope = type.scope |
| |
| self.specialize_fused_types(scope) |
| |
| if type.vtabstruct_cname: |
| code.putln("") |
| code.putln( |
| "struct %s {" % |
| type.vtabstruct_cname) |
| if type.base_type and type.base_type.vtabstruct_cname: |
| code.putln("struct %s %s;" % ( |
| type.base_type.vtabstruct_cname, |
| Naming.obj_base_cname)) |
| for method_entry in scope.cfunc_entries: |
| if not method_entry.is_inherited: |
| code.putln( |
| "%s;" % method_entry.type.declaration_code("(*%s)" % method_entry.cname)) |
| code.putln( |
| "};") |
| |
| def generate_exttype_vtabptr_declaration(self, entry, code): |
| if not entry.used: |
| return |
| |
| code.mark_pos(entry.pos) |
| # Generate declaration of pointer to an extension type's vtable. |
| type = entry.type |
| if type.vtabptr_cname: |
| code.putln("static struct %s *%s;" % ( |
| type.vtabstruct_cname, |
| type.vtabptr_cname)) |
| |
| def generate_exttype_final_methods_declaration(self, entry, code): |
| if not entry.used: |
| return |
| |
| code.mark_pos(entry.pos) |
| # Generate final methods prototypes |
| type = entry.type |
| for method_entry in entry.type.scope.cfunc_entries: |
| if not method_entry.is_inherited and method_entry.final_func_cname: |
| declaration = method_entry.type.declaration_code( |
| method_entry.final_func_cname) |
| modifiers = code.build_function_modifiers(method_entry.func_modifiers) |
| code.putln("static %s%s;" % (modifiers, declaration)) |
| |
| def generate_objstruct_predeclaration(self, type, code): |
| if not type.scope: |
| return |
| code.putln(self.sue_predeclaration(type, "struct", type.objstruct_cname)) |
| |
| def generate_objstruct_definition(self, type, code): |
| code.mark_pos(type.pos) |
| # Generate object struct definition for an |
| # extension type. |
| if not type.scope: |
| return # Forward declared but never defined |
| header, footer = \ |
| self.sue_header_footer(type, "struct", type.objstruct_cname) |
| code.putln(header) |
| base_type = type.base_type |
| if base_type: |
| basestruct_cname = base_type.objstruct_cname |
| if basestruct_cname == "PyTypeObject": |
| # User-defined subclasses of type are heap allocated. |
| basestruct_cname = "PyHeapTypeObject" |
| code.putln( |
| "%s%s %s;" % ( |
| ("struct ", "")[base_type.typedef_flag], |
| basestruct_cname, |
| Naming.obj_base_cname)) |
| else: |
| code.putln( |
| "PyObject_HEAD") |
| if type.vtabslot_cname and not (type.base_type and type.base_type.vtabslot_cname): |
| code.putln( |
| "struct %s *%s;" % ( |
| type.vtabstruct_cname, |
| type.vtabslot_cname)) |
| for attr in type.scope.var_entries: |
| if attr.is_declared_generic: |
| attr_type = py_object_type |
| else: |
| attr_type = attr.type |
| code.putln( |
| "%s;" % |
| attr_type.declaration_code(attr.cname)) |
| code.putln(footer) |
| if type.objtypedef_cname is not None: |
| # Only for exposing public typedef name. |
| code.putln("typedef struct %s %s;" % (type.objstruct_cname, type.objtypedef_cname)) |
| |
| def generate_c_class_declarations(self, env, code, definition): |
| for entry in env.c_class_entries: |
| if definition or entry.defined_in_pxd: |
| code.putln("static PyTypeObject *%s = 0;" % |
| entry.type.typeptr_cname) |
| |
| def generate_cvariable_declarations(self, env, code, definition): |
| if env.is_cython_builtin: |
| return |
| for entry in env.var_entries: |
| if (entry.in_cinclude or entry.in_closure or |
| (entry.visibility == 'private' and |
| not (entry.defined_in_pxd or entry.used))): |
| continue |
| |
| storage_class = None |
| dll_linkage = None |
| cname = None |
| init = None |
| |
| if entry.visibility == 'extern': |
| storage_class = Naming.extern_c_macro |
| dll_linkage = "DL_IMPORT" |
| elif entry.visibility == 'public': |
| storage_class = Naming.extern_c_macro |
| if definition: |
| dll_linkage = "DL_EXPORT" |
| else: |
| dll_linkage = "DL_IMPORT" |
| elif entry.visibility == 'private': |
| storage_class = "static" |
| dll_linkage = None |
| if entry.init is not None: |
| init = entry.type.literal_code(entry.init) |
| type = entry.type |
| cname = entry.cname |
| |
| if entry.defined_in_pxd and not definition: |
| storage_class = "static" |
| dll_linkage = None |
| type = CPtrType(type) |
| cname = env.mangle(Naming.varptr_prefix, entry.name) |
| init = 0 |
| |
| if storage_class: |
| code.put("%s " % storage_class) |
| code.put(type.declaration_code( |
| cname, dll_linkage = dll_linkage)) |
| if init is not None: |
| code.put_safe(" = %s" % init) |
| code.putln(";") |
| if entry.cname != cname: |
| code.putln("#define %s (*%s)" % (entry.cname, cname)) |
| |
| def generate_cfunction_declarations(self, env, code, definition): |
| for entry in env.cfunc_entries: |
| if entry.used or (entry.visibility == 'public' or entry.api): |
| generate_cfunction_declaration(entry, env, code, definition) |
| |
| def generate_variable_definitions(self, env, code): |
| for entry in env.var_entries: |
| if (not entry.in_cinclude and |
| entry.visibility == "public"): |
| code.put(entry.type.declaration_code(entry.cname)) |
| if entry.init is not None: |
| init = entry.type.literal_code(entry.init) |
| code.put_safe(" = %s" % init) |
| code.putln(";") |
| |
| def generate_typeobj_definitions(self, env, code): |
| full_module_name = env.qualified_name |
| for entry in env.c_class_entries: |
| #print "generate_typeobj_definitions:", entry.name |
| #print "...visibility =", entry.visibility |
| if entry.visibility != 'extern': |
| type = entry.type |
| scope = type.scope |
| if scope: # could be None if there was an error |
| 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(["__getitem__"]): |
| self.generate_getitem_int_function(scope, code) |
| if scope.defines_any(["__setitem__", "__delitem__"]): |
| self.generate_ass_subscript_function(scope, code) |
| if scope.defines_any(["__getslice__", "__setslice__", "__delslice__"]): |
| warning(self.pos, "__getslice__, __setslice__, and __delslice__ are not supported by Python 3, use __getitem__, __setitem__, and __delitem__ instead", 1) |
| code.putln("#if PY_MAJOR_VERSION >= 3") |
| code.putln("#error __getslice__, __setslice__, and __delslice__ not supported in Python 3.") |
| code.putln("#endif") |
| if scope.defines_any(["__setslice__", "__delslice__"]): |
| self.generate_ass_slice_function(scope, code) |
| if scope.defines_any(["__getattr__","__getattribute__"]): |
| self.generate_getattro_function(scope, code) |
| if scope.defines_any(["__setattr__", "__delattr__"]): |
| self.generate_setattro_function(scope, code) |
| if scope.defines_any(["__get__"]): |
| self.generate_descr_get_function(scope, code) |
| if scope.defines_any(["__set__", "__delete__"]): |
| self.generate_descr_set_function(scope, code) |
| self.generate_property_accessors(scope, code) |
| self.generate_method_table(scope, code) |
| self.generate_getset_table(scope, code) |
| self.generate_typeobj_definition(full_module_name, entry, code) |
| |
| def generate_exttype_vtable(self, scope, code): |
| # Generate the definition of an extension type's vtable. |
| type = scope.parent_type |
| if type.vtable_cname: |
| code.putln("static struct %s %s;" % ( |
| type.vtabstruct_cname, |
| type.vtable_cname)) |
| |
| def generate_self_cast(self, scope, code): |
| type = scope.parent_type |
| code.putln( |
| "%s = (%s)o;" % ( |
| type.declaration_code("p"), |
| type.declaration_code(""))) |
| |
| def generate_new_function(self, scope, code, cclass_entry): |
| tp_slot = TypeSlots.ConstructorSlot("tp_new", '__new__') |
| slot_func = scope.mangle_internal("tp_new") |
| type = scope.parent_type |
| base_type = type.base_type |
| |
| have_entries, (py_attrs, py_buffers, memoryview_slices) = \ |
| scope.get_refcounted_entries() |
| is_final_type = scope.parent_type.is_final_type |
| if scope.is_internal: |
| # internal classes (should) never need None inits, normal zeroing will do |
| py_attrs = [] |
| cpp_class_attrs = [entry for entry in scope.var_entries |
| if entry.type.is_cpp_class] |
| |
| new_func_entry = scope.lookup_here("__new__") |
| if base_type or (new_func_entry and new_func_entry.is_special |
| and not new_func_entry.trivial_signature): |
| unused_marker = '' |
| else: |
| unused_marker = 'CYTHON_UNUSED ' |
| |
| if base_type: |
| freelist_size = 0 # not currently supported |
| else: |
| freelist_size = scope.directives.get('freelist', 0) |
| freelist_name = scope.mangle_internal(Naming.freelist_name) |
| freecount_name = scope.mangle_internal(Naming.freecount_name) |
| |
| decls = code.globalstate['decls'] |
| decls.putln("static PyObject *%s(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/" % |
| slot_func) |
| code.putln("") |
| if freelist_size: |
| code.putln("static %s[%d];" % ( |
| scope.parent_type.declaration_code(freelist_name), |
| freelist_size)) |
| code.putln("static int %s = 0;" % freecount_name) |
| code.putln("") |
| code.putln( |
| "static PyObject *%s(PyTypeObject *t, %sPyObject *a, %sPyObject *k) {" |
| % (slot_func, unused_marker, unused_marker)) |
| |
| need_self_cast = (type.vtabslot_cname or |
| (py_buffers or memoryview_slices or py_attrs) or |
| cpp_class_attrs) |
| if need_self_cast: |
| code.putln("%s;" % scope.parent_type.declaration_code("p")) |
| if base_type: |
| tp_new = TypeSlots.get_base_slot_function(scope, tp_slot) |
| if tp_new is None: |
| tp_new = "%s->tp_new" % base_type.typeptr_cname |
| code.putln("PyObject *o = %s(t, a, k);" % tp_new) |
| else: |
| code.putln("PyObject *o;") |
| if freelist_size: |
| code.globalstate.use_utility_code( |
| UtilityCode.load_cached("IncludeStringH", "StringTools.c")) |
| if is_final_type: |
| type_safety_check = '' |
| else: |
| type_safety_check = ' & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0)' |
| obj_struct = type.declaration_code("", deref=True) |
| code.putln("if (CYTHON_COMPILING_IN_CPYTHON && likely((%s > 0) & (t->tp_basicsize == sizeof(%s))%s)) {" % ( |
| freecount_name, obj_struct, type_safety_check)) |
| code.putln("o = (PyObject*)%s[--%s];" % ( |
| freelist_name, freecount_name)) |
| code.putln("memset(o, 0, sizeof(%s));" % obj_struct) |
| code.putln("(void) PyObject_INIT(o, t);") |
| if scope.needs_gc(): |
| code.putln("PyObject_GC_Track(o);") |
| code.putln("} else {") |
| if not is_final_type: |
| code.putln("if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {") |
| code.putln("o = (*t->tp_alloc)(t, 0);") |
| if not is_final_type: |
| code.putln("} else {") |
| code.putln("o = (PyObject *) PyBaseObject_Type.tp_new(t, %s, 0);" % Naming.empty_tuple) |
| code.putln("}") |
| code.putln("if (unlikely(!o)) return 0;") |
| if freelist_size and not base_type: |
| code.putln('}') |
| if need_self_cast: |
| code.putln("p = %s;" % type.cast_code("o")) |
| #if need_self_cast: |
| # self.generate_self_cast(scope, code) |
| 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.declaration_code(""))) |
| |
| for entry in py_attrs: |
| 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" |
| code.putln( |
| "if (unlikely(%s(%s) < 0)) {" % |
| (new_func_entry.func_cname, cinit_args)) |
| code.put_decref_clear("o", py_object_type, nanny=False) |
| code.putln( |
| "}") |
| code.putln( |
| "return o;") |
| 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 weakref_slot not in scope.var_entries: |
| weakref_slot = None |
| |
| _, (py_attrs, _, memoryview_slices) = scope.get_refcounted_entries() |
| cpp_class_attrs = [entry for entry in scope.var_entries |
| if entry.type.is_cpp_class] |
| |
| if py_attrs or cpp_class_attrs or memoryview_slices or weakref_slot: |
| self.generate_self_cast(scope, code) |
| |
| if not is_final_type: |
| # in Py3.4+, call tp_finalize() as early as possible |
| code.putln("#if PY_VERSION_HEX >= 0x030400a1") |
| if needs_gc: |
| finalised_check = '!_PyGC_FINALIZED(o)' |
| else: |
| finalised_check = ( |
| '(!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))') |
| code.putln("if (unlikely(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);") |
| |
| for entry in cpp_class_attrs: |
| code.putln("__Pyx_call_destructor(&p->%s);" % entry.cname) |
| |
| for entry in py_attrs: |
| code.put_xdecref_clear("p->%s" % entry.cname, entry.type, nanny=False, |
| clear_before_decref=True) |
| |
| for entry in memoryview_slices: |
| code.put_xdecref_memoryviewslice("p->%s" % entry.cname, |
| have_gil=True) |
| |
| if base_type: |
| if needs_gc: |
| # The base class deallocator probably expects this to be tracked, |
| # so undo the untracking above. |
| if base_type.scope and base_type.scope.needs_gc(): |
| code.putln("PyObject_GC_Track(o);") |
| else: |
| code.putln("#if CYTHON_COMPILING_IN_CPYTHON") |
| 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("++Py_REFCNT(o);") |
| code.putln("%s(o);" % entry.func_cname) |
| code.putln("--Py_REFCNT(o);") |
| code.putln("PyErr_Restore(etype, eval, etb);") |
| code.putln("}") |
| |
| def generate_traverse_function(self, scope, code, cclass_entry): |
| tp_slot = TypeSlots.GCDependentSlot("tp_traverse") |
| slot_func = scope.mangle_internal("tp_traverse") |
| base_type = scope.parent_type.base_type |
| if tp_slot.slot_code(scope) != slot_func: |
| return # never used |
| code.putln("") |
| code.putln( |
| "static int %s(PyObject *o, visitproc v, void *a) {" |
| % slot_func) |
| |
| have_entries, (py_attrs, py_buffers, memoryview_slices) = ( |
| scope.get_refcounted_entries(include_gc_simple=False)) |
| |
| if base_type or py_attrs: |
| code.putln("int e;") |
| |
| if py_attrs or py_buffers: |
| self.generate_self_cast(scope, code) |
| |
| if base_type: |
| # want to call it explicitly if possible so inlining can be performed |
| static_call = TypeSlots.get_base_slot_function(scope, tp_slot) |
| if static_call: |
| code.putln("e = %s(o, v, a); if (e) return e;" % static_call) |
| elif base_type.is_builtin_type: |
| base_cname = base_type.typeptr_cname |
| code.putln("if (!%s->tp_traverse); else { e = %s->tp_traverse(o,v,a); if (e) return e; }" % ( |
| base_cname, base_cname)) |
| else: |
| # This is an externally defined type. Calling through the |
| # cimported base type pointer directly interacts badly with |
| # the module cleanup, which may already have cleared it. |
| # In that case, fall back to traversing the type hierarchy. |
| base_cname = base_type.typeptr_cname |
| code.putln("e = ((likely(%s)) ? ((%s->tp_traverse) ? %s->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, %s)); if (e) return e;" % ( |
| base_cname, base_cname, base_cname, slot_func)) |
| code.globalstate.use_utility_code( |
| UtilityCode.load_cached("CallNextTpTraverse", "ExtensionTypes.c")) |
| |
| for entry in py_attrs: |
| var_code = "p->%s" % entry.cname |
| code.putln( |
| "if (%s) {" |
| % var_code) |
| if entry.type.is_extension_type: |
| var_code = "((PyObject*)%s)" % var_code |
| code.putln( |
| "e = (*v)(%s, a); if (e) return e;" |
| % var_code) |
| code.putln( |
| "}") |
| |
| # Traverse buffer exporting objects. |
| # Note: not traversing memoryview attributes of memoryview slices! |
| # When triggered by the GC, it would cause multiple visits (gc_refs |
| # subtractions which is not matched by its reference count!) |
| for entry in py_buffers: |
| cname = entry.cname + ".obj" |
| code.putln("if (p->%s) {" % cname) |
| code.putln( "e = (*v)(p->%s, a); if (e) return e;" % cname) |
| code.putln("}") |
| |
| code.putln( |
| "return 0;") |
| code.putln( |
| "}") |
| |
| def generate_clear_function(self, scope, code, cclass_entry): |
| tp_slot = TypeSlots.GCDependentSlot("tp_clear") |
| slot_func = scope.mangle_internal("tp_clear") |
| base_type = scope.parent_type.base_type |
| if tp_slot.slot_code(scope) != slot_func: |
| return # never used |
| |
| have_entries, (py_attrs, py_buffers, memoryview_slices) = ( |
| scope.get_refcounted_entries(include_gc_simple=False)) |
| |
| if py_attrs or py_buffers or base_type: |
| unused = '' |
| else: |
| unused = 'CYTHON_UNUSED ' |
| |
| code.putln("") |
| code.putln("static int %s(%sPyObject *o) {" % (slot_func, unused)) |
| |
| if py_attrs and Options.clear_to_none: |
| code.putln("PyObject* tmp;") |
| |
| if py_attrs or py_buffers: |
| self.generate_self_cast(scope, code) |
| |
| if base_type: |
| # want to call it explicitly if possible so inlining can be performed |
| static_call = TypeSlots.get_base_slot_function(scope, tp_slot) |
| if static_call: |
| code.putln("%s(o);" % static_call) |
| elif base_type.is_builtin_type: |
| base_cname = base_type.typeptr_cname |
| code.putln("if (!%s->tp_clear); else %s->tp_clear(o);" % ( |
| base_cname, base_cname)) |
| else: |
| # This is an externally defined type. Calling through the |
| # cimported base type pointer directly interacts badly with |
| # the module cleanup, which may already have cleared it. |
| # In that case, fall back to traversing the type hierarchy. |
| base_cname = base_type.typeptr_cname |
| code.putln("if (likely(%s)) { if (%s->tp_clear) %s->tp_clear(o); } else __Pyx_call_next_tp_clear(o, %s);" % ( |
| base_cname, base_cname, base_cname, slot_func)) |
| code.globalstate.use_utility_code( |
| UtilityCode.load_cached("CallNextTpClear", "ExtensionTypes.c")) |
| |
| if Options.clear_to_none: |
| for entry in py_attrs: |
| name = "p->%s" % entry.cname |
| code.putln("tmp = ((PyObject*)%s);" % name) |
| if entry.is_declared_generic: |
| code.put_init_to_py_none(name, py_object_type, nanny=False) |
| else: |
| code.put_init_to_py_none(name, entry.type, nanny=False) |
| code.putln("Py_XDECREF(tmp);") |
| else: |
| for entry in py_attrs: |
| code.putln("Py_CLEAR(p->%s);" % entry.cname) |
| |
| for entry in py_buffers: |
| # Note: shouldn't this call __Pyx_ReleaseBuffer ?? |
| code.putln("Py_CLEAR(p->%s.obj);" % entry.cname) |
| |
| if cclass_entry.cname == '__pyx_memoryviewslice': |
| code.putln("__PYX_XDEC_MEMVIEW(&p->from_slice, 1);") |
| |
| code.putln( |
| "return 0;") |
| code.putln( |
| "}") |
| |
| def generate_getitem_int_function(self, scope, code): |
| # This function is put into the sq_item slot when |
| # a __getitem__ method is present. It converts its |
| # argument to a Python integer and calls mp_subscript. |
| code.putln( |
| "static PyObject *%s(PyObject *o, Py_ssize_t i) {" % |
| scope.mangle_internal("sq_item")) |
| code.putln( |
| "PyObject *r;") |
| code.putln( |
| "PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;") |
| code.putln( |
| "r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);") |
| code.putln( |
| "Py_DECREF(x);") |
| code.putln( |
| "return r;") |
| code.putln( |
| "}") |
| |
| def generate_ass_subscript_function(self, scope, code): |
| # Setting and deleting an item are both done through |
| # the ass_subscript method, so we dispatch to user's __setitem__ |
| # or __delitem__, or raise an exception. |
| base_type = scope.parent_type.base_type |
| set_entry = scope.lookup_here("__setitem__") |
| del_entry = scope.lookup_here("__delitem__") |
| code.putln("") |
| code.putln( |
| "static int %s(PyObject *o, PyObject *i, PyObject *v) {" % |
| scope.mangle_internal("mp_ass_subscript")) |
| code.putln( |
| "if (v) {") |
| if set_entry: |
| code.putln( |
| "return %s(o, i, v);" % |
| set_entry.func_cname) |
| else: |
| self.generate_guarded_basetype_call( |
| base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code) |
| code.putln( |
| "PyErr_Format(PyExc_NotImplementedError,") |
| code.putln( |
| ' "Subscript assignment not supported by %.200s", Py_TYPE(o)->tp_name);') |
| code.putln( |
| "return -1;") |
| code.putln( |
| "}") |
| code.putln( |
| "else {") |
| if del_entry: |
| code.putln( |
| "return %s(o, i);" % |
| del_entry.func_cname) |
| else: |
| self.generate_guarded_basetype_call( |
| base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code) |
| code.putln( |
| "PyErr_Format(PyExc_NotImplementedError,") |
| code.putln( |
| ' "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);') |
| code.putln( |
| "return -1;") |
| code.putln( |
| "}") |
| code.putln( |
| "}") |
| |
| def generate_guarded_basetype_call( |
| self, base_type, substructure, slot, args, code): |
| if base_type: |
| base_tpname = base_type.typeptr_cname |
| if substructure: |
| code.putln( |
| "if (%s->%s && %s->%s->%s)" % ( |
| base_tpname, substructure, base_tpname, substructure, slot)) |
| code.putln( |
| " return %s->%s->%s(%s);" % ( |
| base_tpname, substructure, slot, args)) |
| else: |
| code.putln( |
| "if (%s->%s)" % ( |
| base_tpname, slot)) |
| code.putln( |
| " return %s->%s(%s);" % ( |
| base_tpname, slot, args)) |
| |
| def generate_ass_slice_function(self, scope, code): |
| # Setting and deleting a slice are both done through |
| # the ass_slice method, so we dispatch to user's __setslice__ |
| # or __delslice__, or raise an exception. |
| base_type = scope.parent_type.base_type |
| set_entry = scope.lookup_here("__setslice__") |
| del_entry = scope.lookup_here("__delslice__") |
| code.putln("") |
| code.putln( |
| "static int %s(PyObject *o, Py_ssize_t i, Py_ssize_t j, PyObject *v) {" % |
| scope.mangle_internal("sq_ass_slice")) |
| code.putln( |
| "if (v) {") |
| if set_entry: |
| code.putln( |
| "return %s(o, i, j, v);" % |
| set_entry.func_cname) |
| else: |
| self.generate_guarded_basetype_call( |
| base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code) |
| code.putln( |
| "PyErr_Format(PyExc_NotImplementedError,") |
| code.putln( |
| ' "2-element slice assignment not supported by %.200s", Py_TYPE(o)->tp_name);') |
| code.putln( |
| "return -1;") |
| code.putln( |
| "}") |
| code.putln( |
| "else {") |
| if del_entry: |
| code.putln( |
| "return %s(o, i, j);" % |
| del_entry.func_cname) |
| else: |
| self.generate_guarded_basetype_call( |
| base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code) |
| code.putln( |
| "PyErr_Format(PyExc_NotImplementedError,") |
| code.putln( |
| ' "2-element slice deletion not supported by %.200s", Py_TYPE(o)->tp_name);') |
| code.putln( |
| "return -1;") |
| code.putln( |
| "}") |
| code.putln( |
| "}") |
| |
| def generate_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,type=None): |
| # Recursive lookup |
| if type is None: |
| type = scope.parent_type |
| r = type.scope.lookup_here(n) |
| if r is None and \ |
| type.base_type is not None: |
| return lookup_here_or_base(n,type.base_type) |
| else: |
| return r |
| getattr_entry = lookup_here_or_base("__getattr__") |
| getattribute_entry = lookup_here_or_base("__getattribute__") |
| code.putln("") |
| code.putln( |
| "static PyObject *%s(PyObject *o, PyObject *n) {" |
| % scope.mangle_internal("tp_getattro")) |
| if getattribute_entry is not None: |
| code.putln( |
| "PyObject *v = %s(o, n);" % |
| getattribute_entry.func_cname) |
| else: |
| code.putln( |
| "PyObject *v = PyObject_GenericGetAttr(o, n);") |
| if getattr_entry is not None: |
| code.putln( |
| "if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) {") |
| code.putln( |
| "PyErr_Clear();") |
| code.putln( |
| "v = %s(o, n);" % |
| getattr_entry.func_cname) |
| code.putln( |
| "}") |
| code.putln( |
| "return v;") |
| code.putln( |
| "}") |
| |
| def generate_setattro_function(self, scope, code): |
| # Setting and deleting an attribute are both done through |
| # the setattro method, so we dispatch to user's __setattr__ |
| # or __delattr__ or fall back on PyObject_GenericSetAttr. |
| base_type = scope.parent_type.base_type |
| set_entry = scope.lookup_here("__setattr__") |
| del_entry = scope.lookup_here("__delattr__") |
| code.putln("") |
| code.putln( |
| "static int %s(PyObject *o, PyObject *n, PyObject *v) {" % |
| scope.mangle_internal("tp_setattro")) |
| code.putln( |
| "if (v) {") |
| if set_entry: |
| code.putln( |
| "return %s(o, n, v);" % |
| set_entry.func_cname) |
| else: |
| self.generate_guarded_basetype_call( |
| base_type, None, "tp_setattro", "o, n, v", code) |
| code.putln( |
| "return PyObject_GenericSetAttr(o, n, v);") |
| code.putln( |
| "}") |
| code.putln( |
| "else {") |
| if del_entry: |
| code.putln( |
| "return %s(o, n);" % |
| del_entry.func_cname) |
| else: |
| self.generate_guarded_basetype_call( |
| base_type, None, "tp_setattro", "o, n, v", code) |
| code.putln( |
| "return PyObject_GenericSetAttr(o, n, 0);") |
| code.putln( |
| "}") |
| code.putln( |
| "}") |
| |
| def generate_descr_get_function(self, scope, code): |
| # The __get__ function of a descriptor object can be |
| # called with NULL for the second or third arguments |
| # under some circumstances, so we replace them with |
| # None in that case. |
| user_get_entry = scope.lookup_here("__get__") |
| code.putln("") |
| code.putln( |
| "static PyObject *%s(PyObject *o, PyObject *i, PyObject *c) {" % |
| scope.mangle_internal("tp_descr_get")) |
| code.putln( |
| "PyObject *r = 0;") |
| code.putln( |
| "if (!i) i = Py_None;") |
| code.putln( |
| "if (!c) c = Py_None;") |
| #code.put_incref("i", py_object_type) |
| #code.put_incref("c", py_object_type) |
| code.putln( |
| "r = %s(o, i, c);" % |
| user_get_entry.func_cname) |
| #code.put_decref("i", py_object_type) |
| #code.put_decref("c", py_object_type) |
| code.putln( |
| "return r;") |
| code.putln( |
| "}") |
| |
| def generate_descr_set_function(self, scope, code): |
| # Setting and deleting are both done through the __set__ |
| # method of a descriptor, so we dispatch to user's __set__ |
| # or __delete__ or raise an exception. |
| base_type = scope.parent_type.base_type |
| user_set_entry = scope.lookup_here("__set__") |
| user_del_entry = scope.lookup_here("__delete__") |
| code.putln("") |
| code.putln( |
| "static int %s(PyObject *o, PyObject *i, PyObject *v) {" % |
| scope.mangle_internal("tp_descr_set")) |
| code.putln( |
| "if (v) {") |
| if user_set_entry: |
| code.putln( |
| "return %s(o, i, v);" % |
| user_set_entry.func_cname) |
| else: |
| self.generate_guarded_basetype_call( |
| base_type, None, "tp_descr_set", "o, i, v", code) |
| code.putln( |
| 'PyErr_SetString(PyExc_NotImplementedError, "__set__");') |
| code.putln( |
| "return -1;") |
| code.putln( |
| "}") |
| code.putln( |
| "else {") |
| if user_del_entry: |
| code.putln( |
| "return %s(o, i);" % |
| user_del_entry.func_cname) |
| else: |
| self.generate_guarded_basetype_call( |
| base_type, None, "tp_descr_set", "o, i, v", code) |
| code.putln( |
| 'PyErr_SetString(PyExc_NotImplementedError, "__delete__");') |
| code.putln( |
| "return -1;") |
| code.putln( |
| "}") |
| code.putln( |
| "}") |
| |
| def generate_property_accessors(self, cclass_scope, code): |
| for entry in cclass_scope.property_entries: |
| property_scope = entry.scope |
| if property_scope.defines_any(["__get__"]): |
| self.generate_property_get_function(entry, code) |
| if property_scope.defines_any(["__set__", "__del__"]): |
| self.generate_property_set_function(entry, code) |
| |
| def generate_property_get_function(self, property_entry, code): |
| property_scope = property_entry.scope |
| property_entry.getter_cname = property_scope.parent_scope.mangle( |
| Naming.prop_get_prefix, property_entry.name) |
| get_entry = property_scope.lookup_here("__get__") |
| code.putln("") |
| code.putln( |
| "static PyObject *%s(PyObject *o, CYTHON_UNUSED void *x) {" % |
| property_entry.getter_cname) |
| code.putln( |
| "return %s(o);" % |
| get_entry.func_cname) |
| code.putln( |
| "}") |
| |
| def generate_property_set_function(self, property_entry, code): |
| property_scope = property_entry.scope |
| property_entry.setter_cname = property_scope.parent_scope.mangle( |
| Naming.prop_set_prefix, property_entry.name) |
| set_entry = property_scope.lookup_here("__set__") |
| del_entry = property_scope.lookup_here("__del__") |
| code.putln("") |
| code.putln( |
| "static int %s(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {" % |
| property_entry.setter_cname) |
| code.putln( |
| "if (v) {") |
| if set_entry: |
| code.putln( |
| "return %s(o, v);" % |
| set_entry.func_cname) |
| else: |
| code.putln( |
| 'PyErr_SetString(PyExc_NotImplementedError, "__set__");') |
| code.putln( |
| "return -1;") |
| code.putln( |
| "}") |
| code.putln( |
| "else {") |
| if del_entry: |
| code.putln( |
| "return %s(o);" % |
| del_entry.func_cname) |
| else: |
| code.putln( |
| 'PyErr_SetString(PyExc_NotImplementedError, "__del__");') |
| code.putln( |
| "return -1;") |
| code.putln( |
| "}") |
| code.putln( |
| "}") |
| |
| def generate_typeobj_definition(self, modname, entry, code): |
| type = entry.type |
| scope = type.scope |
| for suite in TypeSlots.substructures: |
| suite.generate_substructure(scope, code) |
| code.putln("") |
| if entry.visibility == 'public': |
| header = "DL_EXPORT(PyTypeObject) %s = {" |
| else: |
| header = "static PyTypeObject %s = {" |
| #code.putln(header % scope.parent_type.typeobj_cname) |
| code.putln(header % type.typeobj_cname) |
| code.putln( |
| "PyVarObject_HEAD_INIT(0, 0)") |
| code.putln( |
| '__Pyx_NAMESTR("%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("") |
| code.putln( |
| "static PyMethodDef %s[] = {" % |
| env.method_table_cname) |
| for entry in env.pyfunc_entries: |
| if not entry.fused_cfunction: |
| code.put_pymethoddef(entry, ",") |
| code.putln( |
| "{0, 0, 0, 0}") |
| code.putln( |
| "};") |
| |
| def generate_getset_table(self, env, code): |
| if env.property_entries: |
| code.putln("") |
| code.putln( |
| "static struct PyGetSetDef %s[] = {" % |
| env.getset_table_cname) |
| for entry in env.property_entries: |
| if entry.doc: |
| doc_code = "__Pyx_DOCSTR(%s)" % code.get_string_const(entry.doc) |
| else: |
| doc_code = "0" |
| code.putln( |
| '{(char *)"%s", %s, %s, %s, 0},' % ( |
| entry.name, |
| entry.getter_cname or "0", |
| entry.setter_cname or "0", |
| doc_code)) |
| code.putln( |
| "{0, 0, 0, 0, 0}") |
| code.putln( |
| "};") |
| |
| def generate_import_star(self, env, code): |
| env.use_utility_code(streq_utility_code) |
| code.putln() |
| code.putln("static char* %s_type_names[] = {" % Naming.import_star) |
| for name, entry in sorted(env.entries.items()): |
| if entry.is_type: |
| code.putln('"%s",' % name) |
| code.putln("0") |
| 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("char** type_name = %s_type_names;" % Naming.import_star) |
| 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" |
| for name, entry in env.entries.items(): |
| if entry.is_cglobal and entry.used: |
| 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.from_py_function: |
| rhs = "%s(o)" % entry.type.from_py_function |
| if entry.type.is_enum: |
| rhs = PyrexTypes.typecast(entry.type, PyrexTypes.c_long_type, rhs) |
| code.putln("%s = %s; if (%s) %s;" % ( |
| entry.cname, |
| rhs, |
| entry.type.error_condition(entry.cname), |
| code.error_goto(entry.pos))) |
| 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(import_star_utility_code) |
| code.exit_cfunc_scope() # done with labels |
| |
| def generate_module_init_func(self, imported_modules, env, code): |
| code.enter_cfunc_scope() |
| code.putln("") |
| header2 = "PyMODINIT_FUNC init%s(void)" % env.module_name |
| header3 = "PyMODINIT_FUNC PyInit_%s(void)" % env.module_name |
| code.putln("#if PY_MAJOR_VERSION < 3") |
| code.putln("%s; /*proto*/" % header2) |
| code.putln(header2) |
| code.putln("#else") |
| code.putln("%s; /*proto*/" % header3) |
| code.putln(header3) |
| code.putln("#endif") |
| code.putln("{") |
| tempdecl_code = code.insertion_point() |
| |
| code.put_declare_refcount_context() |
| code.putln("#if CYTHON_REFNANNY") |
| code.putln("__Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"refnanny\");") |
| code.putln("if (!__Pyx_RefNanny) {") |
| code.putln(" PyErr_Clear();") |
| code.putln(" __Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"Cython.Runtime.refnanny\");") |
| code.putln(" if (!__Pyx_RefNanny)") |
| code.putln(" Py_FatalError(\"failed to import 'refnanny' module\");") |
| code.putln("}") |
| code.putln("#endif") |
| code.put_setup_refcount_context(header3) |
| |
| env.use_utility_code(UtilityCode.load("CheckBinaryVersion", "ModuleSetupCode.c")) |
| code.putln("if ( __Pyx_check_binary_version() < 0) %s" % code.error_goto(self.pos)) |
| |
| code.putln("%s = PyTuple_New(0); %s" % (Naming.empty_tuple, code.error_goto_if_null(Naming.empty_tuple, self.pos))) |
| code.putln("%s = PyBytes_FromStringAndSize(\"\", 0); %s" % (Naming.empty_bytes, code.error_goto_if_null(Naming.empty_bytes, self.pos))) |
| |
| code.putln("#ifdef __Pyx_CyFunction_USED") |
| code.putln("if (__Pyx_CyFunction_init() < 0) %s" % code.error_goto(self.pos)) |
| code.putln("#endif") |
| |
| code.putln("#ifdef __Pyx_FusedFunction_USED") |
| code.putln("if (__pyx_FusedFunction_init() < 0) %s" % code.error_goto(self.pos)) |
| code.putln("#endif") |
| |
| code.putln("#ifdef __Pyx_Generator_USED") |
| code.putln("if (__pyx_Generator_init() < 0) %s" % code.error_goto(self.pos)) |
| code.putln("#endif") |
| |
| code.putln("/*--- Library function declarations ---*/") |
| env.generate_library_function_declarations(code) |
| |
| code.putln("/*--- Threads initialization code ---*/") |
| code.putln("#if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS") |
| code.putln("#ifdef WITH_THREAD /* Python build with threading support? */") |
| code.putln("PyEval_InitThreads();") |
| code.putln("#endif") |
| code.putln("#endif") |
| |
| code.putln("/*--- Module creation code ---*/") |
| self.generate_module_creation_code(env, code) |
| |
| code.putln("/*--- Initialize various global constants etc. ---*/") |
| code.putln(code.error_goto_if_neg("__Pyx_InitGlobals()", self.pos)) |
| |
| code.putln("#if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)") |
| code.putln("if (__Pyx_init_sys_getdefaultencoding_params() < 0) %s" % code.error_goto(self.pos)) |
| code.putln("#endif") |
| |
| __main__name = code.globalstate.get_py_string_const( |
| EncodedString("__main__"), identifier=True) |
| code.putln("if (%s%s) {" % (Naming.module_is_main, self.full_module_name.replace('.', '__'))) |
| code.putln( |
| 'if (__Pyx_SetAttrString(%s, "__name__", %s) < 0) %s;' % ( |
| env.module_cname, |
| __main__name.cname, |
| code.error_goto(self.pos))) |
| 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(code.error_goto_if_neg("__Pyx_InitCachedBuiltins()", self.pos)) |
| |
| code.putln("/*--- Constants init code ---*/") |
| code.putln(code.error_goto_if_neg("__Pyx_InitCachedConstants()", self.pos)) |
| |
| code.putln("/*--- Global init code ---*/") |
| self.generate_global_init_code(env, code) |
| |
| code.putln("/*--- Variable export code ---*/") |
| self.generate_c_variable_export_code(env, code) |
| |
| code.putln("/*--- Function export code ---*/") |
| self.generate_c_function_export_code(env, code) |
| |
| code.putln("/*--- Type init code ---*/") |
| self.generate_type_init_code(env, code) |
| |
| code.putln("/*--- Type import code ---*/") |
| for module in imported_modules: |
| self.generate_type_import_code_for_module(module, env, code) |
| |
| code.putln("/*--- Variable import code ---*/") |
| for module in imported_modules: |
| self.generate_c_variable_import_code_for_module(module, env, code) |
| |
| code.putln("/*--- Function import code ---*/") |
| for module in imported_modules: |
| self.specialize_fused_types(module) |
| self.generate_c_function_import_code_for_module(module, env, code) |
| |
| code.putln("/*--- Execution code ---*/") |
| code.mark_pos(None) |
| |
| self.body.generate_execution_code(code) |
| |
| 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.put_add_traceback("init %s" % env.qualified_name) |
| env.use_utility_code(Nodes.traceback_utility_code) |
| code.put_decref_clear(env.module_cname, py_object_type, nanny=False) |
| 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 PY_MAJOR_VERSION < 3") |
| code.putln("return;") |
| code.putln("#else") |
| code.putln("return %s;" % env.module_cname) |
| code.putln("#endif") |
| code.putln('}') |
| |
| tempdecl_code.put_temp_declarations(code.funcstate) |
| |
| code.exit_cfunc_scope() |
| |
| 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 (__Pyx_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))) |
| |
| if env.is_package: |
| # set __path__ to mark the module as package |
| 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 (__Pyx_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) |
| |
| 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 |
| 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)) |
| |
| # 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) |
| 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)) |
| code.putln('#if CYTHON_COMPILING_IN_PYPY') |
| code.putln('Py_CLEAR(%s);' % Naming.builtins_cname) |
| code.putln('#endif') |
| code.put_decref_clear(env.module_dict_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 |
| 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 generate_pymoduledef_struct(self, env, code): |
| if env.doc: |
| doc = "__Pyx_DOCSTR(%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("static struct PyModuleDef %s = {" % Naming.pymoduledef_cname) |
| code.putln("#if PY_VERSION_HEX < 0x03020000") |
| # fix C compiler warnings due to missing initialisers |
| code.putln(" { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },") |
| code.putln("#else") |
| code.putln(" PyModuleDef_HEAD_INIT,") |
| code.putln("#endif") |
| code.putln(' __Pyx_NAMESTR("%s"),' % env.module_name) |
| code.putln(" %s, /* m_doc */" % doc) |
| code.putln(" -1, /* m_size */") |
| code.putln(" %s /* m_methods */," % env.method_table_cname) |
| code.putln(" NULL, /* m_reload */") |
| 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, code): |
| # Generate code to create the module object and |
| # install the builtins. |
| if env.doc: |
| doc = "__Pyx_DOCSTR(%s)" % code.get_string_const(env.doc) |
| else: |
| doc = "0" |
| code.putln("#if PY_MAJOR_VERSION < 3") |
| code.putln( |
| '%s = Py_InitModule4(__Pyx_NAMESTR("%s"), %s, %s, 0, PYTHON_API_VERSION); Py_XINCREF(%s);' % ( |
| env.module_cname, |
| env.module_name, |
| env.method_table_cname, |
| doc, |
| env.module_cname)) |
| code.putln("#else") |
| code.putln( |
| "%s = PyModule_Create(&%s);" % ( |
| env.module_cname, |
| Naming.pymoduledef_cname)) |
| code.putln("#endif") |
| code.putln(code.error_goto_if_null(env.module_cname, self.pos)) |
| code.putln( |
| "%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_NAMESTR(__Pyx_BUILTIN_MODULE_NAME)); %s' % ( |
| Naming.builtins_cname, |
| code.error_goto_if_null(Naming.builtins_cname, self.pos))) |
| code.putln('#if CYTHON_COMPILING_IN_PYPY') |
| code.putln('Py_INCREF(%s);' % Naming.builtins_cname) |
| code.putln('#endif') |
| code.putln( |
| 'if (__Pyx_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(__Pyx_NAMESTR("%s")); %s' % ( |
| Naming.preimport_cname, |
| Options.pre_import, |
| code.error_goto_if_null(Naming.preimport_cname, self.pos))) |
| |
| 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_c_variable_export_code(self, env, code): |
| # Generate code to create PyCFunction wrappers for exported C functions. |
| entries = [] |
| for entry in env.var_entries: |
| if (entry.api |
| or entry.defined_in_pxd |
| or (Options.cimport_from_pyx and not entry.visibility == 'extern')): |
| entries.append(entry) |
| if entries: |
| env.use_utility_code(UtilityCode.load_cached("VoidPtrExport", "ImportExport.c")) |
| for entry in entries: |
| signature = entry.type.declaration_code("") |
| name = code.intern_identifier(entry.name) |
| code.putln('if (__Pyx_ExportVoidPtr(%s, (void *)&%s, "%s") < 0) %s' % ( |
| name, entry.cname, signature, |
| code.error_goto(self.pos))) |
| |
| def generate_c_function_export_code(self, env, code): |
| # Generate code to create PyCFunction wrappers for exported C functions. |
| entries = [] |
| for entry in env.cfunc_entries: |
| if (entry.api |
| or entry.defined_in_pxd |
| or (Options.cimport_from_pyx and not entry.visibility == 'extern')): |
| entries.append(entry) |
| if entries: |
| env.use_utility_code( |
| UtilityCode.load_cached("FunctionExport", "ImportExport.c")) |
| 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 module.c_class_entries: |
| if entry.defined_in_pxd: |
| self.generate_type_import_code(env, entry.type, entry.pos, code) |
| |
| 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("ModuleImport", "ImportExport.c")) |
| env.use_utility_code( |
| UtilityCode.load_cached("VoidPtrImport", "ImportExport.c")) |
| temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True) |
| code.putln( |
| '%s = __Pyx_ImportModule("%s"); if (!%s) %s' % ( |
| temp, |
| module.qualified_name, |
| temp, |
| code.error_goto(self.pos))) |
| for entry in entries: |
| if env is module: |
| cname = entry.cname |
| else: |
| cname = module.mangle(Naming.varptr_prefix, entry.name) |
| signature = entry.type.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("Py_DECREF(%s); %s = 0;" % (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("ModuleImport", "ImportExport.c")) |
| env.use_utility_code( |
| UtilityCode.load_cached("FunctionImport", "ImportExport.c")) |
| temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True) |
| code.putln( |
| '%s = __Pyx_ImportModule("%s"); if (!%s) %s' % ( |
| temp, |
| module.qualified_name, |
| temp, |
| 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.putln("Py_DECREF(%s); %s = 0;" % (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. |
| for entry in env.c_class_entries: |
| if entry.visibility == 'extern' and not entry.utility_code_definition: |
| self.generate_type_import_code(env, entry.type, entry.pos, code) |
| else: |
| self.generate_base_type_import_code(env, entry, code) |
| self.generate_exttype_vtable_init_code(entry, code) |
| self.generate_type_ready_code(env, entry, code) |
| self.generate_typeptr_assignment_code(entry, code) |
| |
| def generate_base_type_import_code(self, env, entry, code): |
| 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) |
| |
| def generate_type_import_code(self, env, type, pos, code): |
| # 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 |
| env.use_utility_code(UtilityCode.load_cached("TypeImport", "ImportExport.c")) |
| self.generate_type_import_call(type, code, |
| code.error_goto_if_null(type.typeptr_cname, 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) |
| |
| py3_type_name_map = {'str' : 'bytes', 'unicode' : 'str'} |
| |
| def generate_type_import_call(self, type, code, error_code): |
| 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 |
| 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] |
| |
| code.put('%s = __Pyx_ImportType(%s,' % ( |
| type.typeptr_cname, |
| 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 CYTHON_COMPILING_IN_PYPY") |
| 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('%i); %s' % ( |
| not type.is_external or type.is_subclassed, |
| error_code)) |
| |
| def generate_type_ready_code(self, env, entry, code): |
| # Generate a call to PyType_Ready for an extension |
| # type defined in this module. |
| type = entry.type |
| typeobj_cname = type.typeobj_cname |
| scope = type.scope |
| if scope: # could be None if there was an error |
| if entry.visibility != 'extern': |
| for slot in TypeSlots.slot_table: |
| slot.generate_dynamic_init_code(scope, code) |
| code.putln( |
| "if (PyType_Ready(&%s) < 0) %s" % ( |
| typeobj_cname, |
| code.error_goto(entry.pos))) |
| # Don't inherit tp_print from builtin types, restoring the |
| # behavior of using tp_repr or tp_str instead. |
| code.putln("%s.tp_print = 0;" % typeobj_cname) |
| # Fix special method docstrings. This is a bit of a hack, but |
| # unless we let PyType_Ready create the slot wrappers we have |
| # a significant performance hit. (See trac #561.) |
| for func in entry.type.scope.pyfunc_entries: |
| is_buffer = func.name in ('__getbuffer__', |
| '__releasebuffer__') |
| if (func.is_special and Options.docstrings and |
| func.wrapperbase_cname and not is_buffer): |
| slot = TypeSlots.method_name_to_slot[func.name] |
| preprocessor_guard = slot.preprocessor_guard_code() |
| if preprocessor_guard: |
| code.putln(preprocessor_guard) |
| code.putln('#if CYTHON_COMPILING_IN_CPYTHON') |
| code.putln("{") |
| code.putln( |
| 'PyObject *wrapper = __Pyx_GetAttrString((PyObject *)&%s, "%s"); %s' % ( |
| typeobj_cname, |
| func.name, |
| code.error_goto_if_null('wrapper', entry.pos))) |
| code.putln( |
| "if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {") |
| code.putln( |
| "%s = *((PyWrapperDescrObject *)wrapper)->d_base;" % ( |
| func.wrapperbase_cname)) |
| code.putln( |
| "%s.doc = %s;" % (func.wrapperbase_cname, func.doc_cname)) |
| code.putln( |
| "((PyWrapperDescrObject *)wrapper)->d_base = &%s;" % ( |
| func.wrapperbase_cname)) |
| code.putln("}") |
| code.putln("}") |
| code.putln('#endif') |
| if preprocessor_guard: |
| code.putln('#endif') |
| if type.vtable_cname: |
| code.putln( |
| "if (__Pyx_SetVtable(%s.tp_dict, %s) < 0) %s" % ( |
| typeobj_cname, |
| type.vtabptr_cname, |
| code.error_goto(entry.pos))) |
| code.globalstate.use_utility_code( |
| UtilityCode.load_cached('SetVTable', 'ImportExport.c')) |
| if not type.scope.is_internal and not type.scope.directives['internal']: |
| # scope.is_internal is set for types defined by |
| # Cython (such as closures), the 'internal' |
| # directive is set by users |
| code.putln( |
| 'if (__Pyx_SetAttrString(%s, "%s", (PyObject *)&%s) < 0) %s' % ( |
| Naming.module_cname, |
| scope.class_name, |
| typeobj_cname, |
| code.error_goto(entry.pos))) |
| weakref_entry = scope.lookup_here("__weakref__") |
| if weakref_entry: |
| if weakref_entry.type is py_object_type: |
| tp_weaklistoffset = "%s.tp_weaklistoffset" % typeobj_cname |
| if type.typedef_flag: |
| objstruct = type.objstruct_cname |
| else: |
| objstruct = "struct %s" % type.objstruct_cname |
| code.putln("if (%s == 0) %s = offsetof(%s, %s);" % ( |
| tp_weaklistoffset, |
| tp_weaklistoffset, |
| objstruct, |
| weakref_entry.cname)) |
| else: |
| error(weakref_entry.pos, "__weakref__ slot must be of type 'object'") |
| |
| 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)) |
| |
| def generate_typeptr_assignment_code(self, entry, code): |
| # Generate code to initialise the typeptr of an extension |
| # type defined in this module to point to its type object. |
| type = entry.type |
| if type.typeobj_cname: |
| code.putln( |
| "%s = &%s;" % ( |
| type.typeptr_cname, type.typeobj_cname)) |
| |
| def generate_cfunction_declaration(entry, env, code, definition): |
| from_cy_utility = entry.used and entry.utility_code_definition |
| if entry.used and entry.inline_func_in_pxd or (not entry.in_cinclude and (definition |
| or entry.defined_in_pxd or entry.visibility == 'extern' or from_cy_utility)): |
| if entry.visibility == 'extern': |
| storage_class = Naming.extern_c_macro |
| dll_linkage = "DL_IMPORT" |
| elif entry.visibility == 'public': |
| storage_class = Naming.extern_c_macro |
| dll_linkage = "DL_EXPORT" |
| 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 |
| # |
| #------------------------------------------------------------------------------------ |
| |
| streq_utility_code = UtilityCode( |
| proto = """ |
| static CYTHON_INLINE int __Pyx_StrEq(const char *, const char *); /*proto*/ |
| """, |
| impl = """ |
| static CYTHON_INLINE int __Pyx_StrEq(const char *s1, const char *s2) { |
| while (*s1 != '\\0' && *s1 == *s2) { s1++; s2++; } |
| return *s1 == *s2; |
| } |
| """) |
| |
| #------------------------------------------------------------------------------------ |
| |
| import_star_utility_code = """ |
| |
| /* import_all_from is an unexposed function from ceval.c */ |
| |
| static int |
| __Pyx_import_all_from(PyObject *locals, PyObject *v) |
| { |
| PyObject *all = __Pyx_GetAttrString(v, "__all__"); |
| PyObject *dict, *name, *value; |
| int skip_leading_underscores = 0; |
| int pos, err; |
| |
| if (all == NULL) { |
| if (!PyErr_ExceptionMatches(PyExc_AttributeError)) |
| return -1; /* Unexpected error */ |
| PyErr_Clear(); |
| dict = __Pyx_GetAttrString(v, "__dict__"); |
| if (dict == NULL) { |
| if (!PyErr_ExceptionMatches(PyExc_AttributeError)) |
| return -1; |
| PyErr_SetString(PyExc_ImportError, |
| "from-import-* object has no __dict__ and no __all__"); |
| return -1; |
| } |
| #if PY_MAJOR_VERSION < 3 |
| all = PyObject_CallMethod(dict, (char *)"keys", NULL); |
| #else |
| all = PyMapping_Keys(dict); |
| #endif |
| Py_DECREF(dict); |
| if (all == NULL) |
| return -1; |
| skip_leading_underscores = 1; |
| } |
| |
| for (pos = 0, err = 0; ; pos++) { |
| name = PySequence_GetItem(all, pos); |
| if (name == NULL) { |
| if (!PyErr_ExceptionMatches(PyExc_IndexError)) |
| err = -1; |
| else |
| PyErr_Clear(); |
| break; |
| } |
| if (skip_leading_underscores && |
| #if PY_MAJOR_VERSION < 3 |
| PyString_Check(name) && |
| PyString_AS_STRING(name)[0] == '_') |
| #else |
| PyUnicode_Check(name) && |
| PyUnicode_AS_UNICODE(name)[0] == '_') |
| #endif |
| { |
| Py_DECREF(name); |
| continue; |
| } |
| value = PyObject_GetAttr(v, name); |
| if (value == NULL) |
| err = -1; |
| else if (PyDict_CheckExact(locals)) |
| err = PyDict_SetItem(locals, name, value); |
| else |
| err = PyObject_SetItem(locals, name, value); |
| Py_DECREF(name); |
| Py_XDECREF(value); |
| if (err != 0) |
| break; |
| } |
| Py_DECREF(all); |
| return err; |
| } |
| |
| |
| static int %(IMPORT_STAR)s(PyObject* m) { |
| |
| int i; |
| int ret = -1; |
| char* s; |
| PyObject *locals = 0; |
| PyObject *list = 0; |
| #if PY_MAJOR_VERSION >= 3 |
| PyObject *utf8_name = 0; |
| #endif |
| PyObject *name; |
| PyObject *item; |
| |
| locals = PyDict_New(); if (!locals) goto bad; |
| if (__Pyx_import_all_from(locals, m) < 0) goto bad; |
| list = PyDict_Items(locals); if (!list) goto bad; |
| |
| for(i=0; i<PyList_GET_SIZE(list); i++) { |
| name = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 0); |
| item = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 1); |
| #if PY_MAJOR_VERSION >= 3 |
| utf8_name = PyUnicode_AsUTF8String(name); |
| if (!utf8_name) goto bad; |
| s = PyBytes_AS_STRING(utf8_name); |
| if (%(IMPORT_STAR_SET)s(item, name, s) < 0) goto bad; |
| Py_DECREF(utf8_name); utf8_name = 0; |
| #else |
| s = PyString_AsString(name); |
| if (!s) goto bad; |
| if (%(IMPORT_STAR_SET)s(item, name, s) < 0) goto bad; |
| #endif |
| } |
| ret = 0; |
| |
| bad: |
| Py_XDECREF(locals); |
| Py_XDECREF(list); |
| #if PY_MAJOR_VERSION >= 3 |
| Py_XDECREF(utf8_name); |
| #endif |
| return ret; |
| } |
| """ % {'IMPORT_STAR' : Naming.import_star, |
| 'IMPORT_STAR_SET' : Naming.import_star_set } |
| |
| refnanny_utility_code = UtilityCode.load_cached("Refnanny", "ModuleSetupCode.c") |
| |
| main_method = UtilityCode.load("MainFunction", "Embed.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") |
