diff options
| author | orivej <[email protected]> | 2022-02-10 16:45:01 +0300 |
|---|---|---|
| committer | Daniil Cherednik <[email protected]> | 2022-02-10 16:45:01 +0300 |
| commit | 2d37894b1b037cf24231090eda8589bbb44fb6fc (patch) | |
| tree | be835aa92c6248212e705f25388ebafcf84bc7a1 /contrib/tools/cython/Cython/Compiler/ModuleNode.py | |
| parent | 718c552901d703c502ccbefdfc3c9028d608b947 (diff) | |
Restoring authorship annotation for <[email protected]>. Commit 2 of 2.
Diffstat (limited to 'contrib/tools/cython/Cython/Compiler/ModuleNode.py')
| -rw-r--r-- | contrib/tools/cython/Cython/Compiler/ModuleNode.py | 1156 |
1 files changed, 578 insertions, 578 deletions
diff --git a/contrib/tools/cython/Cython/Compiler/ModuleNode.py b/contrib/tools/cython/Cython/Compiler/ModuleNode.py index 0eb4a02ab34..cd7166408e0 100644 --- a/contrib/tools/cython/Cython/Compiler/ModuleNode.py +++ b/contrib/tools/cython/Cython/Compiler/ModuleNode.py @@ -9,12 +9,12 @@ cython.declare(Naming=object, Options=object, PyrexTypes=object, TypeSlots=objec error=object, warning=object, py_object_type=object, UtilityCode=object, EncodedString=object, re=object) -from collections import defaultdict -import json -import operator +from collections import defaultdict +import json +import operator import os import re - + from .PyrexTypes import CPtrType from . import Future from . import Annotate @@ -28,7 +28,7 @@ from . import Pythran from .Errors import error, warning from .PyrexTypes import py_object_type -from ..Utils import open_new_file, replace_suffix, decode_filename, build_hex_version +from ..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 @@ -37,25 +37,25 @@ 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) - - + +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 @@ -108,13 +108,13 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 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: + if self.doc is not None: env.doc = EncodedString(env.doc + u'\n' + self.doc) env.doc.encoding = self.doc.encoding else: @@ -123,17 +123,17 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 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 @@ -142,7 +142,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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) + self.generate_api_code(env, options, result) def has_imported_c_functions(self): for module in self.referenced_modules: @@ -161,18 +161,18 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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: + 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) + 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_code.put_generated_by() h_guard = Naming.h_guard_prefix + self.api_name(env) h_code.put_h_guard(h_guard) h_code.putln("") @@ -185,8 +185,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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) + h_code.putln("") + self.generate_dl_import_macro(h_code) if h_extension_types: h_code.putln("") for entry in h_extension_types: @@ -208,8 +208,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): h_code.putln("/* It now returns a PyModuleDef instance instead of a PyModule instance. */") h_code.putln("") h_code.putln("#if PY_MAJOR_VERSION < 3") - init_name = 'init' + (options.init_suffix or env.module_name) - h_code.putln("PyMODINIT_FUNC %s(void);" % init_name) + init_name = 'init' + (options.init_suffix or env.module_name) + h_code.putln("PyMODINIT_FUNC %s(void);" % init_name) h_code.putln("#else") h_code.putln("PyMODINIT_FUNC %s(void);" % self.mod_init_func_cname('PyInit', env, options)) h_code.putln("#endif") @@ -227,13 +227,13 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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))) + 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 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)] @@ -243,16 +243,16 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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() + 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') - + # 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)) @@ -267,14 +267,14 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): h_code.putln("") for entry in api_funcs: type = CPtrType(entry.type) - cname = env.mangle(Naming.func_prefix_api, entry.name) + 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) + 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]) @@ -283,28 +283,28 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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")[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('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) + 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() + 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;") + 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:") @@ -333,8 +333,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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))) + i_code.putln("cdef %s" % ( + entry.type.declaration_code(entry.cname, pyrex=1))) else: i_code.putln("pass") i_code.dedent() @@ -345,19 +345,19 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): if Options.annotate or options.annotate: rootwriter = Annotate.AnnotationCCodeWriter() else: - rootwriter = Code.CCodeWriter() - - c_code_config = generate_c_code_config(env, options) - - globalstate = Code.GlobalState( - rootwriter, self, - code_config=c_code_config, - common_utility_include_dir=options.common_utility_include_dir, - ) + 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) + self.generate_module_preamble(env, options, modules, result.embedded_metadata, h_code) globalstate.module_pos = self.pos globalstate.directives = self.directives @@ -382,21 +382,21 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): self.generate_lambda_definitions(env, code) # generate normal variable and function definitions self.generate_variable_definitions(env, code) - + self.body.generate_function_definitions(env, code) - + code.mark_pos(None) self.generate_typeobj_definitions(env, code) self.generate_method_table(env, code) if env.has_import_star: self.generate_import_star(env, code) - self.generate_pymoduledef_struct(env, options, code) + self.generate_pymoduledef_struct(env, options, code) + + # initialise the macro to reduce the code size of one-time functionality + code.putln(UtilityCode.load_as_string("SmallCodeConfig", "ModuleSetupCode.c")[0].strip()) - # initialise the macro to reduce the code size of one-time functionality - code.putln(UtilityCode.load_as_string("SmallCodeConfig", "ModuleSetupCode.c")[0].strip()) - # init_globals is inserted before this - self.generate_module_init_func(modules[:-1], env, options, globalstate['init_module']) + self.generate_module_init_func(modules[:-1], env, options, globalstate['init_module']) self.generate_module_cleanup_func(env, globalstate['cleanup_module']) if Options.embed: self.generate_main_method(env, globalstate['main_method']) @@ -418,29 +418,29 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): if options.gdb_debug: self._serialize_lineno_map(env, rootwriter) if Options.annotate or options.annotate: - self._generate_annotations(rootwriter, result, options) + self._generate_annotations(rootwriter, result, options) - def _generate_annotations(self, 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() + coverage_xml_filename = Options.annotate_coverage_xml or options.annotate_coverage_xml + if coverage_xml_filename and os.path.exists(coverage_xml_filename): + try: + import xml.etree.cElementTree as ET + except ImportError: + import xml.etree.ElementTree as ET + coverage_xml = ET.parse(coverage_xml_filename).getroot() if hasattr(coverage_xml, 'iter'): iterator = coverage_xml.iter() # Python 2.7 & 3.2+ else: iterator = coverage_xml.getiterator() for el in iterator: - el.tail = None # save some memory - else: - coverage_xml = None - - rootwriter.save_annotation(result.main_source_file, result.c_file, coverage_xml=coverage_xml) - + 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 @@ -459,28 +459,28 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): if target_file_dir != target_dir and not os.path.exists(target_file_dir): try: os.makedirs(target_file_dir) - except OSError as e: + except OSError as e: import errno if e.errno != errno.EEXIST: raise - rootwriter.save_annotation(source_file, target_file, coverage_xml=coverage_xml) + 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) + d = defaultdict(list) for c_lineno, cython_lineno in enumerate(markers): if cython_lineno > 0: - d[cython_lineno].append(c_lineno + 1) + 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), - ) + 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() @@ -625,16 +625,16 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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("") + def _put_setup_code(self, code, name): + code.put(UtilityCode.load_as_string(name, "ModuleSetupCode.c")[1]) + + def generate_module_preamble(self, env, options, cimported_modules, metadata, code): + code.put_generated_by() + if metadata: + code.putln("/* BEGIN: Cython Metadata") + code.putln(json.dumps(metadata, indent=4, sort_keys=True)) + code.putln("END: Cython Metadata */") + code.putln("") code.putln("#ifndef PY_SSIZE_T_CLEAN") code.putln("#define PY_SSIZE_T_CLEAN") @@ -644,9 +644,9 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): if inc.location == inc.INITIAL: inc.write(code) code.putln("#ifndef Py_PYTHON_H") - code.putln(" #error Python headers needed to compile C extensions, " - "please install development version of Python.") - code.putln("#elif PY_VERSION_HEX < 0x02060000 || " + code.putln(" #error Python headers needed to compile C extensions, " + "please install development version of Python.") + code.putln("#elif PY_VERSION_HEX < 0x02060000 || " "(0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)") code.putln(" #error Cython requires Python 2.6+ or Python 3.3+.") code.putln("#else") @@ -654,23 +654,23 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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_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, "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") + self._put_setup_code(code, "MathInitCode") # Using "(void)cname" to prevent "unused" warnings. - if options.c_line_in_traceback: + if options.c_line_in_traceback: cinfo = "%s = %s; (void)%s; " % (Naming.clineno_cname, Naming.line_c_macro, Naming.clineno_cname) - else: - cinfo = "" + else: + cinfo = "" code.putln("#define __PYX_MARK_ERR_POS(f_index, lineno) \\") code.putln(" { %s = %s[f_index]; (void)%s; %s = lineno; (void)%s; %s}" % ( Naming.filename_cname, Naming.filetable_cname, Naming.filename_cname, @@ -679,7 +679,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): )) code.putln("#define __PYX_ERR(f_index, lineno, Ln_error) \\") code.putln(" { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; }") - + code.putln("") self.generate_extern_c_macro_definition(code) code.putln("") @@ -707,13 +707,13 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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')) + 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_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' @@ -734,10 +734,10 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 = 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) + 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) @@ -759,11 +759,11 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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_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): @@ -810,8 +810,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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_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 @@ -825,8 +825,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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_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: @@ -869,8 +869,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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("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): @@ -899,10 +899,10 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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") + 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)) + "%s;" % attr.type.declaration_code(attr.cname)) code.putln(footer) if packed: code.putln("#if defined(__SUNPRO_C)") @@ -917,13 +917,13 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): scope = type.scope if scope: if type.templates: - code.putln("template <class %s>" % ", class ".join( - [T.empty_declaration_code() for T in type.templates])) + code.putln("template <class %s>" % ", class ".join( + [T.empty_declaration_code() for T in type.templates])) # Just let everything be public. code.put("struct %s" % type.cname) if type.base_classes: base_class_decl = ", public ".join( - [base_class.empty_declaration_code() for base_class in type.base_classes]) + [base_class.empty_declaration_code() for base_class in type.base_classes]) code.put(" : public %s" % base_class_decl) code.putln(" {") py_attrs = [e for e in scope.entries.values() @@ -932,8 +932,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): constructor = None destructor = None for attr in scope.var_entries: - if attr.type.is_cfunction: - code.put("inline ") + if attr.type.is_cfunction: + code.put("inline ") if attr.type.is_cfunction and attr.type.is_static_method: code.put("static ") elif attr.name == "<init>": @@ -943,7 +943,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): elif attr.type.is_cfunction: code.put("virtual ") has_virtual_methods = True - code.putln("%s;" % attr.type.declaration_code(attr.cname)) + code.putln("%s;" % attr.type.declaration_code(attr.cname)) is_implementing = 'init_module' in code.globalstate.parts if constructor or py_attrs: if constructor: @@ -1022,11 +1022,11 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code.mark_pos(entry.pos) type = entry.type name = entry.cname or entry.name or "" - header, footer = self.sue_header_footer(type, "enum", name) + 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") + 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 @@ -1080,15 +1080,15 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): if type.vtabstruct_cname: code.putln("") - code.putln("struct %s {" % type.vtabstruct_cname) + 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("};") + 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: @@ -1155,7 +1155,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): else: attr_type = attr.type code.putln( - "%s;" % attr_type.declaration_code(attr.cname)) + "%s;" % attr_type.declaration_code(attr.cname)) code.putln(footer) if type.objtypedef_cname is not None: # Only for exposing public typedef name. @@ -1164,15 +1164,15 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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)) + 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))): + (entry.visibility == 'private' and not (entry.defined_in_pxd or entry.used))): continue storage_class = None @@ -1192,7 +1192,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): storage_class = "static" dll_linkage = None if entry.init is not None: - init = entry.type.literal_code(entry.init) + init = entry.type.literal_code(entry.init) type = entry.type cname = entry.cname @@ -1206,7 +1206,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): if storage_class: code.put("%s " % storage_class) code.put(type.declaration_code( - cname, dll_linkage=dll_linkage)) + cname, dll_linkage=dll_linkage)) if init is not None: code.put_safe(" = %s" % init) code.putln(";") @@ -1220,10 +1220,10 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): def generate_variable_definitions(self, env, code): for entry in env.var_entries: - if not entry.in_cinclude and entry.visibility == "public": + 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) + init = entry.type.literal_code(entry.init) code.put_safe(" = %s" % init) code.putln(";") @@ -1252,9 +1252,9 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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) + 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") @@ -1269,7 +1269,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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) + 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) @@ -1290,7 +1290,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code.putln( "%s = (%s)o;" % ( type.declaration_code("p"), - type.empty_declaration_code())) + type.empty_declaration_code())) def generate_new_function(self, scope, code, cclass_entry): tp_slot = TypeSlots.ConstructorSlot("tp_new", '__new__') @@ -1332,8 +1332,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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)) + "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 @@ -1355,9 +1355,9 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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( + "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) @@ -1379,10 +1379,10 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 - + + # 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: @@ -1396,16 +1396,16 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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())) + 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) + 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) @@ -1422,16 +1422,16 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): cinit_args = "o, %s, NULL" % Naming.empty_tuple else: cinit_args = "o, a, k" - needs_error_cleanup = True - code.putln("if (unlikely(%s(%s) < 0)) goto bad;" % ( - new_func_entry.func_cname, cinit_args)) - + needs_error_cleanup = True + code.putln("if (unlikely(%s(%s) < 0)) goto bad;" % ( + new_func_entry.func_cname, cinit_args)) + code.putln( "return o;") - if needs_error_cleanup: - code.putln("bad:") - code.put_decref_clear("o", py_object_type, nanny=False) - code.putln("return NULL;") + if needs_error_cleanup: + code.putln("bad:") + code.put_decref_clear("o", py_object_type, nanny=False) + code.putln("return NULL;") code.putln( "}") @@ -1455,14 +1455,14 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 - + 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: + 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: @@ -1493,11 +1493,11 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): if weakref_slot: code.putln("if (p->__weakref__) PyObject_ClearWeakRefs(o);") - if dict_slot: - code.putln("if (p->__dict__) PyDict_Clear(p->__dict__);") - + 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) + 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, @@ -1514,7 +1514,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 CYTHON_USE_TYPE_SLOTS") code.putln("if (PyType_IS_GC(Py_TYPE(o)->tp_base))") code.putln("#endif") code.putln("PyObject_GC_Track(o);") @@ -1548,12 +1548,12 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): ' & ((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( + "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 {") @@ -1584,10 +1584,10 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 + return # never used code.putln("") code.putln( - "static int %s(PyObject *o, visitproc v, void *a) {" % slot_func) + "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)) @@ -1613,19 +1613,19 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): # 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.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("if (%s) {" % var_code) code.putln("e = (*v)(%s, a); if (e) return e;" % var_as_pyobject) - code.putln("}") + code.putln("}") # Traverse buffer exporting objects. # Note: not traversing memoryview attributes of memoryview slices! @@ -1634,14 +1634,14 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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("e = (*v)(p->%s, a); if (e) return e;" % cname) code.putln("}") - code.putln("return 0;") - 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") + 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: @@ -1679,9 +1679,9 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): # 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.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")) @@ -1705,26 +1705,26 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): if cclass_entry.cname == '__pyx_memoryviewslice': code.putln("__PYX_XDEC_MEMVIEW(&p->from_slice, 1);") - code.putln("return 0;") - code.putln("}") + 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"))) + "static PyObject *%s(PyObject *o, Py_ssize_t i) {" % ( + scope.mangle_internal("sq_item"))) code.putln( - "PyObject *r;") + "PyObject *r;") code.putln( - "PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;") + "PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;") code.putln( - "r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);") + "r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);") code.putln( - "Py_DECREF(x);") + "Py_DECREF(x);") code.putln( - "return r;") + "return r;") code.putln( "}") @@ -1737,40 +1737,40 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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"))) + "static int %s(PyObject *o, PyObject *i, PyObject *v) {" % ( + scope.mangle_internal("mp_ass_subscript"))) code.putln( - "if (v) {") + "if (v) {") if set_entry: - code.putln("return %s(o, i, v);" % set_entry.func_cname) + 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,") + "PyErr_Format(PyExc_NotImplementedError,") code.putln( - ' "Subscript assignment not supported by %.200s", Py_TYPE(o)->tp_name);') + ' "Subscript assignment not supported by %.200s", Py_TYPE(o)->tp_name);') code.putln( - "return -1;") + "return -1;") code.putln( - "}") + "}") code.putln( - "else {") + "else {") if del_entry: code.putln( - "return %s(o, i);" % ( - del_entry.func_cname)) + "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,") + "PyErr_Format(PyExc_NotImplementedError,") code.putln( - ' "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);') + ' "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name);') code.putln( - "return -1;") + "return -1;") code.putln( - "}") + "}") code.putln( "}") @@ -1802,42 +1802,42 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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"))) + "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 (v) {") if set_entry: code.putln( - "return %s(o, i, j, v);" % ( - set_entry.func_cname)) + "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,") + "PyErr_Format(PyExc_NotImplementedError,") code.putln( - ' "2-element slice assignment not supported by %.200s", Py_TYPE(o)->tp_name);') + ' "2-element slice assignment not supported by %.200s", Py_TYPE(o)->tp_name);') code.putln( - "return -1;") + "return -1;") code.putln( - "}") + "}") code.putln( - "else {") + "else {") if del_entry: code.putln( - "return %s(o, i, j);" % ( - del_entry.func_cname)) + "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,") + "PyErr_Format(PyExc_NotImplementedError,") code.putln( - ' "2-element slice deletion not supported by %.200s", Py_TYPE(o)->tp_name);') + ' "2-element slice deletion not supported by %.200s", Py_TYPE(o)->tp_name);') code.putln( - "return -1;") + "return -1;") code.putln( - "}") + "}") code.putln( "}") @@ -1935,12 +1935,12 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): getattribute_entry = lookup_here_or_base("__getattribute__") code.putln("") code.putln( - "static PyObject *%s(PyObject *o, PyObject *n) {" % ( - scope.mangle_internal("tp_getattro"))) + "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)) + "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. @@ -1962,8 +1962,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code.putln( "PyErr_Clear();") code.putln( - "v = %s(o, n);" % ( - getattr_entry.func_cname)) + "v = %s(o, n);" % ( + getattr_entry.func_cname)) code.putln( "}") code.putln( @@ -1980,34 +1980,34 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): del_entry = scope.lookup_here("__delattr__") code.putln("") code.putln( - "static int %s(PyObject *o, PyObject *n, PyObject *v) {" % ( - scope.mangle_internal("tp_setattro"))) + "static int %s(PyObject *o, PyObject *n, PyObject *v) {" % ( + scope.mangle_internal("tp_setattro"))) code.putln( - "if (v) {") + "if (v) {") if set_entry: code.putln( - "return %s(o, n, v);" % ( - set_entry.func_cname)) + "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);") + "return PyObject_GenericSetAttr(o, n, v);") code.putln( - "}") + "}") code.putln( - "else {") + "else {") if del_entry: code.putln( - "return %s(o, n);" % ( - del_entry.func_cname)) + "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);") + "return PyObject_GenericSetAttr(o, n, 0);") code.putln( - "}") + "}") code.putln( "}") @@ -2019,8 +2019,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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"))) + "static PyObject *%s(PyObject *o, PyObject *i, PyObject *c) {" % ( + scope.mangle_internal("tp_descr_get"))) code.putln( "PyObject *r = 0;") code.putln( @@ -2030,8 +2030,8 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): #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)) + "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( @@ -2048,38 +2048,38 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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"))) + "static int %s(PyObject *o, PyObject *i, PyObject *v) {" % ( + scope.mangle_internal("tp_descr_set"))) code.putln( - "if (v) {") + "if (v) {") if user_set_entry: code.putln( - "return %s(o, i, v);" % ( - user_set_entry.func_cname)) + "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__");') + 'PyErr_SetString(PyExc_NotImplementedError, "__set__");') code.putln( - "return -1;") + "return -1;") code.putln( - "}") + "}") code.putln( - "else {") + "else {") if user_del_entry: code.putln( - "return %s(o, i);" % ( - user_del_entry.func_cname)) + "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__");') + 'PyErr_SetString(PyExc_NotImplementedError, "__delete__");') code.putln( - "return -1;") + "return -1;") code.putln( - "}") + "}") code.putln( "}") @@ -2098,11 +2098,11 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): get_entry = property_scope.lookup_here("__get__") code.putln("") code.putln( - "static PyObject *%s(PyObject *o, CYTHON_UNUSED void *x) {" % ( - property_entry.getter_cname)) + "static PyObject *%s(PyObject *o, CYTHON_UNUSED void *x) {" % ( + property_entry.getter_cname)) code.putln( - "return %s(o);" % ( - get_entry.func_cname)) + "return %s(o);" % ( + get_entry.func_cname)) code.putln( "}") @@ -2114,34 +2114,34 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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)) + "static int %s(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {" % ( + property_entry.setter_cname)) code.putln( - "if (v) {") + "if (v) {") if set_entry: code.putln( - "return %s(o, v);" % ( - set_entry.func_cname)) + "return %s(o, v);" % ( + set_entry.func_cname)) else: code.putln( - 'PyErr_SetString(PyExc_NotImplementedError, "__set__");') + 'PyErr_SetString(PyExc_NotImplementedError, "__set__");') code.putln( - "return -1;") + "return -1;") code.putln( - "}") + "}") code.putln( - "else {") + "else {") if del_entry: code.putln( - "return %s(o);" % ( - del_entry.func_cname)) + "return %s(o);" % ( + del_entry.func_cname)) else: code.putln( - 'PyErr_SetString(PyExc_NotImplementedError, "__del__");') + 'PyErr_SetString(PyExc_NotImplementedError, "__del__");') code.putln( - "return -1;") + "return -1;") code.putln( - "}") + "}") code.putln( "}") @@ -2167,7 +2167,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): else: objstruct = "struct %s" % type.objstruct_cname code.putln( - "sizeof(%s), /*tp_basicsize*/" % objstruct) + "sizeof(%s), /*tp_basicsize*/" % objstruct) code.putln( "0, /*tp_itemsize*/") for slot in TypeSlots.slot_table: @@ -2178,88 +2178,88 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): def generate_method_table(self, env, code): if env.is_c_class_scope and not env.pyfunc_entries: return - binding = env.directives['binding'] - + binding = env.directives['binding'] + code.putln("") - wrapper_code_writer = code.insertion_point() - + wrapper_code_writer = code.insertion_point() + code.putln( - "static PyMethodDef %s[] = {" % ( - env.method_table_cname)) + "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) + 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}") + "{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("}") - + 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) + env.getset_table_cname) for entry in env.property_entries: - doc = entry.doc - if doc: - if doc.is_unicode: - doc = doc.as_utf8_string() - doc_code = doc.as_c_string_literal() + doc = entry.doc + if doc: + if doc.is_unicode: + doc = doc.as_utf8_string() + doc_code = doc.as_c_string_literal() else: doc_code = "0" code.putln( - '{(char *)"%s", %s, %s, (char *)%s, 0},' % ( + '{(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}") + "{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 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")) + 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[] = {") + 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("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);') @@ -2267,17 +2267,17 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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("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: @@ -2289,13 +2289,13 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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)) + 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('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 {") @@ -2310,17 +2310,17 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code.putln("bad:") code.putln("return -1;") code.putln("}") - code.putln("") + code.putln("") code.putln(UtilityCode.load_as_string("ImportStar", "ImportExport.c")[1]) - code.exit_cfunc_scope() # done with labels + code.exit_cfunc_scope() # done with labels - def generate_module_init_func(self, imported_modules, env, options, code): + def generate_module_init_func(self, imported_modules, env, options, code): subfunction = self.mod_init_subfunction(self.pos, self.scope, code) - code.enter_cfunc_scope(self.scope) + code.enter_cfunc_scope(self.scope) code.putln("") code.putln(UtilityCode.load_as_string("PyModInitFuncType", "ModuleSetupCode.c")[0]) - init_name = 'init' + (options.init_suffix or env.module_name) + init_name = 'init' + (options.init_suffix or env.module_name) header2 = "__Pyx_PyMODINIT_FUNC %s(void)" % init_name header3 = "__Pyx_PyMODINIT_FUNC %s(void)" % self.mod_init_func_cname('PyInit', env, options) code.putln("#if PY_MAJOR_VERSION < 3") @@ -2342,7 +2342,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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)" % ( + 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 @@ -2354,26 +2354,26 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): tempdecl_code = code.insertion_point() - profile = code.globalstate.directives['profile'] - linetrace = code.globalstate.directives['linetrace'] - if profile or linetrace: - code.globalstate.use_utility_code(UtilityCode.load_cached("Profile", "Profile.c")) - + profile = code.globalstate.directives['profile'] + linetrace = code.globalstate.directives['linetrace'] + if profile or linetrace: + code.globalstate.use_utility_code(UtilityCode.load_cached("Profile", "Profile.c")) + code.put_declare_refcount_context() code.putln("#if CYTHON_PEP489_MULTI_PHASE_INIT") - # Most extension modules simply can't deal with it, and Cython isn't ready either. - # See issues listed here: https://docs.python.org/3/c-api/init.html#sub-interpreter-support - code.putln("if (%s) {" % Naming.module_cname) + # 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;" % ( + 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('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);" % ( @@ -2382,31 +2382,31 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): )) code.putln("#endif") - if profile or linetrace: - tempdecl_code.put_trace_declarations() - code.put_trace_frame_init() - + 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))) + 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("#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']: @@ -2419,21 +2419,21 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code.putln("#endif") code.putln("/*--- Module creation code ---*/") - self.generate_module_creation_code(env, options, code) + self.generate_module_creation_code(env, options, code) code.putln("/*--- Initialize various global constants etc. ---*/") - code.put_error_if_neg(self.pos, "__Pyx_InitGlobals()") + code.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("#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.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 @@ -2476,20 +2476,20 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 - + 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) - + 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) @@ -2506,15 +2506,15 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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.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) + # 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.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('}') @@ -2562,7 +2562,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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) + 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() @@ -2730,11 +2730,11 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): # 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) + 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('.', '__')) @@ -2742,18 +2742,18 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): wmain = "wmain" else: wmain = Options.embed - main_method = UtilityCode.load_cached("MainFunction", "Embed.c") + 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)) + module_name=env.module_name, + module_is_main=module_is_main, + main_method=Options.embed, + wmain_method=wmain)) def mod_init_func_cname(self, prefix, env, options=None): - return '%s_%s' % (prefix, options and options.init_suffix or env.module_name) + return '%s_%s' % (prefix, options and options.init_suffix or env.module_name) - def generate_pymoduledef_struct(self, env, options, code): + def generate_pymoduledef_struct(self, env, options, code): if env.doc: doc = "%s" % code.get_string_const(env.doc) else: @@ -2781,7 +2781,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code.putln("") code.putln("static struct PyModuleDef %s = {" % Naming.pymoduledef_cname) code.putln(" PyModuleDef_HEAD_INIT,") - code.putln(' "%s",' % (options.module_name or env.module_name)) + code.putln(' "%s",' % (options.module_name or env.module_name)) code.putln(" %s, /* m_doc */" % doc) code.putln("#if CYTHON_PEP489_MULTI_PHASE_INIT") code.putln(" 0, /* m_size */") @@ -2800,7 +2800,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code.putln("};") code.putln("#endif") - def generate_module_creation_code(self, env, options, code): + def generate_module_creation_code(self, env, options, code): # Generate code to create the module object and # install the builtins. if env.doc: @@ -2818,7 +2818,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): code.putln( '%s = Py_InitModule4("%s", %s, %s, 0, PYTHON_API_VERSION); Py_XINCREF(%s);' % ( env.module_cname, - options.module_name or env.module_name, + options.module_name or env.module_name, env.method_table_cname, doc, env.module_cname)) @@ -2841,12 +2841,12 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): '%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.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.put_incref(Naming.cython_runtime_cname, py_object_type, nanny=False) code.putln( 'if (PyObject_SetAttrString(%s, "__builtins__", %s) < 0) %s;' % ( env.module_cname, @@ -2858,7 +2858,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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) + 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 * @@ -2869,7 +2869,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): entry.type.global_init_code(entry, code) def generate_wrapped_entries_code(self, env, code): - for name, entry in sorted(env.entries.items()): + for name, entry in sorted(env.entries.items()): if (entry.create_wrapper and not entry.is_type and entry.scope is env): @@ -2892,13 +2892,13 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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')): + 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() + 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, @@ -2909,14 +2909,14 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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')): + 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. + # 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' % ( @@ -2929,10 +2929,10 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): # 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) + 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): """ @@ -2957,7 +2957,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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' % ( + '%s = PyImport_ImportModule("%s"); if (!%s) %s' % ( temp, module.qualified_name, temp, @@ -2968,7 +2968,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): cname = entry.cname else: cname = module.mangle(Naming.varptr_prefix, entry.name) - signature = entry.type.empty_declaration_code() + signature = entry.type.empty_declaration_code() code.putln( 'if (__Pyx_ImportVoidPtr(%s, "%s", (void **)&%s, "%s") < 0) %s' % ( temp, entry.name, cname, signature, @@ -2987,7 +2987,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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' % ( + '%s = PyImport_ImportModule("%s"); if (!%s) %s' % ( temp, module.qualified_name, temp, @@ -3007,33 +3007,33 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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): + 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) + 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): + 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.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')) @@ -3044,7 +3044,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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): + 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: @@ -3054,11 +3054,11 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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 + 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: @@ -3067,14 +3067,14 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): # 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,' % ( + 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, module_name)) if condition and replacement: @@ -3090,7 +3090,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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("#if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000") code.putln('sizeof(%s),' % objstruct) code.putln("#else") code.putln('sizeof(%s),' % sizeof_objstruct) @@ -3098,18 +3098,18 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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)) - + # 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) @@ -3131,7 +3131,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): c_method_entries = [ entry for entry in type.scope.cfunc_entries - if entry.func_cname] + if entry.func_cname] if c_method_entries: for meth_entry in c_method_entries: cast = meth_entry.type.signature_cast_string() @@ -3142,47 +3142,47 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode): 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) - - + +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.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" @@ -3203,7 +3203,7 @@ def generate_cfunction_declaration(entry, env, code, definition): type = CPtrType(type) header = type.declaration_code( - entry.cname, dll_linkage=dll_linkage) + entry.cname, dll_linkage=dll_linkage) modifiers = code.build_function_modifiers(entry.func_modifiers) code.putln("%s %s%s; /*proto*/" % ( storage_class, @@ -3216,7 +3216,7 @@ def generate_cfunction_declaration(entry, env, code, definition): # #------------------------------------------------------------------------------------ -refnanny_utility_code = UtilityCode.load("Refnanny", "ModuleSetupCode.c") +refnanny_utility_code = UtilityCode.load("Refnanny", "ModuleSetupCode.c") packed_struct_utility_code = UtilityCode(proto=""" #if defined(__GNUC__) |