diff options
Diffstat (limited to 'debian/pyrex/pyrex-0.9.9/Pyrex/Compiler/ModuleNode.py')
| -rw-r--r-- | debian/pyrex/pyrex-0.9.9/Pyrex/Compiler/ModuleNode.py | 1678 |
1 files changed, 1678 insertions, 0 deletions
diff --git a/debian/pyrex/pyrex-0.9.9/Pyrex/Compiler/ModuleNode.py b/debian/pyrex/pyrex-0.9.9/Pyrex/Compiler/ModuleNode.py new file mode 100644 index 00000000..9c2b0a31 --- /dev/null +++ b/debian/pyrex/pyrex-0.9.9/Pyrex/Compiler/ModuleNode.py @@ -0,0 +1,1678 @@ +# +# Pyrex - Module parse tree node +# + +import os, time +from cStringIO import StringIO +from PyrexTypes import CPtrType, py_object_type, typecast +from Pyrex.Utils import set + +# Following is set by Testing.py to suppress filename/date comments +# in generated files, so as not to produce spurious changes in test +# reference files. + +testing_mode = False + + +import Code +import Naming +import Nodes +import Options +import PyrexTypes +import TypeSlots +import Version + +from Errors import error +from PyrexTypes import py_object_type +from Pyrex.Utils import open_new_file, replace_suffix + +class ModuleNode(Nodes.Node, Nodes.BlockNode): + # doc string or None + # body StatListNode + # + # referenced_modules [ModuleScope] + # module_temp_cname string + + def analyse_declarations(self, env): + env.doc = self.doc + self.body.analyse_declarations(env) + + def process_implementation(self, env, options, result): + self.analyse_declarations(env) + env.check_c_classes() + self.body.analyse_expressions(env) + env.return_type = PyrexTypes.c_void_type + self.referenced_modules = self.find_referenced_modules(env) + if self.has_imported_c_functions(): + self.module_temp_cname = env.allocate_temp_pyobject() + env.release_temp(self.module_temp_cname) + if options.timestamps or options.recursive: + self.generate_dep_file(env, result) + self.generate_c_code(env, result) + self.generate_h_code(env, options, result) + self.generate_api_code(env, result) + + def has_imported_c_functions(self): + for module in self.referenced_modules: + for entry in module.cfunc_entries: + if entry.defined_in_pxd: + return 1 + return 0 + + def generate_dep_file(self, env, result): + modules = self.referenced_modules + includes = set(env.pyrex_include_files) + for module in modules: + for include in module.pyrex_include_files: + includes.add(include) + if len(modules) > 1 or includes: + include_list = list(includes) + include_list.sort() + dep_file = replace_suffix(result.c_file, ".dep") + f = open(dep_file, "w") + try: + for module in modules[:-1]: + f.write("cimport %s\n" % module.qualified_name) + for path in include_list: + f.write("include %s\n" % path) + finally: + f.close() + + def generate_h_code(self, env, options, result): + def pub(entries): #, pxd = 0): + return [entry for entry in entries + if entry.visibility == 'public'] # or pxd and entry.defined_in_pxd] + denv = env.definition_scope + h_types = pub(denv.type_entries) + pub(env.type_entries) + h_vars = pub(denv.var_entries) + pub(env.var_entries) + h_funcs = pub(denv.cfunc_entries) + pub(env.cfunc_entries) + h_extension_types = pub(denv.c_class_entries) + pub(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(open_new_file(result.h_file)) + if options.generate_pxi: + result.i_file = replace_suffix(result.c_file, ".pxi") + i_code = Code.PyrexCodeWriter(result.i_file) + else: + i_code = None + guard = Naming.h_guard_prefix + env.qualified_name.replace(".", "__") + h_code.put_h_guard(guard) + self.generate_extern_c_macro_definition(h_code) + self.generate_type_header_code(h_types, h_code) + h_code.putln("") + h_code.putln("#ifndef %s" % Naming.api_guard_prefix + self.api_name(env)) + if h_vars: + h_code.putln("") + for entry in h_vars: + self.generate_public_declaration(entry, h_code, i_code) + if h_funcs: + h_code.putln("") + for entry in h_funcs: + self.generate_public_declaration(entry, h_code, i_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) + h_code.putln("") + h_code.putln("#endif") + h_code.putln("") + h_code.putln("PyMODINIT_FUNC init%s(void);" % env.module_name) + h_code.putln("") + h_code.putln("#endif") + + def generate_public_declaration(self, entry, h_code, i_code): + h_code.putln("%s %s;" % ( + Naming.extern_c_macro, + entry.type.declaration_code( + entry.cname, dll_linkage = "DL_IMPORT"))) + if i_code: + i_code.putln("cdef extern %s" % + entry.type.declaration_code(entry.cname, pyrex = 1)) + + def api_name(self, env): + return env.qualified_name.replace(".", "__") + + def generate_api_code(self, env, result): + denv = env.definition_scope + api_funcs = [] + public_extension_types = [] + has_api_extension_types = 0 + for entry in denv.cfunc_entries: + if entry.api: + api_funcs.append(entry) + for entry in env.cfunc_entries: + if entry.api: + api_funcs.append(entry) + for entry in denv.c_class_entries + env.c_class_entries: + if entry.visibility == 'public': + public_extension_types.append(entry) + if entry.api: + has_api_extension_types = 1 + if api_funcs or has_api_extension_types: + result.api_file = replace_suffix(result.c_file, "_api.h") + h_code = Code.CCodeWriter(open_new_file(result.api_file)) + name = self.api_name(env) + guard = Naming.api_guard_prefix + name + h_code.put_h_guard(guard) + h_code.putln('#include "Python.h"') + if result.h_file: + h_code.putln('#include "%s"' % os.path.basename(result.h_file)) + for entry in public_extension_types: + type = entry.type + h_code.putln("") + h_code.putln("static PyTypeObject *%s;" % type.typeptr_cname) + h_code.putln("#define %s (*%s)" % ( + type.typeobj_cname, type.typeptr_cname)) + if api_funcs: + h_code.putln("") + for entry in api_funcs: + type = CPtrType(entry.type) + h_code.putln("static %s;" % type.declaration_code(entry.cname)) + h_code.putln("") + h_code.put_h_guard(Naming.api_func_guard + "import_module") + h_code.put(import_module_utility_code[1]) + h_code.putln("") + h_code.putln("#endif") + if api_funcs: + h_code.putln("") + h_code.put(function_import_utility_code[1]) + if public_extension_types: + h_code.putln("") + h_code.put(type_import_utility_code[1]) + h_code.putln("") + h_code.putln("static int import_%s(void) {" % name) + h_code.putln("PyObject *module = 0;") + h_code.putln('module = __Pyx_ImportModule("%s");' % env.qualified_name) + h_code.putln("if (!module) goto bad;") + for entry in api_funcs: + sig = entry.type.signature_string() + h_code.putln( + 'if (__Pyx_ImportFunction(module, "%s", (void**)&%s, "%s") < 0) goto bad;' % ( + entry.name, + entry.cname, + sig)) + h_code.putln("Py_DECREF(module); module = 0;") + for entry in public_extension_types: + self.generate_type_import_call(entry.type, h_code, "goto bad;") + 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") + + def generate_cclass_header_code(self, type, h_code): + h_code.putln("%s DL_IMPORT(PyTypeObject) %s;" % ( + Naming.extern_c_macro, + type.typeobj_cname)) + #self.generate_obj_struct_definition(type, h_code) + + 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, result): + code = Code.MainCCodeWriter(StringIO()) + code.h = Code.CCodeWriter(StringIO()) + code.init_labels() + + modules = self.referenced_modules + self.generate_module_preamble(env, modules, code.h) + + code.putln("") + code.putln("/* Implementation of %s */" % env.qualified_name) + #self.generate_const_definitions(env, code) + #self.generate_interned_name_decls(env, code) + #self.generate_py_string_decls(env, code) + self.body.generate_function_definitions(env, code) + #self.generate_interned_name_table(env, code) + #self.generate_py_string_table(env, code) + self.generate_typeobj_definitions(env, code) + self.generate_method_table(env, code) + self.generate_filename_init_prototype(code) + self.generate_module_init_func(modules[:-1], env, code) + self.generate_filename_table(code) + self.generate_utility_functions(code) + + denv = env.definition_scope + for module in modules: + code.h.putln("") + code.h.putln("/* Declarations from %s */" % module.qualified_name) + self.generate_declarations_for_module(module, code.h, + implementation = module is denv) + + code.h.putln("") + code.h.putln("/* Declarations from implementation of %s */" % + env.qualified_name) + self.generate_declarations_for_module(env, code.h, implementation = 1) + code.global_state.generate_const_declarations(code.h) + #self.generate_interned_name_table(code.interned_strings, code.h) + #self.generate_py_string_table(code.py_strings, code.h) + self.generate_default_value_declarations(env, code.h) + + f = open_new_file(result.c_file) + f.write(code.h.f.getvalue()) + f.write("\n") + f.write(code.f.getvalue()) + f.close() + result.c_file_generated = 1 + + def find_referenced_modules(self, env): + # Given the ImplementationScope, find the DefinitionScopes of all + # modules cimported, directly or indirectly. Includes this module's + # DefinitionScope as the last entry in the list. + denv = env.definition_scope + module_list = [] + modules_seen = set() + def add_module(module): + if module not in modules_seen: + modules_seen.add(module) + add_modules(module.cimported_modules) + module_list.append(module) + def add_modules(modules): + for module in modules: + add_module(module) + modules_seen.add(denv) + add_modules(denv.cimported_modules) + add_modules(env.cimported_modules) + module_list.append(denv) + #self.print_referenced_modules(module_list) ### + return module_list + + def print_referenced_modules(self, module_list): + print "find_referenced_modules: result =", + for m in module_list: + print m, + print + + def generate_module_preamble(self, env, cimported_modules, code): + comment = "Generated by Pyrex" + if not testing_mode: + comment = "%s %s on %s" % (comment, Version.version, time.asctime()) + code.putln('/* %s */' % comment) + code.putln('') + code.putln('#define PY_SSIZE_T_CLEAN') + for filename in env.python_include_files: + code.putln('#include "%s"' % filename) + code.putln("#ifndef PY_LONG_LONG") + code.putln(" #define PY_LONG_LONG LONG_LONG") + code.putln("#endif") + code.putln("#if PY_VERSION_HEX < 0x02050000") + code.putln(" typedef int Py_ssize_t;") + code.putln(" #define PY_SSIZE_T_MAX INT_MAX") + code.putln(" #define PY_SSIZE_T_MIN INT_MIN") + code.putln(" #define PyInt_FromSsize_t(z) PyInt_FromLong(z)") + code.putln(" #define PyInt_AsSsize_t(o) PyInt_AsLong(o)") + code.putln("#endif") + code.putln("#if !defined(WIN32) && !defined(MS_WINDOWS)") + code.putln(" #ifndef __stdcall") + code.putln(" #define __stdcall") + code.putln(" #endif") + code.putln(" #ifndef __cdecl") + code.putln(" #define __cdecl") + code.putln(" #endif") + code.putln("#endif") + self.generate_extern_c_macro_definition(code) + code.putln("#include <math.h>") + self.generate_includes(env, cimported_modules, code) + code.putln('') + code.put(Nodes.utility_function_predeclarations) + code.putln('') + code.putln('static PyObject *%s;' % env.module_cname) + code.putln('static PyObject *%s;' % Naming.builtins_cname) + code.putln('static int %s;' % Naming.lineno_cname) + code.putln('static char *%s;' % Naming.filename_cname) + code.putln('static char **%s;' % Naming.filetable_cname) + doc = None + doc1 = env.definition_scope.doc + doc2 = env.doc + if doc1 and doc2: + doc = "%s\\n%s" % (doc1, doc2) + else: + doc = doc1 or doc2 + if doc: + code.putln('') + code.putln('static char %s[] = "%s";' % (env.doc_cname, doc)) + + def generate_extern_c_macro_definition(self, code): + name = Naming.extern_c_macro + code.putln("#ifdef __cplusplus") + code.putln('#define %s extern "C"' % name) + code.putln("#else") + code.putln("#define %s extern" % name) + code.putln("#endif") + + def generate_includes(self, env, cimported_modules, code): + includes = [] + for module in cimported_modules + [env]: + for filename in module.include_files: + if filename not in includes: + includes.append(filename) + for filename in includes: + code.putln('#include "%s"' % filename) + + def generate_filename_table(self, code): + code.global_state.generate_filename_table(code) + + def generate_declarations_for_module(self, env, code, implementation): + self.generate_type_predeclarations(env, code) + self.generate_type_definitions(env, code) #, implementation) + self.generate_global_declarations(env, code, implementation) + self.generate_cfunction_predeclarations(env, code, implementation) + + 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? + #for entry in env.type_entries: + 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_struct_or_union: + self.generate_struct_union_definition(entry, code) + elif type.is_enum: + self.generate_enum_definition(entry, code) + elif type.is_extension_type: + self.generate_obj_struct_definition(type, code) + + def generate_type_definitions(self, env, code): #, implementation): + #print "generate_type_definitions:", env ### + type_entries = env.type_entries + self.generate_type_header_code(type_entries, code) + for entry in env.c_class_entries: + if not entry.in_cinclude: + self.generate_typeobject_predeclaration(entry, code) + self.generate_exttype_vtable_struct(entry, code) + self.generate_exttype_vtabptr_declaration(entry, code) + + def generate_typedef(self, entry, code): + base_type = entry.type.typedef_base_type + code.putln("") + code.putln("typedef %s;" % base_type.declaration_code(entry.cname)) + + def sue_header_footer(self, type, kind, name): + if type.typedef_flag: + header = "typedef %s {" % kind + footer = "} %s;" % name + else: + header = "%s %s {" % (kind, name) + footer = "};" + return header, footer + + def generate_struct_union_definition(self, entry, code): + type = entry.type + scope = type.scope + if scope: + header, footer = \ + self.sue_header_footer(type, type.kind, type.cname) + code.putln("") + code.putln(header) + var_entries = scope.var_entries + if not var_entries and not scope.cfunc_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) + + def generate_enum_definition(self, entry, code): + type = entry.type + name = entry.cname or entry.name or "" + header, footer = \ + self.sue_header_footer(type, "enum", name) + code.putln("") + 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] + for value_entry in enum_values: + if value_entry.value == value_entry.name: + value_code = value_entry.cname + else: + value_code = ("%s = %s" % ( + value_entry.cname, + value_entry.value)) + if value_entry is not last_entry: + value_code += "," + code.putln(value_code) + code.putln(footer) + + def generate_typeobject_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 DL_IMPORT(PyTypeObject) %s;" % ( + Naming.extern_c_macro, + name)) + elif entry.visibility == 'public': + #code.putln("DL_EXPORT(PyTypeObject) %s;" % name) + code.putln("%s DL_EXPORT(PyTypeObject) %s;" % ( + Naming.extern_c_macro, + name)) + + def generate_exttype_vtable_struct(self, entry, code): + # Generate struct declaration for an extension type's vtable. + type = entry.type + scope = type.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.name)) + code.putln( + "};") + + def generate_exttype_vtabptr_declaration(self, entry, code): + # 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_obj_struct_definition(self, type, code): + # 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("") + code.putln(header) + base_type = type.base_type + if base_type: + code.putln( + "%s%s %s;" % ( + ("struct ", "")[base_type.typedef_flag], + base_type.objstruct_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: + code.putln( + "%s;" % + attr.type.declaration_code(attr.cname)) + code.putln(footer) + + def generate_global_declarations(self, env, code, implementation): + code.putln("") + for entry in env.c_class_entries: + if implementation or entry.defined_in_pxd: + code.putln("static PyTypeObject *%s = 0;" % + entry.type.typeptr_cname) + #code.putln("/* var_entries */") ### + code.put_var_declarations(env.var_entries, static = 1, + dll_linkage = "DL_EXPORT", definition = implementation) + + def generate_default_value_declarations(self, env, code): + #code.putln("/* default_entries */") ### + code.putln("") + code.put_var_declarations(env.default_entries, static = 1) + + def generate_cfunction_predeclarations(self, env, code, implementation): + for entry in env.cfunc_entries: + if not entry.in_cinclude: + # and (definition or entry.defined_in_pxd or + # entry.visibility == 'extern'): + if entry.visibility in ('public', 'extern'): + dll_linkage = "DL_EXPORT" + else: + dll_linkage = None + type = entry.type + if not implementation: #and entry.defined_in_pxd: + type = CPtrType(type) + header = type.declaration_code(entry.cname, + dll_linkage = dll_linkage) + if entry.visibility <> 'private': + storage_class = "%s " % Naming.extern_c_macro + else: + storage_class = "static " + code.putln("%s%s; /*proto*/" % ( + storage_class, + header)) + + def generate_typeobj_definitions(self, env, code): + full_module_name = env.qualified_name + denv = env.definition_scope + for entry in denv.c_class_entries + 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) + self.generate_dealloc_function(scope, code) + self.generate_traverse_function(scope, code) + self.generate_clear_function(scope, code) + if scope.defines_any(["__getitem__"]): + self.generate_getitem_int_function(scope, code) + if scope.defines_any(["__setitem__", "__delitem__"]): + self.generate_ass_subscript_function(scope, code) + if scope.defines_any(["__setslice__", "__delslice__"]): + self.generate_ass_slice_function(scope, code) + if scope.defines_any(["__getattr__"]): + self.generate_getattro_function(scope, code) + if scope.defines_any(["__setattr__", "__delattr__"]): + self.generate_setattro_function(scope, code) + if scope.defines_any(["__get__"]): + self.generate_descr_get_function(scope, code) + if scope.defines_any(["__set__", "__delete__"]): + self.generate_descr_set_function(scope, code) + self.generate_property_accessors(scope, code) + self.generate_method_table(scope, code) + self.generate_member_table(scope, code) + self.generate_getset_table(scope, code) + self.generate_typeobj_definition(full_module_name, entry, code) + + def generate_exttype_vtable(self, scope, code): + # Generate the definition of an extension type's vtable. + type = scope.parent_type + if type.vtable_cname: + code.putln("static struct %s %s;" % ( + type.vtabstruct_cname, + type.vtable_cname)) + + def generate_self_cast(self, scope, code): + type = scope.parent_type + code.putln( + "%s = (%s)o;" % ( + type.declaration_code("p"), + type.declaration_code(""))) + + def generate_new_function(self, scope, code): + type = scope.parent_type + base_type = type.base_type + py_attrs = [] + for entry in scope.var_entries: + if entry.type.is_pyobject: + py_attrs.append(entry) + need_self_cast = type.vtabslot_cname or py_attrs + code.putln("") + code.putln( + "static PyObject *%s(PyTypeObject *t, PyObject *a, PyObject *k) {" + % scope.mangle_internal("tp_new")) + if need_self_cast: + code.putln( + "%s;" + % scope.parent_type.declaration_code("p")) + if base_type: + code.putln( + "PyObject *o = %s->tp_new(t, a, k);" % + base_type.typeptr_cname) + else: + code.putln( + "PyObject *o = (*t->tp_alloc)(t, 0);") + code.putln( + "if (!o) return 0;") + if need_self_cast: + code.putln( + "p = %s;" + % type.cast_code("o")) + #if need_self_cast: + # self.generate_self_cast(scope, code) + if type.vtabslot_cname: + code.putln("*(struct %s **)&p->%s = %s;" % ( + type.vtabstruct_cname, + type.vtabslot_cname, + type.vtabptr_cname)) + for entry in py_attrs: + if entry.name == "__weakref__": + code.putln("p->%s = 0;" % entry.cname) + else: + code.put_init_var_to_py_none(entry, "p->%s") + entry = scope.lookup_here("__new__") + if entry: + code.putln( + "if (%s(o, a, k) < 0) {" % + entry.func_cname) + code.put_decref_clear("o", py_object_type); + code.putln( + "}") + code.putln( + "return o;") + code.putln( + "}") + + def generate_dealloc_function(self, scope, code): + base_type = scope.parent_type.base_type + code.putln("") + code.putln( + "static void %s(PyObject *o) {" + % scope.mangle_internal("tp_dealloc")) + #py_attrs = [] + #for entry in scope.var_entries: + # if entry.type.is_pyobject and entry.name <> "__weakref__": + # py_attrs.append(entry) + py_attrs = scope.pyattr_entries + if py_attrs: + self.generate_self_cast(scope, code) + self.generate_usr_dealloc_call(scope, code) + if scope.lookup_here("__weakref__"): + code.putln("PyObject_ClearWeakRefs(o);") + for entry in py_attrs: + code.put_xdecref("p->%s" % entry.cname, entry.type) + if base_type: + code.putln( + "%s->tp_dealloc(o);" % + base_type.typeptr_cname) + else: + code.putln( + "(*o->ob_type->tp_free)(o);") + code.putln( + "}") + + def generate_usr_dealloc_call(self, scope, code): + entry = scope.lookup_here("__dealloc__") + if entry: + code.putln( + "{") + code.putln( + "PyObject *etype, *eval, *etb;") + code.putln( + "PyErr_Fetch(&etype, &eval, &etb);") + code.putln( + "++o->ob_refcnt;") + code.putln( + "%s(o);" % + entry.func_cname) + code.putln( + "if (PyErr_Occurred()) PyErr_WriteUnraisable(o);") + code.putln( + "--o->ob_refcnt;") + code.putln( + "PyErr_Restore(etype, eval, etb);") + code.putln( + "}") + + def generate_traverse_function(self, scope, code): + py_attrs = scope.pyattr_entries + if py_attrs: + base_type = scope.parent_type.base_type + code.putln("") + code.putln( + "static int %s(PyObject *o, visitproc v, void *a) {" + % scope.mangle_internal("tp_traverse")) + code.putln( + "int e;") + self.generate_self_cast(scope, code) + if base_type: + code.putln( + "traverseproc t;") + code.putln( + "if ((t = %s->tp_traverse)) {" % + base_type.typeptr_cname) + code.putln( + "e = t(o, v, a); if (e) return e;") + code.putln( + "}") + for entry in py_attrs: + var_code = "p->%s" % entry.cname + code.putln( + "if (%s) {" + % var_code) + if entry.type.is_extension_type: + var_code = "((PyObject*)%s)" % var_code + code.putln( + "e = (*v)(%s, a); if (e) return e;" + % var_code) + code.putln( + "}") + code.putln( + "return 0;") + code.putln( + "}") + + def generate_clear_function(self, scope, code): + py_attrs = scope.pyattr_entries + if py_attrs: + base_type = scope.parent_type.base_type + code.putln("") + code.putln( + "static int %s(PyObject *o) {" + % scope.mangle_internal("tp_clear")) + self.generate_self_cast(scope, code) + code.putln( + "PyObject *t;") + if base_type: + code.putln( + "inquiry c;") + code.putln( + "if ((c = %s->tp_clear)) {" % + base_type.typeptr_cname) + code.putln( + "c(o);") + code.putln( + "}") + for entry in py_attrs: + name = "p->%s" % entry.cname + code.putln( + "t = %s; " % + typecast(py_object_type, entry.type, name)) + code.put_init_var_to_py_none(entry, "p->%s") + #code.put_xdecref(name, entry.type) + code.putln( + "Py_XDECREF(t);") + 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 = o->ob_type->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 %s", o->ob_type->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 %s", o->ob_type->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 %s", o->ob_type->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 %s", o->ob_type->tp_name);') + code.putln( + "return -1;") + code.putln( + "}") + code.putln( + "}") + + def generate_getattro_function(self, scope, code): + # First try to get the attribute using PyObject_GenericGetAttr. + # If that raises an AttributeError, call the user's __getattr__ + # method. + entry = scope.lookup_here("__getattr__") + code.putln("") + code.putln( + "static PyObject *%s(PyObject *o, PyObject *n) {" + % scope.mangle_internal("tp_getattro")) + code.putln( + "PyObject *v = PyObject_GenericGetAttr(o, n);") + code.putln( + "if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) {") + code.putln( + "PyErr_Clear();") + code.putln( + "v = %s(o, n);" % + 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, 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, 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 = "PyTypeObject %s = {" + code.putln(header % type.typeobj_cname) + code.putln( + "PyObject_HEAD_INIT(0)") + code.putln( + "0, /*ob_size*/") + code.putln( + '"%s.%s", /*tp_name*/' % ( + modname, scope.class_name)) + if type.typedef_flag: + objstruct = type.objstruct_cname + else: + #objstruct = "struct %s" % scope.parent_type.objstruct_cname + 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): + code.putln("") + code.putln( + "static struct PyMethodDef %s[] = {" % + env.method_table_cname) + for entry in env.pyfunc_entries: + code.put_pymethoddef(entry, ",") + code.putln( + "{0, 0, 0, 0}") + code.putln( + "};") + + def generate_member_table(self, env, code): + #print "ModuleNode.generate_member_table: scope =", env ### + if env.public_attr_entries: + code.putln("") + code.putln( + "static struct PyMemberDef %s[] = {" % + env.member_table_cname) + type = env.parent_type + if type.typedef_flag: + objstruct = type.objstruct_cname + else: + objstruct = "struct %s" % type.objstruct_cname + for entry in env.public_attr_entries: + type_code = entry.type.pymemberdef_typecode + if entry.visibility == 'readonly': + flags = "READONLY" + else: + flags = "0" + code.putln('{"%s", %s, %s, %s, 0},' % ( + entry.name, + type_code, + "offsetof(%s, %s)" % (objstruct, entry.cname), + flags)) + code.putln( + "{0, 0, 0, 0, 0}") + code.putln( + "};") + + def generate_getset_table(self, env, code): + if env.property_entries: + code.putln("") + code.putln( + "static struct PyGetSetDef %s[] = {" % + env.getset_table_cname) + for entry in env.property_entries: + if entry.doc: + doc_code = code.get_string_const(entry.doc) + else: + doc_code = "0" + code.putln( + '{"%s", %s, %s, %s, 0},' % ( + entry.name, + entry.getter_cname or "0", + entry.setter_cname or "0", + doc_code)) + code.putln( + "{0, 0, 0, 0, 0}") + code.putln( + "};") + + def generate_interned_name_table(self, interned_strings, code): + code.putln("") + code.putln( + "static PyObject **%s[] = {" % Naming.intern_tab_cname) + for s in interned_strings: + code.putln("&%s," % s.py_cname) + code.putln("0") + code.putln( + "};") + + def generate_filename_init_prototype(self, code): + code.putln(""); + code.putln("static void %s(void); /*proto*/" % Naming.fileinit_cname) + + def generate_module_init_func(self, imported_modules, env, code): + denv = env.definition_scope + code.putln("") + header = "PyMODINIT_FUNC init%s(void)" % env.module_name + code.putln("%s; /*proto*/" % header) + code.putln("%s {" % header) + code.put_var_declarations(env.temp_entries) + + if env.gil_used: + # Workaround for GIL/threading bug in 2.3 + code.putln("#if PY_VERSION_HEX < 0x02040000 && defined(WITH_THREAD)") + code.putln(" PyEval_InitThreads();") + code.putln("#endif") + + #code.putln("/*--- Libary function declarations ---*/") + env.generate_library_function_declarations(code) + self.generate_filename_init_call(code) + + #code.putln("/*--- Module creation code ---*/") + self.generate_module_creation_code(env, code) + + #code.putln("/*--- String init code ---*/") + self.generate_string_init_code(env, code) + + #code.putln("/*--- Intern code ---*/") + #self.generate_intern_code(env, code) + + #code.putln("/*--- Global init code ---*/") + self.generate_global_init_code(env, code) + + #code.putln("/*--- Function export code ---*/") + self.generate_pxd_function_export_code(env, code) + self.generate_api_function_export_code(env, code) + + #code.putln("/*--- Function import code ---*/") + for module in imported_modules: + self.generate_c_function_import_code_for_module(module, env, code) + + #code.putln("/*--- Type init code ---*/") + self.generate_type_init_code(env, code) + + #code.putln("/*--- Type import code ---*/") + for module in imported_modules: + self.generate_type_import_code_for_module(module, env, code) + + #code.putln("/*--- Execution code ---*/") + self.body.generate_execution_code(code) + code.putln("return;") + code.put_label(code.error_label) + code.put_var_xdecrefs(env.temp_entries) + code.putln('__Pyx_AddTraceback("%s");' % (env.qualified_name)) + code.use_utility_code(Nodes.traceback_utility_code) + code.putln('}') + + def generate_filename_init_call(self, code): + code.putln("%s();" % Naming.fileinit_cname) + + def generate_module_creation_code(self, env, code): + # Generate code to create the module object and + # install the builtins. + if env.doc: + doc = env.doc_cname + else: + doc = "0" + code.putln( + '%s = Py_InitModule4("%s", %s, %s, 0, PYTHON_API_VERSION);' % ( + env.module_cname, + env.module_name, + env.method_table_cname, + doc)) + code.putln( + "if (!%s) %s;" % ( + env.module_cname, + code.error_goto(self.pos))); + code.putln( + "Py_INCREF(%s);" % + env.module_cname) + code.putln( + '%s = PyImport_AddModule("__builtin__");' % + Naming.builtins_cname) + code.putln( + "if (!%s) %s;" % ( + Naming.builtins_cname, + code.error_goto(self.pos))); + code.putln( + 'if (PyObject_SetAttrString(%s, "__builtins__", %s) < 0) %s;' % ( + env.module_cname, + Naming.builtins_cname, + code.error_goto(self.pos))) + + def generate_string_init_code(self, env, code): + code.use_utility_code(Nodes.init_string_tab_utility_code) + code.putln( + "if (__Pyx_InitStrings(%s) < 0) %s;" % ( + Naming.stringtab_cname, + code.error_goto(self.pos))) + + def generate_global_init_code(self, env, code): + # Generate code to initialise global PyObject * + # variables to None. + for entry in env.var_entries: + if entry.visibility <> 'extern': + if entry.type.is_pyobject: + code.put_init_var_to_py_none(entry) + + def generate_pxd_function_export_code(self, env, code): + denv = env.definition_scope + for entry in denv.cfunc_entries: + if entry.visibility <> 'extern': + self.generate_c_function_export_code(env, entry, code) + + def generate_api_function_export_code(self, env, code): + for entry in env.cfunc_entries: + if entry.api: + self.generate_c_function_export_code(env, entry, code) + + def generate_c_function_export_code(self, env, entry, code): + code.use_utility_code(function_export_utility_code) + signature = entry.type.signature_string() + code.putln('if (__Pyx_ExportFunction("%s", (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: + #print "generate_type_import_code_for_module:", module ### + for entry in module.c_class_entries: + if entry.defined_in_pxd: + self.generate_type_import_code(env, entry.type, entry.pos, code) + + 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: + entries.append(entry) + if entries: + code.use_utility_code(import_module_utility_code) + code.use_utility_code(function_import_utility_code) + temp = self.module_temp_cname + code.putln( + '%s = __Pyx_ImportModule("%s"); if (!%s) %s' % ( + temp, + module.qualified_name, + temp, + code.error_goto(self.pos))) + for entry in entries: + code.putln( + 'if (__Pyx_ImportFunction(%s, "%s", (void**)&%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. + #print "generate_type_init_code:", env ### + denv = env.definition_scope + for entry in denv.c_class_entries + env.c_class_entries: + if entry.visibility == 'extern': + self.generate_type_import_code(env, entry.type, entry.pos, code) + else: + self.generate_base_type_import_code(env, entry, code) + self.generate_exttype_vtable_init_code(entry, code) + self.generate_type_ready_code(env, entry, code) + self.generate_typeptr_assignment_code(entry, code) + + def generate_base_type_import_code(self, env, entry, code): + base_type = entry.type.base_type + if base_type and base_type.module_name <> env.qualified_name: + self.generate_type_import_code(env, base_type, self.pos, code) + + def use_type_import_utility_code(self, code): + import ExprNodes + code.use_utility_code(type_import_utility_code) + code.use_utility_code(import_module_utility_code) + + def generate_type_import_code(self, env, type, pos, code): + # If not already done, generate code to import the typeobject of an + # extension type defined in another module, and extract its C method + # table pointer if any. + #print "generate_type_import_code:", type ### + if not type.is_builtin and type not in env.types_imported: + if type.typedef_flag: + objstruct = type.objstruct_cname + else: + objstruct = "struct %s" % type.objstruct_cname + self.generate_type_import_call(type, code, code.error_goto(pos)) + self.use_type_import_utility_code(code) + if type.vtabptr_cname: + code.putln( + "if (__Pyx_GetVtable(%s->tp_dict, &%s) < 0) %s" % ( + type.typeptr_cname, + type.vtabptr_cname, + code.error_goto(pos))) + code.use_utility_code(Nodes.get_vtable_utility_code) + env.types_imported[type] = 1 + + def generate_type_import_call(self, type, code, error_code): + if type.typedef_flag: + objstruct = type.objstruct_cname + else: + objstruct = "struct %s" % type.objstruct_cname + code.putln('%s = __Pyx_ImportType("%s", "%s", sizeof(%s)); if (!%s) %s' % ( + type.typeptr_cname, + type.module_name, + type.name, + objstruct, + type.typeptr_cname, + error_code)) + + def generate_type_ready_code(self, env, entry, code): + # Generate a call to PyType_Ready for an extension + # type defined in this module. + type = entry.type + typeobj_cname = type.typeobj_cname + scope = type.scope + if scope: # could be None if there was an error + if entry.visibility <> 'extern': + for slot in TypeSlots.slot_table: + slot.generate_dynamic_init_code(scope, code) + code.putln( + "if (PyType_Ready(&%s) < 0) %s" % ( + typeobj_cname, + code.error_goto(entry.pos))) + if type.vtable_cname: + code.putln( + "if (__Pyx_SetVtable(%s.tp_dict, %s) < 0) %s" % ( + typeobj_cname, + type.vtabptr_cname, + code.error_goto(entry.pos))) + code.use_utility_code(Nodes.set_vtable_utility_code) + code.putln( + 'if (PyObject_SetAttrString(%s, "%s", (PyObject *)&%s) < 0) %s' % ( + Naming.module_cname, + scope.class_name, + typeobj_cname, + code.error_goto(entry.pos))) + weakref_entry = scope.lookup_here("__weakref__") + if weakref_entry: + if weakref_entry.type is py_object_type: + tp_weaklistoffset = "%s.tp_weaklistoffset" % typeobj_cname + code.putln("if (%s == 0) %s = offsetof(struct %s, %s);" % ( + tp_weaklistoffset, + tp_weaklistoffset, + type.objstruct_cname, + weakref_entry.cname)) + else: + error(weakref_entry.pos, "__weakref__ slot must be of type 'object'") + + def generate_exttype_vtable_init_code(self, entry, code): + # Generate code to initialise the C method table of an + # extension type. + type = entry.type + if type.vtable_cname: + code.putln( + "%s = &%s;" % ( + type.vtabptr_cname, + type.vtable_cname)) + if type.base_type and type.base_type.vtabptr_cname: + code.putln( + "%s.%s = *%s;" % ( + type.vtable_cname, + Naming.obj_base_cname, + type.base_type.vtabptr_cname)) + for meth_entry in type.scope.cfunc_entries: + if meth_entry.func_cname: + code.putln( + "*(void(**)(void))&%s.%s = (void(*)(void))%s;" % ( + type.vtable_cname, + meth_entry.cname, + meth_entry.func_cname)) + + def generate_typeptr_assignment_code(self, entry, code): + # Generate code to initialise the typeptr of an extension + # type defined in this module to point to its type object. + type = entry.type + if type.typeobj_cname: + code.putln( + "%s = &%s;" % ( + type.typeptr_cname, type.typeobj_cname)) + + def generate_utility_functions(self, code): + code.global_state.generate_utility_functions(code) + +#------------------------------------------------------------------------------------ +# +# Runtime support code +# +#------------------------------------------------------------------------------------ + +import_module_utility_code = [ +""" +static PyObject *__Pyx_ImportModule(char *name); /*proto*/ +""",""" +#ifndef __PYX_HAVE_RT_ImportModule +#define __PYX_HAVE_RT_ImportModule +static PyObject *__Pyx_ImportModule(char *name) { + PyObject *py_name = 0; + + py_name = PyString_FromString(name); + if (!py_name) + goto bad; + return PyImport_Import(py_name); +bad: + Py_XDECREF(py_name); + return 0; +} +#endif +"""] + +#------------------------------------------------------------------------------------ + +type_import_utility_code = [ +""" +static PyTypeObject *__Pyx_ImportType(char *module_name, char *class_name, long size); /*proto*/ +""",r""" +#ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(char *module_name, char *class_name, + long size) +{ + PyObject *py_module = 0; + PyObject *result = 0; + + py_module = __Pyx_ImportModule(module_name); + if (!py_module) + goto bad; + result = PyObject_GetAttrString(py_module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%s.%s is not a type object", + module_name, class_name); + goto bad; + } +#ifdef __PYX_CHECK_IMPORTED_TYPES + if (((PyTypeObject *)result)->tp_basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%s.%s does not appear to be the correct type object", + module_name, class_name); + goto bad; + } +#endif + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return 0; +} +#endif +"""] + +#------------------------------------------------------------------------------------ + +function_export_utility_code = [ +""" +static int __Pyx_ExportFunction(char *n, void *f, char *s); /*proto*/ +""",r""" +static int __Pyx_ExportFunction(char *n, void *f, char *s) { + PyObject *d = 0; + PyObject *p = 0; + d = PyObject_GetAttrString(%(MODULE)s, "%(API)s"); + if (!d) { + PyErr_Clear(); + d = PyDict_New(); + if (!d) + goto bad; + Py_INCREF(d); + if (PyModule_AddObject(%(MODULE)s, "%(API)s", d) < 0) + goto bad; + } + p = PyCObject_FromVoidPtrAndDesc(f, s, 0); + if (!p) + goto bad; + if (PyDict_SetItemString(d, n, p) < 0) + goto bad; + Py_DECREF(p); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(p); + Py_XDECREF(d); + return -1; +} +""" % {'MODULE': Naming.module_cname, 'API': Naming.api_name}] + +#------------------------------------------------------------------------------------ + +function_import_utility_code = [ +""" +static int __Pyx_ImportFunction(PyObject *module, char *funcname, void **f, char *sig); /*proto*/ +""",""" +#ifndef __PYX_HAVE_RT_ImportFunction +#define __PYX_HAVE_RT_ImportFunction +static int __Pyx_ImportFunction(PyObject *module, char *funcname, void **f, char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + char *desc; + + d = PyObject_GetAttrString(module, "%(API)s"); + if (!d) + goto bad; + cobj = PyDict_GetItemString(d, funcname); + if (!cobj) { + PyErr_Format(PyExc_ImportError, + "%%s does not export expected C function %%s", + PyModule_GetName(module), funcname); + goto bad; + } + desc = (char *)PyCObject_GetDesc(cobj); + if (!desc) + goto bad; + if (strcmp(desc, sig) != 0) { + PyErr_Format(PyExc_TypeError, + "C function %%s.%%s has wrong signature (expected %%s, got %%s)", + PyModule_GetName(module), funcname, sig, desc); + goto bad; + } + *f = PyCObject_AsVoidPtr(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(d); + return -1; +} +#endif +""" % dict(API = Naming.api_name)] |