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