Cython/Compiler/ModuleNode.py

   1 #
   2 #   Pyrex - Module parse tree node
   3 #
   4
   5 import os, time
   6 from cStringIO import StringIO
   7 from PyrexTypes import CPtrType
   8
   9 try:
  10     set
  11 except NameError: # Python 2.3
  12     from sets import Set as set
  13
  14 import Annotate
  15 import Code
  16 import Naming
  17 import Nodes
  18 import Options
  19 import PyrexTypes
  20 import TypeSlots
  21 import Version
  22
  23 from Errors import error
  24 from PyrexTypes import py_object_type
  25 from Cython.Utils import open_new_file, replace_suffix
  26
  27
  28 class ModuleNode(Nodes.Node, Nodes.BlockNode):
  29     #  doc       string or None
  30     #  body      StatListNode
  31     #
  32     #  referenced_modules   [ModuleScope]
  33     #  module_temp_cname    string
  34     #  full_module_name     string
  35
  36     children_attrs = ["body"]
  37
  38     def analyse_declarations(self, env):
  39         if Options.embed_pos_in_docstring:
  40             env.doc = 'File: %s (starting at line %s)'%Nodes.relative_position(self.pos)
  41             if not self.doc is None:
  42                 env.doc = env.doc + '\\n' + self.doc
  43         else:
  44             env.doc = self.doc
  45         self.body.analyse_declarations(env)
  46
  47     def process_implementation(self, env, options, result):
  48         self.analyse_declarations(env)
  49         env.check_c_classes()
  50         self.body.analyse_expressions(env)
  51         env.return_type = PyrexTypes.c_void_type
  52         self.referenced_modules = []
  53         self.find_referenced_modules(env, self.referenced_modules, {})
  54         if self.has_imported_c_functions():
  55             self.module_temp_cname = env.allocate_temp_pyobject()
  56             env.release_temp(self.module_temp_cname)
  57         self.generate_c_code(env, options, result)
  58         self.generate_h_code(env, options, result)
  59         self.generate_api_code(env, result)
  60
  61     def has_imported_c_functions(self):
  62         for module in self.referenced_modules:
  63             for entry in module.cfunc_entries:
  64                 if entry.defined_in_pxd:
  65                     return 1
  66         return 0
  67
  68     def generate_h_code(self, env, options, result):
  69         def h_entries(entries, pxd = 0):
  70             return [entry for entry in entries
  71                 if entry.visibility == 'public' or pxd and entry.defined_in_pxd]
  72         h_types = h_entries(env.type_entries)
  73         h_vars = h_entries(env.var_entries)
  74         h_funcs = h_entries(env.cfunc_entries)
  75         h_extension_types = h_entries(env.c_class_entries)
  76         if h_types or h_vars or h_funcs or h_extension_types:
  77             result.h_file = replace_suffix(result.c_file, ".h")
  78             h_code = Code.CCodeWriter(open_new_file(result.h_file))
  79             if options.generate_pxi:
  80                 result.i_file = replace_suffix(result.c_file, ".pxi")
  81                 i_code = Code.PyrexCodeWriter(result.i_file)
  82             else:
  83                 i_code = None
  84             guard = Naming.h_guard_prefix + env.qualified_name.replace(".", "__")
  85             h_code.put_h_guard(guard)
  86             self.generate_extern_c_macro_definition(h_code)
  87             self.generate_type_header_code(h_types, h_code)
  88             h_code.putln("")
  89             h_code.putln("#ifndef %s" % Naming.api_guard_prefix + self.api_name(env))
  90             if h_vars:
  91                 h_code.putln("")
  92                 for entry in h_vars:
  93                     self.generate_public_declaration(entry, h_code, i_code)
  94             if h_funcs:
  95                 h_code.putln("")
  96                 for entry in h_funcs:
  97                     self.generate_public_declaration(entry, h_code, i_code)
  98             if h_extension_types:
  99                 h_code.putln("")
 100                 for entry in h_extension_types:
 101                     self.generate_cclass_header_code(entry.type, h_code)
 102                     if i_code:
 103                         self.generate_cclass_include_code(entry.type, i_code)
 104             h_code.putln("")
 105             h_code.putln("#endif")
 106             h_code.putln("")
 107             h_code.putln("PyMODINIT_FUNC init%s(void);" % env.module_name)
 108             h_code.putln("")
 109             h_code.putln("#endif")
 110
 111     def generate_public_declaration(self, entry, h_code, i_code):
 112         h_code.putln("%s %s;" % (
 113             Naming.extern_c_macro,
 114             entry.type.declaration_code(
 115                 entry.cname, dll_linkage = "DL_IMPORT")))
 116         if i_code:
 117             i_code.putln("cdef extern %s" %
 118                 entry.type.declaration_code(entry.cname, pyrex = 1))
 119
 120     def api_name(self, env):
 121         return env.qualified_name.replace(".", "__")
 122
 123     def generate_api_code(self, env, result):
 124         api_funcs = []
 125         public_extension_types = []
 126         has_api_extension_types = 0
 127         for entry in env.cfunc_entries:
 128             if entry.api:
 129                 api_funcs.append(entry)
 130         for entry in env.c_class_entries:
 131             if entry.visibility == 'public':
 132                 public_extension_types.append(entry)
 133             if entry.api:
 134                 has_api_extension_types = 1
 135         if api_funcs or has_api_extension_types:
 136             result.api_file = replace_suffix(result.c_file, "_api.h")
 137             h_code = Code.CCodeWriter(open_new_file(result.api_file))
 138             name = self.api_name(env)
 139             guard = Naming.api_guard_prefix + name
 140             h_code.put_h_guard(guard)
 141             h_code.putln('#include "Python.h"')
 142             if result.h_file:
 143                 h_code.putln('#include "%s"' % os.path.basename(result.h_file))
 144             for entry in public_extension_types:
 145                 type = entry.type
 146                 h_code.putln("")
 147                 h_code.putln("static PyTypeObject *%s;" % type.typeptr_cname)
 148                 h_code.putln("#define %s (*%s)" % (
 149                     type.typeobj_cname, type.typeptr_cname))
 150             if api_funcs:
 151                 h_code.putln("")
 152                 for entry in api_funcs:
 153                     type = CPtrType(entry.type)
 154                     h_code.putln("static %s;" % type.declaration_code(entry.cname))
 155             h_code.putln("")
 156             h_code.put_h_guard(Naming.api_func_guard + "import_module")
 157             h_code.put(import_module_utility_code[1])
 158             h_code.putln("")
 159             h_code.putln("#endif")
 160             if api_funcs:
 161                 h_code.putln("")
 162                 h_code.put(function_import_utility_code[1])
 163             if public_extension_types:
 164                 h_code.putln("")
 165                 h_code.put(type_import_utility_code[1])
 166             h_code.putln("")
 167             h_code.putln("static int import_%s(void) {" % name)
 168             h_code.putln("PyObject *module = 0;")
 169             h_code.putln('module = __Pyx_ImportModule("%s");' % env.qualified_name)
 170             h_code.putln("if (!module) goto bad;")
 171             for entry in api_funcs:
 172                 sig = entry.type.signature_string()
 173                 h_code.putln(
 174                     'if (__Pyx_ImportFunction(module, "%s", (void**)&%s, "%s") < 0) goto bad;' % (
 175                         entry.name,
 176                         entry.cname,
 177                         sig))
 178             h_code.putln("Py_DECREF(module); module = 0;")
 179             for entry in public_extension_types:
 180                 self.generate_type_import_call(
 181                     entry.type, h_code,
 182                     "if (!%s) goto bad;" % entry.type.typeptr_cname)
 183             h_code.putln("return 0;")
 184             h_code.putln("bad:")
 185             h_code.putln("Py_XDECREF(module);")
 186             h_code.putln("return -1;")
 187             h_code.putln("}")
 188             h_code.putln("")
 189             h_code.putln("#endif")
 190
 191     def generate_cclass_header_code(self, type, h_code):
 192         h_code.putln("%s DL_IMPORT(PyTypeObject) %s;" % (
 193             Naming.extern_c_macro,
 194             type.typeobj_cname))
 195         #self.generate_obj_struct_definition(type, h_code)
 196
 197     def generate_cclass_include_code(self, type, i_code):
 198         i_code.putln("cdef extern class %s.%s:" % (
 199             type.module_name, type.name))
 200         i_code.indent()
 201         var_entries = type.scope.var_entries
 202         if var_entries:
 203             for entry in var_entries:
 204                 i_code.putln("cdef %s" %
 205                     entry.type.declaration_code(entry.cname, pyrex = 1))
 206         else:
 207             i_code.putln("pass")
 208         i_code.dedent()
 209
 210     def generate_c_code(self, env, options, result):
 211         modules = self.referenced_modules
 212         if Options.annotate or options.annotate:
 213             code = Annotate.AnnotationCCodeWriter(StringIO())
 214         else:
 215             code = Code.CCodeWriter(StringIO())
 216         code.h = Code.CCodeWriter(StringIO())
 217         code.init_labels()
 218         self.generate_module_preamble(env, modules, code.h)
 219
 220         code.putln("")
 221         code.putln("/* Implementation of %s */" % env.qualified_name)
 222         self.generate_const_definitions(env, code)
 223         self.generate_interned_num_decls(env, code)
 224         self.generate_interned_string_decls(env, code)
 225         self.generate_py_string_decls(env, code)
 226         self.generate_cached_builtins_decls(env, code)
 227         self.body.generate_function_definitions(env, code, options.transforms)
 228         code.mark_pos(None)
 229         self.generate_py_string_table(env, code)
 230         self.generate_typeobj_definitions(env, code)
 231         self.generate_method_table(env, code)
 232         self.generate_filename_init_prototype(code)
 233         self.generate_module_init_func(modules[:-1], env, code)
 234         code.mark_pos(None)
 235         self.generate_module_cleanup_func(env, code)
 236         self.generate_filename_table(code)
 237         self.generate_utility_functions(env, code)
 238
 239         self.generate_declarations_for_modules(env, modules, code.h)
 240
 241         f = open_new_file(result.c_file)
 242         f.write(code.h.f.getvalue())
 243         f.write("\n")
 244         f.write(code.f.getvalue())
 245         f.close()
 246         result.c_file_generated = 1
 247         if Options.annotate or options.annotate:
 248             self.annotate(code)
 249             code.save_annotation(result.main_source_file, result.c_file)
 250
 251     def find_referenced_modules(self, env, module_list, modules_seen):
 252         if env not in modules_seen:
 253             modules_seen[env] = 1
 254             for imported_module in env.cimported_modules:
 255                 self.find_referenced_modules(imported_module, module_list, modules_seen)
 256             module_list.append(env)
 257
 258     def sort_types_by_inheritance(self, type_dict, getkey):
 259         # copy the types into a list moving each parent type before
 260         # its first child
 261         type_items = type_dict.items()
 262         type_list = []
 263         for i, item in enumerate(type_items):
 264             key, new_entry = item
 265
 266             # collect all base classes to check for children
 267             hierarchy = set()
 268             base = new_entry
 269             while base:
 270                 base_type = base.type.base_type
 271                 if not base_type:
 272                     break
 273                 base_key = getkey(base_type)
 274                 hierarchy.add(base_key)
 275                 base = type_dict.get(base_key)
 276             new_entry.base_keys = hierarchy
 277
 278             # find the first (sub-)subclass and insert before that
 279             for j in range(i):
 280                 entry = type_list[j]
 281                 if key in entry.base_keys:
 282                     type_list.insert(j, new_entry)
 283                     break
 284             else:
 285                 type_list.append(new_entry)
 286         return type_list
 287
 288     def sort_type_hierarchy(self, module_list, env):
 289         vtab_dict = {}
 290         vtabslot_dict = {}
 291         for module in module_list:
 292             for entry in module.c_class_entries:
 293                 if not entry.in_cinclude:
 294                     type = entry.type
 295                     if type.vtabstruct_cname:
 296                         vtab_dict[type.vtabstruct_cname] = entry
 297             all_defined_here = module is env
 298             for entry in module.type_entries:
 299                 if all_defined_here or entry.defined_in_pxd:
 300                     type = entry.type
 301                     if type.is_extension_type and not entry.in_cinclude:
 302                         type = entry.type
 303                         vtabslot_dict[type.objstruct_cname] = entry
 304
 305         def vtabstruct_cname(entry_type):
 306             return entry_type.vtabstruct_cname
 307         vtab_list = self.sort_types_by_inheritance(
 308             vtab_dict, vtabstruct_cname)
 309
 310         def objstruct_cname(entry_type):
 311             return entry_type.objstruct_cname
 312         vtabslot_list = self.sort_types_by_inheritance(
 313             vtabslot_dict, objstruct_cname)
 314
 315         return (vtab_list, vtabslot_list)
 316
 317     def generate_type_definitions(self, env, modules, vtab_list, vtabslot_list, code):
 318         vtabslot_entries = set(vtabslot_list)
 319         for module in modules:
 320             definition = module is env
 321             if definition:
 322                 type_entries = module.type_entries
 323             else:
 324                 type_entries = []
 325                 for entry in module.type_entries:
 326                     if entry.defined_in_pxd:
 327                         type_entries.append(entry)
 328             for entry in type_entries:
 329                 if not entry.in_cinclude:
 330                     #print "generate_type_header_code:", entry.name, repr(entry.type) ###
 331                     type = entry.type
 332                     if type.is_typedef: # Must test this first!
 333                         self.generate_typedef(entry, code)
 334                     elif type.is_struct_or_union:
 335                         self.generate_struct_union_definition(entry, code)
 336                     elif type.is_enum:
 337                         self.generate_enum_definition(entry, code)
 338                     elif type.is_extension_type and entry not in vtabslot_entries:
 339                         self.generate_obj_struct_definition(type, code)
 340         for entry in vtabslot_list:
 341             self.generate_obj_struct_definition(entry.type, code)
 342         for entry in vtab_list:
 343             self.generate_typeobject_predeclaration(entry, code)
 344             self.generate_exttype_vtable_struct(entry, code)
 345             self.generate_exttype_vtabptr_declaration(entry, code)
 346
 347     def generate_declarations_for_modules(self, env, modules, code):
 348         code.putln("")
 349         code.putln("/* Declarations */")
 350         vtab_list, vtabslot_list = self.sort_type_hierarchy(modules, env)
 351         self.generate_type_definitions(
 352             env, modules, vtab_list, vtabslot_list, code)
 353         for module in modules:
 354             defined_here = module is env
 355             self.generate_global_declarations(module, code, defined_here)
 356             self.generate_cfunction_predeclarations(module, code, defined_here)
 357
 358     def generate_module_preamble(self, env, cimported_modules, code):
 359         code.putln('/* Generated by Cython %s on %s */' % (
 360             Version.version, time.asctime()))
 361         code.putln('')
 362         code.putln('#define PY_SSIZE_T_CLEAN')
 363         for filename in env.python_include_files:
 364             code.putln('#include "%s"' % filename)
 365         code.putln("#ifndef PY_LONG_LONG")
 366         code.putln("  #define PY_LONG_LONG LONG_LONG")
 367         code.putln("#endif")
 368         code.putln("#ifndef DL_EXPORT")
 369         code.putln("  #define DL_EXPORT(t) t")
 370         code.putln("#endif")
 371         code.putln("#if PY_VERSION_HEX < 0x02040000")
 372         code.putln("  #define METH_COEXIST 0")
 373         code.putln("#endif")
 374
 375         code.putln("#if PY_VERSION_HEX < 0x02050000")
 376         code.putln("  typedef int Py_ssize_t;")
 377         code.putln("  #define PY_SSIZE_T_MAX INT_MAX")
 378         code.putln("  #define PY_SSIZE_T_MIN INT_MIN")
 379         code.putln("  #define PyInt_FromSsize_t(z) PyInt_FromLong(z)")
 380         code.putln("  #define PyInt_AsSsize_t(o)   PyInt_AsLong(o)")
 381         code.putln("  #define PyNumber_Index(o)    PyNumber_Int(o)")
 382         code.putln("  #define PyIndex_Check(o)     PyNumber_Check(o)")
 383         code.putln("#endif")
 384
 385         code.putln("#if PY_VERSION_HEX < 0x02060000")
 386         code.putln("  #define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)")
 387         code.putln("  #define Py_TYPE(ob)   (((PyObject*)(ob))->ob_type)")
 388         code.putln("  #define Py_SIZE(ob)   ((PyVarObject*)(ob))->ob_size)")
 389         code.putln("  #define PyVarObject_HEAD_INIT(type, size) \\")
 390         code.putln("          PyObject_HEAD_INIT(type) size,")
 391         code.putln("#endif")
 392
 393         code.put(builtin_module_name_utility_code[0])
 394
 395         code.putln("#if PY_MAJOR_VERSION >= 3")
 396         code.putln("  #define Py_TPFLAGS_CHECKTYPES 0")
 397         code.putln("  #define Py_TPFLAGS_HAVE_INDEX 0")
 398         code.putln("#endif")
 399
 400         code.putln("#if PY_MAJOR_VERSION >= 3")
 401         code.putln("  #define PyInt_Type                   PyLong_Type")
 402         code.putln("  #define PyInt_Check(op)              PyLong_Check(op)")
 403         code.putln("  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)")
 404         code.putln("  #define PyInt_FromString             PyLong_FromString")
 405         code.putln("  #define PyInt_FromUnicode            PyLong_FromUnicode")
 406         code.putln("  #define PyInt_FromLong               PyLong_FromLong")
 407         code.putln("  #define PyInt_FromSize_t             PyLong_FromSize_t")
 408         code.putln("  #define PyInt_FromSsize_t            PyLong_FromSsize_t")
 409         code.putln("  #define PyInt_AsLong                 PyLong_AsLong")
 410         code.putln("  #define PyInt_AS_LONG                PyLong_AS_LONG")
 411         code.putln("  #define PyInt_AsSsize_t              PyLong_AsSsize_t")
 412         code.putln("  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask")
 413         code.putln("  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask")
 414         code.putln("#endif")
 415
 416         code.putln("#if PY_MAJOR_VERSION >= 3")
 417         code.putln("  #define PyBaseString_Type            PyUnicode_Type")
 418         code.putln("#endif")
 419
 420         code.putln("#if PY_MAJOR_VERSION >= 3")
 421         code.putln("  #define PyMethod_New(func, self, klass) (func!=NULL?(Py_INCREF(func),func):NULL)")
 422         code.putln("#endif")
 423
 424         code.putln("#ifndef __stdcall")
 425         code.putln("  #define __stdcall")
 426         code.putln("#endif")
 427         code.putln("#ifndef __cdecl")
 428         code.putln("  #define __cdecl")
 429         code.putln("#endif")
 430         self.generate_extern_c_macro_definition(code)
 431         code.putln("#include <math.h>")
 432         self.generate_includes(env, cimported_modules, code)
 433         code.putln('')
 434         code.put(Nodes.utility_function_predeclarations)
 435         code.put(PyrexTypes.type_conversion_predeclarations)
 436         code.put(Nodes.branch_prediction_macros)
 437         code.putln('')
 438         code.putln('static PyObject *%s;' % env.module_cname)
 439         code.putln('static PyObject *%s;' % Naming.builtins_cname)
 440         code.putln('static PyObject *%s;' % Naming.empty_tuple)
 441         if Options.pre_import is not None:
 442             code.putln('static PyObject *%s;' % Naming.preimport_cname)
 443         code.putln('static int %s;' % Naming.lineno_cname)
 444         code.putln('static int %s = 0;' % Naming.clineno_cname)
 445         code.putln('static char * %s= %s;' % (Naming.cfilenm_cname, Naming.file_c_macro))
 446         code.putln('static char *%s;' % Naming.filename_cname)
 447         code.putln('static char **%s;' % Naming.filetable_cname)
 448         if env.doc:
 449             code.putln('')
 450             code.putln('static char %s[] = "%s";' % (env.doc_cname, env.doc))
 451
 452     def generate_extern_c_macro_definition(self, code):
 453         name = Naming.extern_c_macro
 454         code.putln("#ifdef __cplusplus")
 455         code.putln('#define %s extern "C"' % name)
 456         code.putln("#else")
 457         code.putln("#define %s extern" % name)
 458         code.putln("#endif")
 459
 460     def generate_includes(self, env, cimported_modules, code):
 461         includes = env.include_files[:]
 462         for module in cimported_modules:
 463             for filename in module.include_files:
 464                 if filename not in includes:
 465                     includes.append(filename)
 466         for filename in includes:
 467             code.putln('#include "%s"' % filename)
 468
 469     def generate_filename_table(self, code):
 470         code.putln("")
 471         code.putln("static char *%s[] = {" % Naming.filenames_cname)
 472         if code.filename_list:
 473             for filename in code.filename_list:
 474                 filename = os.path.basename(filename)
 475                 escaped_filename = filename.replace("\\", "\\\\").replace('"', r'\"')
 476                 code.putln('"%s",' %
 477                     escaped_filename)
 478         else:
 479             # Some C compilers don't like an empty array
 480             code.putln("0")
 481         code.putln("};")
 482
 483     def generate_type_predeclarations(self, env, code):
 484         pass
 485
 486     def generate_type_header_code(self, type_entries, code):
 487         # Generate definitions of structs/unions/enums/typedefs/objstructs.
 488         #self.generate_gcc33_hack(env, code) # Is this still needed?
 489         #for entry in env.type_entries:
 490         for entry in type_entries:
 491             if not entry.in_cinclude:
 492                 #print "generate_type_header_code:", entry.name, repr(entry.type) ###
 493                 type = entry.type
 494                 if type.is_typedef: # Must test this first!
 495                     self.generate_typedef(entry, code)
 496                 elif type.is_struct_or_union:
 497                     self.generate_struct_union_definition(entry, code)
 498                 elif type.is_enum:
 499                     self.generate_enum_definition(entry, code)
 500                 elif type.is_extension_type:
 501                     self.generate_obj_struct_definition(type, code)
 502
 503     def generate_gcc33_hack(self, env, code):
 504         # Workaround for spurious warning generation in gcc 3.3
 505         code.putln("")
 506         for entry in env.c_class_entries:
 507             type = entry.type
 508             if not type.typedef_flag:
 509                 name = type.objstruct_cname
 510                 if name.startswith("__pyx_"):
 511                     tail = name[6:]
 512                 else:
 513                     tail = name
 514                 code.putln("typedef struct %s __pyx_gcc33_%s;" % (
 515                     name, tail))
 516
 517     def generate_typedef(self, entry, code):
 518         base_type = entry.type.typedef_base_type
 519         code.putln("")
 520         code.putln("typedef %s;" % base_type.declaration_code(entry.cname))
 521
 522     def sue_header_footer(self, type, kind, name):
 523         if type.typedef_flag:
 524             header = "typedef %s {" % kind
 525             footer = "} %s;" % name
 526         else:
 527             header = "%s %s {" % (kind, name)
 528             footer = "};"
 529         return header, footer
 530
 531     def generate_struct_union_definition(self, entry, code):
 532         code.mark_pos(entry.pos)
 533         type = entry.type
 534         scope = type.scope
 535         if scope:
 536             header, footer = \
 537                 self.sue_header_footer(type, type.kind, type.cname)
 538             code.putln("")
 539             code.putln(header)
 540             var_entries = scope.var_entries
 541             if not var_entries:
 542                 error(entry.pos,
 543                     "Empty struct or union definition not allowed outside a"
 544                     " 'cdef extern from' block")
 545             for attr in var_entries:
 546                 code.putln(
 547                     "%s;" %
 548                         attr.type.declaration_code(attr.cname))
 549             code.putln(footer)
 550
 551     def generate_enum_definition(self, entry, code):
 552         code.mark_pos(entry.pos)
 553         type = entry.type
 554         name = entry.cname or entry.name or ""
 555         header, footer = \
 556             self.sue_header_footer(type, "enum", name)
 557         code.putln("")
 558         code.putln(header)
 559         enum_values = entry.enum_values
 560         if not enum_values:
 561             error(entry.pos,
 562                 "Empty enum definition not allowed outside a"
 563                 " 'cdef extern from' block")
 564         else:
 565             last_entry = enum_values[-1]
 566             for value_entry in enum_values:
 567                 if value_entry.value == value_entry.name:
 568                     value_code = value_entry.cname
 569                 else:
 570                     value_code = ("%s = %s" % (
 571                         value_entry.cname,
 572                         value_entry.value))
 573                 if value_entry is not last_entry:
 574                     value_code += ","
 575                 code.putln(value_code)
 576         code.putln(footer)
 577
 578     def generate_typeobject_predeclaration(self, entry, code):
 579         code.putln("")
 580         name = entry.type.typeobj_cname
 581         if name:
 582             if entry.visibility == 'extern' and not entry.in_cinclude:
 583                 code.putln("%s DL_IMPORT(PyTypeObject) %s;" % (
 584                     Naming.extern_c_macro,
 585                     name))
 586             elif entry.visibility == 'public':
 587                 #code.putln("DL_EXPORT(PyTypeObject) %s;" % name)
 588                 code.putln("%s DL_EXPORT(PyTypeObject) %s;" % (
 589                     Naming.extern_c_macro,
 590                     name))
 591             # ??? Do we really need the rest of this? ???
 592             #else:
 593             #   code.putln("staticforward PyTypeObject %s;" % name)
 594
 595     def generate_exttype_vtable_struct(self, entry, code):
 596         code.mark_pos(entry.pos)
 597         # Generate struct declaration for an extension type's vtable.
 598         type = entry.type
 599         scope = type.scope
 600         if type.vtabstruct_cname:
 601             code.putln("")
 602             code.putln(
 603                 "struct %s {" %
 604                     type.vtabstruct_cname)
 605             if type.base_type and type.base_type.vtabstruct_cname:
 606                 code.putln("struct %s %s;" % (
 607                     type.base_type.vtabstruct_cname,
 608                     Naming.obj_base_cname))
 609             for method_entry in scope.cfunc_entries:
 610                 if not method_entry.is_inherited:
 611                     code.putln(
 612                         "%s;" % method_entry.type.declaration_code("(*%s)" % method_entry.name))
 613             code.putln(
 614                 "};")
 615
 616     def generate_exttype_vtabptr_declaration(self, entry, code):
 617         code.mark_pos(entry.pos)
 618         # Generate declaration of pointer to an extension type's vtable.
 619         type = entry.type
 620         if type.vtabptr_cname:
 621             code.putln("static struct %s *%s;" % (
 622                 type.vtabstruct_cname,
 623                 type.vtabptr_cname))
 624
 625     def generate_obj_struct_definition(self, type, code):
 626         code.mark_pos(type.pos)
 627         # Generate object struct definition for an
 628         # extension type.
 629         if not type.scope:
 630             return # Forward declared but never defined
 631         header, footer = \
 632             self.sue_header_footer(type, "struct", type.objstruct_cname)
 633         code.putln("")
 634         code.putln(header)
 635         base_type = type.base_type
 636         if base_type:
 637             code.putln(
 638                 "%s%s %s;" % (
 639                     ("struct ", "")[base_type.typedef_flag],
 640                     base_type.objstruct_cname,
 641                     Naming.obj_base_cname))
 642         else:
 643             code.putln(
 644                 "PyObject_HEAD")
 645         if type.vtabslot_cname and not (type.base_type and type.base_type.vtabslot_cname):
 646             code.putln(
 647                 "struct %s *%s;" % (
 648                     type.vtabstruct_cname,
 649                     type.vtabslot_cname))
 650         for attr in type.scope.var_entries:
 651             code.putln(
 652                 "%s;" %
 653                     attr.type.declaration_code(attr.cname))
 654         code.putln(footer)
 655
 656     def generate_global_declarations(self, env, code, definition):
 657         code.putln("")
 658         for entry in env.c_class_entries:
 659             if definition or entry.defined_in_pxd:
 660                 code.putln("static PyTypeObject *%s = 0;" %
 661                     entry.type.typeptr_cname)
 662         code.put_var_declarations(env.var_entries, static = 1,
 663             dll_linkage = "DL_EXPORT", definition = definition)
 664         code.put_var_declarations(env.default_entries, static = 1,
 665                                   definition = definition)
 666
 667     def generate_cfunction_predeclarations(self, env, code, definition):
 668         for entry in env.cfunc_entries:
 669             if not entry.in_cinclude and (definition
 670                     or entry.defined_in_pxd or entry.visibility == 'extern'):
 671                 if entry.visibility in ('public', 'extern'):
 672                     dll_linkage = "DL_EXPORT"
 673                 else:
 674                     dll_linkage = None
 675                 type = entry.type
 676                 if not definition and entry.defined_in_pxd:
 677                     type = CPtrType(type)
 678                 header = type.declaration_code(entry.cname,
 679                     dll_linkage = dll_linkage)
 680                 if entry.visibility == 'private':
 681                     storage_class = "static "
 682                 elif entry.visibility == 'extern':
 683                     storage_class = "%s " % Naming.extern_c_macro
 684                 else:
 685                     storage_class = ""
 686                 code.putln("%s%s; /*proto*/" % (
 687                     storage_class,
 688                     header))
 689
 690     def generate_typeobj_definitions(self, env, code):
 691         full_module_name = env.qualified_name
 692         for entry in env.c_class_entries:
 693             #print "generate_typeobj_definitions:", entry.name
 694             #print "...visibility =", entry.visibility
 695             if entry.visibility != 'extern':
 696                 type = entry.type
 697                 scope = type.scope
 698                 if scope: # could be None if there was an error
 699                     self.generate_exttype_vtable(scope, code)
 700                     self.generate_new_function(scope, code)
 701                     self.generate_dealloc_function(scope, code)
 702                     if scope.needs_gc():
 703                         self.generate_traverse_function(scope, code)
 704                         self.generate_clear_function(scope, code)
 705                     if scope.defines_any(["__getitem__"]):
 706                         self.generate_getitem_int_function(scope, code)
 707                     if scope.defines_any(["__setitem__", "__delitem__"]):
 708                         self.generate_ass_subscript_function(scope, code)
 709                     if scope.defines_any(["__setslice__", "__delslice__"]):
 710                         self.generate_ass_slice_function(scope, code)
 711                     if scope.defines_any(["__getattr__","__getattribute__"]):
 712                         self.generate_getattro_function(scope, code)
 713                     if scope.defines_any(["__setattr__", "__delattr__"]):
 714                         self.generate_setattro_function(scope, code)
 715                     if scope.defines_any(["__get__"]):
 716                         self.generate_descr_get_function(scope, code)
 717                     if scope.defines_any(["__set__", "__delete__"]):
 718                         self.generate_descr_set_function(scope, code)
 719                     self.generate_property_accessors(scope, code)
 720                     self.generate_method_table(scope, code)
 721                     self.generate_member_table(scope, code)
 722                     self.generate_getset_table(scope, code)
 723                     self.generate_typeobj_definition(full_module_name, entry, code)
 724
 725     def generate_exttype_vtable(self, scope, code):
 726         # Generate the definition of an extension type's vtable.
 727         type = scope.parent_type
 728         if type.vtable_cname:
 729             code.putln("static struct %s %s;" % (
 730                 type.vtabstruct_cname,
 731                 type.vtable_cname))
 732
 733     def generate_self_cast(self, scope, code):
 734         type = scope.parent_type
 735         code.putln(
 736             "%s = (%s)o;" % (
 737                 type.declaration_code("p"),
 738                 type.declaration_code("")))
 739
 740     def generate_new_function(self, scope, code):
 741         tp_slot = TypeSlots.ConstructorSlot("tp_new", '__new__')
 742         slot_func = scope.mangle_internal("tp_new")
 743         type = scope.parent_type
 744         base_type = type.base_type
 745         py_attrs = []
 746         for entry in scope.var_entries:
 747             if entry.type.is_pyobject:
 748                 py_attrs.append(entry)
 749         need_self_cast = type.vtabslot_cname or py_attrs
 750         code.putln("")
 751         code.putln(
 752             "static PyObject *%s(PyTypeObject *t, PyObject *a, PyObject *k) {"
 753                 % scope.mangle_internal("tp_new"))
 754         if need_self_cast:
 755             code.putln(
 756                 "%s;"
 757                     % scope.parent_type.declaration_code("p"))
 758         if base_type:
 759             tp_new = TypeSlots.get_base_slot_function(scope, tp_slot)
 760             if tp_new is None:
 761                 tp_new = "%s->tp_new" % base_type.typeptr_cname
 762             code.putln(
 763                 "PyObject *o = %s(t, a, k);" % tp_new)
 764         else:
 765             code.putln(
 766                 "PyObject *o = (*t->tp_alloc)(t, 0);")
 767         code.putln(
 768                 "if (!o) return 0;")
 769         if need_self_cast:
 770             code.putln(
 771                 "p = %s;"
 772                     % type.cast_code("o"))
 773         #if need_self_cast:
 774         #       self.generate_self_cast(scope, code)
 775         if type.vtabslot_cname:
 776             code.putln("*(struct %s **)&p->%s = %s;" % (
 777                 type.vtabstruct_cname,
 778                 type.vtabslot_cname,
 779                 type.vtabptr_cname))
 780         for entry in py_attrs:
 781             if entry.name == "__weakref__":
 782                 code.putln("p->%s = 0;" % entry.cname)
 783             else:
 784                 code.put_init_var_to_py_none(entry, "p->%s")
 785         entry = scope.lookup_here("__new__")
 786         if entry:
 787             if entry.trivial_signature:
 788                 cinit_args = "o, %s, NULL" % Naming.empty_tuple
 789             else:
 790                 cinit_args = "o, a, k"
 791             code.putln(
 792                 "if (%s(%s) < 0) {" %
 793                     (entry.func_cname, cinit_args))
 794             code.put_decref_clear("o", py_object_type);
 795             code.putln(
 796                 "}")
 797         code.putln(
 798             "return o;")
 799         code.putln(
 800             "}")
 801
 802     def generate_dealloc_function(self, scope, code):
 803         tp_slot = TypeSlots.ConstructorSlot("tp_dealloc", '__dealloc__')
 804         slot_func = scope.mangle_internal("tp_dealloc")
 805         base_type = scope.parent_type.base_type
 806         if tp_slot.slot_code(scope) != slot_func:
 807             return # never used
 808         code.putln("")
 809         code.putln(
 810             "static void %s(PyObject *o) {"
 811                 % scope.mangle_internal("tp_dealloc"))
 812         py_attrs = []
 813         weakref_slot = scope.lookup_here("__weakref__")
 814         for entry in scope.var_entries:
 815             if entry.type.is_pyobject and entry is not weakref_slot:
 816                 py_attrs.append(entry)
 817         if py_attrs or weakref_slot in scope.var_entries:
 818             self.generate_self_cast(scope, code)
 819         self.generate_usr_dealloc_call(scope, code)
 820         if weakref_slot in scope.var_entries:
 821             code.putln("if (p->__weakref__) PyObject_ClearWeakRefs(o);")
 822         for entry in py_attrs:
 823             code.put_xdecref("p->%s" % entry.cname, entry.type)
 824         if base_type:
 825             tp_dealloc = TypeSlots.get_base_slot_function(scope, tp_slot)
 826             if tp_dealloc is None:
 827                 tp_dealloc = "%s->tp_dealloc" % base_type.typeptr_cname
 828             code.putln(
 829                     "%s(o);" % tp_dealloc)
 830         else:
 831             code.putln(
 832                     "(*Py_TYPE(o)->tp_free)(o);")
 833         code.putln(
 834             "}")
 835
 836     def generate_usr_dealloc_call(self, scope, code):
 837         entry = scope.lookup_here("__dealloc__")
 838         if entry:
 839             code.putln(
 840                 "{")
 841             code.putln(
 842                     "PyObject *etype, *eval, *etb;")
 843             code.putln(
 844                     "PyErr_Fetch(&etype, &eval, &etb);")
 845             code.putln(
 846                     "++Py_REFCNT(o);")
 847             code.putln(
 848                     "%s(o);" %
 849                         entry.func_cname)
 850             code.putln(
 851                     "if (PyErr_Occurred()) PyErr_WriteUnraisable(o);")
 852             code.putln(
 853                     "--Py_REFCNT(o);")
 854             code.putln(
 855                     "PyErr_Restore(etype, eval, etb);")
 856             code.putln(
 857                 "}")
 858
 859     def generate_traverse_function(self, scope, code):
 860         tp_slot = TypeSlots.GCDependentSlot("tp_traverse")
 861         slot_func = scope.mangle_internal("tp_traverse")
 862         base_type = scope.parent_type.base_type
 863         if tp_slot.slot_code(scope) != slot_func:
 864             return # never used
 865         code.putln("")
 866         code.putln(
 867             "static int %s(PyObject *o, visitproc v, void *a) {"
 868                 % slot_func)
 869         py_attrs = []
 870         for entry in scope.var_entries:
 871             if entry.type.is_pyobject and entry.name != "__weakref__":
 872                 py_attrs.append(entry)
 873         if base_type or py_attrs:
 874             code.putln("int e;")
 875         if py_attrs:
 876             self.generate_self_cast(scope, code)
 877         if base_type:
 878             # want to call it explicitly if possible so inlining can be performed
 879             static_call = TypeSlots.get_base_slot_function(scope, tp_slot)
 880             if static_call:
 881                 code.putln("e = %s(o, v, a); if (e) return e;" % static_call)
 882             else:
 883                 code.putln("if (%s->tp_traverse) {" % base_type.typeptr_cname)
 884                 code.putln(
 885                         "e = %s->tp_traverse(o, v, a); if (e) return e;" %
 886                             base_type.typeptr_cname)
 887                 code.putln("}")
 888         for entry in py_attrs:
 889             var_code = "p->%s" % entry.cname
 890             code.putln(
 891                     "if (%s) {"
 892                         % var_code)
 893             if entry.type.is_extension_type:
 894                 var_code = "((PyObject*)%s)" % var_code
 895             code.putln(
 896                         "e = (*v)(%s, a); if (e) return e;"
 897                             % var_code)
 898             code.putln(
 899                     "}")
 900         code.putln(
 901                 "return 0;")
 902         code.putln(
 903             "}")
 904
 905     def generate_clear_function(self, scope, code):
 906         tp_slot = TypeSlots.GCDependentSlot("tp_clear")
 907         slot_func = scope.mangle_internal("tp_clear")
 908         base_type = scope.parent_type.base_type
 909         if tp_slot.slot_code(scope) != slot_func:
 910             return # never used
 911         code.putln("")
 912         code.putln("static int %s(PyObject *o) {" % slot_func)
 913         py_attrs = []
 914         for entry in scope.var_entries:
 915             if entry.type.is_pyobject and entry.name != "__weakref__":
 916                 py_attrs.append(entry)
 917         if py_attrs:
 918             self.generate_self_cast(scope, code)
 919             code.putln("PyObject* tmp;")
 920         if base_type:
 921             # want to call it explicitly if possible so inlining can be performed
 922             static_call = TypeSlots.get_base_slot_function(scope, tp_slot)
 923             if static_call:
 924                 code.putln("%s(o);" % static_call)
 925             else:
 926                 code.putln("if (%s->tp_clear) {" % base_type.typeptr_cname)
 927                 code.putln("%s->tp_clear(o);" % base_type.typeptr_cname)
 928                 code.putln("}")
 929         for entry in py_attrs:
 930             name = "p->%s" % entry.cname
 931             code.putln("tmp = ((PyObject*)%s);" % name)
 932             code.put_init_to_py_none(name, entry.type)
 933             code.putln("Py_XDECREF(tmp);")
 934         code.putln(
 935             "return 0;")
 936         code.putln(
 937             "}")
 938
 939     def generate_getitem_int_function(self, scope, code):
 940         # This function is put into the sq_item slot when
 941         # a __getitem__ method is present. It converts its
 942         # argument to a Python integer and calls mp_subscript.
 943         code.putln(
 944             "static PyObject *%s(PyObject *o, Py_ssize_t i) {" %
 945                 scope.mangle_internal("sq_item"))
 946         code.putln(
 947                 "PyObject *r;")
 948         code.putln(
 949                 "PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;")
 950         code.putln(
 951                 "r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);")
 952         code.putln(
 953                 "Py_DECREF(x);")
 954         code.putln(
 955                 "return r;")
 956         code.putln(
 957             "}")
 958
 959     def generate_ass_subscript_function(self, scope, code):
 960         # Setting and deleting an item are both done through
 961         # the ass_subscript method, so we dispatch to user's __setitem__
 962         # or __delitem__, or raise an exception.
 963         base_type = scope.parent_type.base_type
 964         set_entry = scope.lookup_here("__setitem__")
 965         del_entry = scope.lookup_here("__delitem__")
 966         code.putln("")
 967         code.putln(
 968             "static int %s(PyObject *o, PyObject *i, PyObject *v) {" %
 969                 scope.mangle_internal("mp_ass_subscript"))
 970         code.putln(
 971                 "if (v) {")
 972         if set_entry:
 973             code.putln(
 974                     "return %s(o, i, v);" %
 975                         set_entry.func_cname)
 976         else:
 977             self.generate_guarded_basetype_call(
 978                 base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code)
 979             code.putln(
 980                     "PyErr_Format(PyExc_NotImplementedError,")
 981             code.putln(
 982                     '  "Subscript assignment not supported by %s", Py_TYPE(o)->tp_name);')
 983             code.putln(
 984                     "return -1;")
 985         code.putln(
 986                 "}")
 987         code.putln(
 988                 "else {")
 989         if del_entry:
 990             code.putln(
 991                     "return %s(o, i);" %
 992                         del_entry.func_cname)
 993         else:
 994             self.generate_guarded_basetype_call(
 995                 base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code)
 996             code.putln(
 997                     "PyErr_Format(PyExc_NotImplementedError,")
 998             code.putln(
 999                     '  "Subscript deletion not supported by %s", Py_TYPE(o)->tp_name);')
1000             code.putln(
1001                     "return -1;")
1002         code.putln(
1003                 "}")
1004         code.putln(
1005             "}")
1006
1007     def generate_guarded_basetype_call(
1008             self, base_type, substructure, slot, args, code):
1009         if base_type:
1010             base_tpname = base_type.typeptr_cname
1011             if substructure:
1012                 code.putln(
1013                     "if (%s->%s && %s->%s->%s)" % (
1014                         base_tpname, substructure, base_tpname, substructure, slot))
1015                 code.putln(
1016                     "  return %s->%s->%s(%s);" % (
1017                         base_tpname, substructure, slot, args))
1018             else:
1019                 code.putln(
1020                     "if (%s->%s)" % (
1021                         base_tpname, slot))
1022                 code.putln(
1023                     "  return %s->%s(%s);" % (
1024                         base_tpname, slot, args))
1025
1026     def generate_ass_slice_function(self, scope, code):
1027         # Setting and deleting a slice are both done through
1028         # the ass_slice method, so we dispatch to user's __setslice__
1029         # or __delslice__, or raise an exception.
1030         base_type = scope.parent_type.base_type
1031         set_entry = scope.lookup_here("__setslice__")
1032         del_entry = scope.lookup_here("__delslice__")
1033         code.putln("")
1034         code.putln(
1035             "static int %s(PyObject *o, Py_ssize_t i, Py_ssize_t j, PyObject *v) {" %
1036                 scope.mangle_internal("sq_ass_slice"))
1037         code.putln(
1038                 "if (v) {")
1039         if set_entry:
1040             code.putln(
1041                     "return %s(o, i, j, v);" %
1042                         set_entry.func_cname)
1043         else:
1044             self.generate_guarded_basetype_call(
1045                 base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)
1046             code.putln(
1047                     "PyErr_Format(PyExc_NotImplementedError,")
1048             code.putln(
1049                     '  "2-element slice assignment not supported by %s", Py_TYPE(o)->tp_name);')
1050             code.putln(
1051                     "return -1;")
1052         code.putln(
1053                 "}")
1054         code.putln(
1055                 "else {")
1056         if del_entry:
1057             code.putln(
1058                     "return %s(o, i, j);" %
1059                         del_entry.func_cname)
1060         else:
1061             self.generate_guarded_basetype_call(
1062                 base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)
1063             code.putln(
1064                     "PyErr_Format(PyExc_NotImplementedError,")
1065             code.putln(
1066                     '  "2-element slice deletion not supported by %s", Py_TYPE(o)->tp_name);')
1067             code.putln(
1068                     "return -1;")
1069         code.putln(
1070                 "}")
1071         code.putln(
1072             "}")
1073
1074     def generate_getattro_function(self, scope, code):
1075         # First try to get the attribute using __getattribute__, if defined, or
1076         # PyObject_GenericGetAttr.
1077         #
1078         # If that raises an AttributeError, call the __getattr__ if defined.
1079         #
1080         # In both cases, defined can be in this class, or any base class.
1081         def lookup_here_or_base(n,type=None):
1082             # Recursive lookup
1083             if type is None:
1084                 type = scope.parent_type
1085             r = type.scope.lookup_here(n)
1086             if r is None and \
1087                type.base_type is not None:
1088                 return lookup_here_or_base(n,type.base_type)
1089             else:
1090                 return r
1091         getattr_entry = lookup_here_or_base("__getattr__")
1092         getattribute_entry = lookup_here_or_base("__getattribute__")
1093         code.putln("")
1094         code.putln(
1095             "static PyObject *%s(PyObject *o, PyObject *n) {"
1096                 % scope.mangle_internal("tp_getattro"))
1097         if getattribute_entry is not None:
1098             code.putln(
1099                 "PyObject *v = %s(o, n);" %
1100                     getattribute_entry.func_cname)
1101         else:
1102             code.putln(
1103                 "PyObject *v = PyObject_GenericGetAttr(o, n);")
1104         if getattr_entry is not None:
1105             code.putln(
1106                 "if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) {")
1107             code.putln(
1108                 "PyErr_Clear();")
1109             code.putln(
1110                 "v = %s(o, n);" %
1111                     getattr_entry.func_cname)
1112             code.putln(
1113                 "}")
1114         code.putln(
1115             "return v;")
1116         code.putln(
1117             "}")
1118
1119     def generate_setattro_function(self, scope, code):
1120         # Setting and deleting an attribute are both done through
1121         # the setattro method, so we dispatch to user's __setattr__
1122         # or __delattr__ or fall back on PyObject_GenericSetAttr.
1123         base_type = scope.parent_type.base_type
1124         set_entry = scope.lookup_here("__setattr__")
1125         del_entry = scope.lookup_here("__delattr__")
1126         code.putln("")
1127         code.putln(
1128             "static int %s(PyObject *o, PyObject *n, PyObject *v) {" %
1129                 scope.mangle_internal("tp_setattro"))
1130         code.putln(
1131                 "if (v) {")
1132         if set_entry:
1133             code.putln(
1134                     "return %s(o, n, v);" %
1135                         set_entry.func_cname)
1136         else:
1137             self.generate_guarded_basetype_call(
1138                 base_type, None, "tp_setattro", "o, n, v", code)
1139             code.putln(
1140                     "return PyObject_GenericSetAttr(o, n, v);")
1141         code.putln(
1142                 "}")
1143         code.putln(
1144                 "else {")
1145         if del_entry:
1146             code.putln(
1147                     "return %s(o, n);" %
1148                         del_entry.func_cname)
1149         else:
1150             self.generate_guarded_basetype_call(
1151                 base_type, None, "tp_setattro", "o, n, v", code)
1152             code.putln(
1153                     "return PyObject_GenericSetAttr(o, n, 0);")
1154         code.putln(
1155                 "}")
1156         code.putln(
1157             "}")
1158
1159     def generate_descr_get_function(self, scope, code):
1160         # The __get__ function of a descriptor object can be
1161         # called with NULL for the second or third arguments
1162         # under some circumstances, so we replace them with
1163         # None in that case.
1164         user_get_entry = scope.lookup_here("__get__")
1165         code.putln("")
1166         code.putln(
1167             "static PyObject *%s(PyObject *o, PyObject *i, PyObject *c) {" %
1168                 scope.mangle_internal("tp_descr_get"))
1169         code.putln(
1170             "PyObject *r = 0;")
1171         code.putln(
1172             "if (!i) i = Py_None;")
1173         code.putln(
1174             "if (!c) c = Py_None;")
1175         #code.put_incref("i", py_object_type)
1176         #code.put_incref("c", py_object_type)
1177         code.putln(
1178             "r = %s(o, i, c);" %
1179                 user_get_entry.func_cname)
1180         #code.put_decref("i", py_object_type)
1181         #code.put_decref("c", py_object_type)
1182         code.putln(
1183             "return r;")
1184         code.putln(
1185             "}")
1186
1187     def generate_descr_set_function(self, scope, code):
1188         # Setting and deleting are both done through the __set__
1189         # method of a descriptor, so we dispatch to user's __set__
1190         # or __delete__ or raise an exception.
1191         base_type = scope.parent_type.base_type
1192         user_set_entry = scope.lookup_here("__set__")
1193         user_del_entry = scope.lookup_here("__delete__")
1194         code.putln("")
1195         code.putln(
1196             "static int %s(PyObject *o, PyObject *i, PyObject *v) {" %
1197                 scope.mangle_internal("tp_descr_set"))
1198         code.putln(
1199                 "if (v) {")
1200         if user_set_entry:
1201             code.putln(
1202                     "return %s(o, i, v);" %
1203                         user_set_entry.func_cname)
1204         else:
1205             self.generate_guarded_basetype_call(
1206                 base_type, None, "tp_descr_set", "o, i, v", code)
1207             code.putln(
1208                     'PyErr_SetString(PyExc_NotImplementedError, "__set__");')
1209             code.putln(
1210                     "return -1;")
1211         code.putln(
1212                 "}")
1213         code.putln(
1214                 "else {")
1215         if user_del_entry:
1216             code.putln(
1217                     "return %s(o, i);" %
1218                         user_del_entry.func_cname)
1219         else:
1220             self.generate_guarded_basetype_call(
1221                 base_type, None, "tp_descr_set", "o, i, v", code)
1222             code.putln(
1223                     'PyErr_SetString(PyExc_NotImplementedError, "__delete__");')
1224             code.putln(
1225                     "return -1;")
1226         code.putln(
1227                 "}")
1228         code.putln(
1229             "}")
1230
1231     def generate_property_accessors(self, cclass_scope, code):
1232         for entry in cclass_scope.property_entries:
1233             property_scope = entry.scope
1234             if property_scope.defines_any(["__get__"]):
1235                 self.generate_property_get_function(entry, code)
1236             if property_scope.defines_any(["__set__", "__del__"]):
1237                 self.generate_property_set_function(entry, code)
1238
1239     def generate_property_get_function(self, property_entry, code):
1240         property_scope = property_entry.scope
1241         property_entry.getter_cname = property_scope.parent_scope.mangle(
1242             Naming.prop_get_prefix, property_entry.name)
1243         get_entry = property_scope.lookup_here("__get__")
1244         code.putln("")
1245         code.putln(
1246             "static PyObject *%s(PyObject *o, void *x) {" %
1247                 property_entry.getter_cname)
1248         code.putln(
1249                 "return %s(o);" %
1250                     get_entry.func_cname)
1251         code.putln(
1252             "}")
1253
1254     def generate_property_set_function(self, property_entry, code):
1255         property_scope = property_entry.scope
1256         property_entry.setter_cname = property_scope.parent_scope.mangle(
1257             Naming.prop_set_prefix, property_entry.name)
1258         set_entry = property_scope.lookup_here("__set__")
1259         del_entry = property_scope.lookup_here("__del__")
1260         code.putln("")
1261         code.putln(
1262             "static int %s(PyObject *o, PyObject *v, void *x) {" %
1263                 property_entry.setter_cname)
1264         code.putln(
1265                 "if (v) {")
1266         if set_entry:
1267             code.putln(
1268                     "return %s(o, v);" %
1269                         set_entry.func_cname)
1270         else:
1271             code.putln(
1272                     'PyErr_SetString(PyExc_NotImplementedError, "__set__");')
1273             code.putln(
1274                     "return -1;")
1275         code.putln(
1276                 "}")
1277         code.putln(
1278                 "else {")
1279         if del_entry:
1280             code.putln(
1281                     "return %s(o);" %
1282                         del_entry.func_cname)
1283         else:
1284             code.putln(
1285                     'PyErr_SetString(PyExc_NotImplementedError, "__del__");')
1286             code.putln(
1287                     "return -1;")
1288         code.putln(
1289                 "}")
1290         code.putln(
1291             "}")
1292
1293     def generate_typeobj_definition(self, modname, entry, code):
1294         type = entry.type
1295         scope = type.scope
1296         for suite in TypeSlots.substructures:
1297             suite.generate_substructure(scope, code)
1298         code.putln("")
1299         if entry.visibility == 'public':
1300             header = "DL_EXPORT(PyTypeObject) %s = {"
1301         else:
1302             #header = "statichere PyTypeObject %s = {"
1303             header = "PyTypeObject %s = {"
1304         #code.putln(header % scope.parent_type.typeobj_cname)
1305         code.putln(header % type.typeobj_cname)
1306         code.putln(
1307             "PyVarObject_HEAD_INIT(0, 0)")
1308         code.putln(
1309             '"%s.%s", /*tp_name*/' % (
1310                 self.full_module_name, scope.class_name))
1311         if type.typedef_flag:
1312             objstruct = type.objstruct_cname
1313         else:
1314             #objstruct = "struct %s" % scope.parent_type.objstruct_cname
1315             objstruct = "struct %s" % type.objstruct_cname
1316         code.putln(
1317             "sizeof(%s), /*tp_basicsize*/" %
1318                 objstruct)
1319         code.putln(
1320             "0, /*tp_itemsize*/")
1321         for slot in TypeSlots.slot_table:
1322             slot.generate(scope, code)
1323         code.putln(
1324             "};")
1325
1326     def generate_method_table(self, env, code):
1327         code.putln("")
1328         code.putln(
1329             "static struct PyMethodDef %s[] = {" %
1330                 env.method_table_cname)
1331         for entry in env.pyfunc_entries:
1332             code.put_pymethoddef(entry, ",")
1333         code.putln(
1334                 "{0, 0, 0, 0}")
1335         code.putln(
1336             "};")
1337
1338     def generate_member_table(self, env, code):
1339         #print "ModuleNode.generate_member_table: scope =", env ###
1340         if env.public_attr_entries:
1341             code.putln("")
1342             code.putln(
1343                 "static struct PyMemberDef %s[] = {" %
1344                     env.member_table_cname)
1345             type = env.parent_type
1346             if type.typedef_flag:
1347                 objstruct = type.objstruct_cname
1348             else:
1349                 objstruct = "struct %s" % type.objstruct_cname
1350             for entry in env.public_attr_entries:
1351                 type_code = entry.type.pymemberdef_typecode
1352                 if entry.visibility == 'readonly':
1353                     flags = "READONLY"
1354                 else:
1355                     flags = "0"
1356                 code.putln('{"%s", %s, %s, %s, 0},' % (
1357                     entry.name,
1358                     type_code,
1359                     "offsetof(%s, %s)" % (objstruct, entry.cname),
1360                     flags))
1361             code.putln(
1362                     "{0, 0, 0, 0, 0}")
1363             code.putln(
1364                 "};")
1365
1366     def generate_getset_table(self, env, code):
1367         if env.property_entries:
1368             code.putln("")
1369             code.putln(
1370                 "static struct PyGetSetDef %s[] = {" %
1371                     env.getset_table_cname)
1372             for entry in env.property_entries:
1373                 code.putln(
1374                     '{"%s", %s, %s, %s, 0},' % (
1375                         entry.name,
1376                         entry.getter_cname or "0",
1377                         entry.setter_cname or "0",
1378                         entry.doc_cname or "0"))
1379             code.putln(
1380                     "{0, 0, 0, 0, 0}")
1381             code.putln(
1382                 "};")
1383
1384     def generate_py_string_table(self, env, code):
1385         entries = env.all_pystring_entries
1386         if entries:
1387             code.putln("")
1388             code.putln(
1389                 "static __Pyx_StringTabEntry %s[] = {" %
1390                     Naming.stringtab_cname)
1391             for entry in entries:
1392                 code.putln(
1393                     "{&%s, %s, sizeof(%s), %d, %d, %d}," % (
1394                         entry.pystring_cname,
1395                         entry.cname,
1396                         entry.cname,
1397                         entry.type.is_unicode,
1398                         entry.is_identifier,
1399                         entry.is_interned
1400                         ))
1401             code.putln(
1402                 "{0, 0, 0, 0, 0}")
1403             code.putln(
1404                 "};")
1405
1406     def generate_filename_init_prototype(self, code):
1407         code.putln("");
1408         code.putln("static void %s(void); /*proto*/" % Naming.fileinit_cname)
1409
1410     def generate_module_init_func(self, imported_modules, env, code):
1411         code.putln("")
1412         header = "PyMODINIT_FUNC init%s(void)" % env.module_name
1413         code.putln("%s; /*proto*/" % header)
1414         code.putln("%s {" % header)
1415         code.put_var_declarations(env.temp_entries)
1416
1417         code.putln("/*--- Libary function declarations ---*/")
1418         env.generate_library_function_declarations(code)
1419         self.generate_filename_init_call(code)
1420
1421         code.putln("/*--- Module creation code ---*/")
1422         self.generate_module_creation_code(env, code)
1423
1424         code.putln("/*--- Intern code ---*/")
1425         self.generate_intern_code(env, code)
1426
1427         code.putln("/*--- String init code ---*/")
1428         self.generate_string_init_code(env, code)
1429
1430         if Options.cache_builtins:
1431             code.putln("/*--- Builtin init code ---*/")
1432             self.generate_builtin_init_code(env, code)
1433
1434         code.putln("%s = PyTuple_New(0); %s" % (Naming.empty_tuple, code.error_goto_if_null(Naming.empty_tuple, self.pos)));
1435         code.putln("%s = 0;" % Naming.skip_dispatch_cname);
1436
1437         code.putln("/*--- Global init code ---*/")
1438         self.generate_global_init_code(env, code)
1439
1440         code.putln("/*--- Function export code ---*/")
1441         self.generate_c_function_export_code(env, code)
1442
1443         code.putln("/*--- Type init code ---*/")
1444         self.generate_type_init_code(env, code)
1445
1446         code.putln("/*--- Type import code ---*/")
1447         for module in imported_modules:
1448             self.generate_type_import_code_for_module(module, env, code)
1449
1450         code.putln("/*--- Function import code ---*/")
1451         for module in imported_modules:
1452             self.generate_c_function_import_code_for_module(module, env, code)
1453
1454         code.putln("/*--- Execution code ---*/")
1455         code.mark_pos(None)
1456         self.body.generate_execution_code(code)
1457
1458         if Options.generate_cleanup_code:
1459             code.putln("if (__Pyx_RegisterCleanup()) %s;" % code.error_goto(self.pos))
1460
1461         code.putln("return;")
1462         code.put_label(code.error_label)
1463         code.put_var_xdecrefs(env.temp_entries)
1464         code.putln('__Pyx_AddTraceback("%s");' % env.qualified_name)
1465         env.use_utility_code(Nodes.traceback_utility_code)
1466         code.putln('}')
1467
1468     def generate_module_cleanup_func(self, env, code):
1469         if not Options.generate_cleanup_code:
1470             return
1471         env.use_utility_code(import_module_utility_code)
1472         env.use_utility_code(register_cleanup_utility_code)
1473         code.putln()
1474         code.putln('static PyObject* %s(PyObject *self, PyObject *unused) {' % Naming.cleanup_cname)
1475         if Options.generate_cleanup_code >= 2:
1476             code.putln("/*--- Global cleanup code ---*/")
1477             rev_entries = list(env.var_entries)
1478             rev_entries.reverse()
1479             for entry in rev_entries:
1480                 if entry.visibility != 'extern':
1481                     if entry.type.is_pyobject:
1482                         code.put_var_decref_clear(entry)
1483         if Options.generate_cleanup_code >= 3:
1484             code.putln("/*--- Type import cleanup code ---*/")
1485             for type, _ in env.types_imported.items():
1486                 code.put_decref("((PyObject*)%s)" % type.typeptr_cname, PyrexTypes.py_object_type)
1487         if Options.cache_builtins:
1488             code.putln("/*--- Builtin cleanup code ---*/")
1489             for entry in env.cached_builtins:
1490                 code.put_var_decref_clear(entry)
1491         code.putln("Py_DECREF(%s); %s = 0;" % (Naming.empty_tuple, Naming.empty_tuple));
1492         code.putln("/*--- Intern cleanup code ---*/")
1493         for entry in env.pynum_entries:
1494             code.put_var_decref_clear(entry)
1495         if env.all_pystring_entries:
1496             for entry in env.all_pystring_entries:
1497                 if entry.is_interned:
1498                     code.put_decref_clear(
1499                         entry.pystring_cname, PyrexTypes.py_object_type)
1500         code.putln("Py_INCREF(Py_None); return Py_None;")
1501         code.putln('}')
1502
1503     def generate_filename_init_call(self, code):
1504         code.putln("%s();" % Naming.fileinit_cname)
1505
1506     def generate_module_creation_code(self, env, code):
1507         # Generate code to create the module object and
1508         # install the builtins.
1509         if env.doc:
1510             doc = env.doc_cname
1511         else:
1512             doc = "0"
1513         code.putln(
1514             '%s = Py_InitModule4("%s", %s, %s, 0, PYTHON_API_VERSION);' % (
1515                 env.module_cname,
1516                 env.module_name,
1517                 env.method_table_cname,
1518                 doc))
1519         code.putln(
1520             "if (!%s) %s;" % (
1521                 env.module_cname,
1522                 code.error_goto(self.pos)));
1523         code.putln(
1524             '%s = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME);' %
1525                 Naming.builtins_cname)
1526         code.putln(
1527             "if (!%s) %s;" % (
1528                 Naming.builtins_cname,
1529                 code.error_goto(self.pos)));
1530         code.putln(
1531             'if (PyObject_SetAttrString(%s, "__builtins__", %s) < 0) %s;' % (
1532                 env.module_cname,
1533                 Naming.builtins_cname,
1534                 code.error_goto(self.pos)))
1535         if Options.pre_import is not None:
1536             code.putln(
1537                 '%s = PyImport_AddModule("%s");' % (
1538                     Naming.preimport_cname,
1539                     Options.pre_import))
1540             code.putln(
1541                 "if (!%s) %s;" % (
1542                     Naming.preimport_cname,
1543                     code.error_goto(self.pos)));
1544
1545     def generate_intern_code(self, env, code):
1546         for entry in env.pynum_entries:
1547             code.putln("%s = PyInt_FromLong(%s); %s;" % (
1548                 entry.cname,
1549                 entry.init,
1550                 code.error_goto_if_null(entry.cname, self.pos)))
1551
1552     def generate_string_init_code(self, env, code):
1553         if env.all_pystring_entries:
1554             env.use_utility_code(Nodes.init_string_tab_utility_code)
1555             code.putln(
1556                 "if (__Pyx_InitStrings(%s) < 0) %s;" % (
1557                     Naming.stringtab_cname,
1558                     code.error_goto(self.pos)))
1559
1560     def generate_builtin_init_code(self, env, code):
1561         # Lookup and cache builtin objects.
1562         if Options.cache_builtins:
1563             for entry in env.cached_builtins:
1564                 #assert entry.interned_cname is not None
1565                 code.putln(
1566                     '%s = __Pyx_GetName(%s, %s); if (!%s) %s' % (
1567                     entry.cname,
1568                     Naming.builtins_cname,
1569                     entry.interned_cname,
1570                     entry.cname,
1571                     code.error_goto(entry.pos)))
1572
1573     def generate_global_init_code(self, env, code):
1574         # Generate code to initialise global PyObject *
1575         # variables to None.
1576         for entry in env.var_entries:
1577             if entry.visibility != 'extern':
1578                 if entry.type.is_pyobject:
1579                     code.put_init_var_to_py_none(entry)
1580
1581     def generate_c_function_export_code(self, env, code):
1582         # Generate code to create PyCFunction wrappers for exported C functions.
1583         for entry in env.cfunc_entries:
1584             if entry.api or entry.defined_in_pxd:
1585                 env.use_utility_code(function_export_utility_code)
1586                 signature = entry.type.signature_string()
1587                 code.putln('if (__Pyx_ExportFunction("%s", (void*)%s, "%s") < 0) %s' % (
1588                     entry.name,
1589                     entry.cname,
1590                     signature,
1591                     code.error_goto(self.pos)))
1592
1593     def generate_type_import_code_for_module(self, module, env, code):
1594         # Generate type import code for all exported extension types in
1595         # an imported module.
1596         #if module.c_class_entries:
1597         for entry in module.c_class_entries:
1598             if entry.defined_in_pxd:
1599                 self.generate_type_import_code(env, entry.type, entry.pos, code)
1600
1601     def generate_c_function_import_code_for_module(self, module, env, code):
1602         # Generate import code for all exported C functions in a cimported module.
1603         entries = []
1604         for entry in module.cfunc_entries:
1605             if entry.defined_in_pxd:
1606                 entries.append(entry)
1607         if entries:
1608             env.use_utility_code(import_module_utility_code)
1609             env.use_utility_code(function_import_utility_code)
1610             temp = self.module_temp_cname
1611             code.putln(
1612                 '%s = __Pyx_ImportModule("%s"); if (!%s) %s' % (
1613                     temp,
1614                     module.qualified_name,
1615                     temp,
1616                     code.error_goto(self.pos)))
1617             for entry in entries:
1618                 code.putln(
1619                     'if (__Pyx_ImportFunction(%s, "%s", (void**)&%s, "%s") < 0) %s' % (
1620                         temp,
1621                         entry.name,
1622                         entry.cname,
1623                         entry.type.signature_string(),
1624                         code.error_goto(self.pos)))
1625             code.putln("Py_DECREF(%s); %s = 0;" % (temp, temp))
1626
1627     def generate_type_init_code(self, env, code):
1628         # Generate type import code for extern extension types
1629         # and type ready code for non-extern ones.
1630         for entry in env.c_class_entries:
1631             if entry.visibility == 'extern':
1632                 self.generate_type_import_code(env, entry.type, entry.pos, code)
1633             else:
1634                 self.generate_base_type_import_code(env, entry, code)
1635                 self.generate_exttype_vtable_init_code(entry, code)
1636                 self.generate_type_ready_code(env, entry, code)
1637                 self.generate_typeptr_assignment_code(entry, code)
1638
1639     def generate_base_type_import_code(self, env, entry, code):
1640         base_type = entry.type.base_type
1641         if base_type and base_type.module_name != env.qualified_name:
1642             self.generate_type_import_code(env, base_type, self.pos, code)
1643
1644     def use_type_import_utility_code(self, env):
1645         env.use_utility_code(type_import_utility_code)
1646         env.use_utility_code(import_module_utility_code)
1647
1648     def generate_type_import_code(self, env, type, pos, code):
1649         # If not already done, generate code to import the typeobject of an
1650         # extension type defined in another module, and extract its C method
1651         # table pointer if any.
1652         if type in env.types_imported:
1653             return
1654         if type.typedef_flag:
1655             objstruct = type.objstruct_cname
1656         else:
1657             objstruct = "struct %s" % type.objstruct_cname
1658         self.generate_type_import_call(type, code,
1659                                        code.error_goto_if_null(type.typeptr_cname, pos))
1660         self.use_type_import_utility_code(env)
1661         if type.vtabptr_cname:
1662             code.putln(
1663                 "if (__Pyx_GetVtable(%s->tp_dict, &%s) < 0) %s" % (
1664                     type.typeptr_cname,
1665                     type.vtabptr_cname,
1666                     code.error_goto(pos)))
1667             env.use_utility_code(Nodes.get_vtable_utility_code)
1668         env.types_imported[type] = 1
1669
1670     def generate_type_import_call(self, type, code, error_code):
1671         if type.typedef_flag:
1672             objstruct = type.objstruct_cname
1673         else:
1674             objstruct = "struct %s" % type.objstruct_cname
1675         module_name = type.module_name
1676         if module_name not in ('__builtin__', 'builtins'):
1677             module_name = '"%s"' % module_name
1678         else:
1679             module_name = '__Pyx_BUILTIN_MODULE_NAME'
1680         code.putln('%s = __Pyx_ImportType(%s, "%s", sizeof(%s)); %s' % (
1681             type.typeptr_cname,
1682             module_name,
1683             type.name,
1684             objstruct,
1685             error_code))
1686
1687     def generate_type_ready_code(self, env, entry, code):
1688         # Generate a call to PyType_Ready for an extension
1689         # type defined in this module.
1690         type = entry.type
1691         typeobj_cname = type.typeobj_cname
1692         scope = type.scope
1693         if scope: # could be None if there was an error
1694             if entry.visibility != 'extern':
1695                 for slot in TypeSlots.slot_table:
1696                     slot.generate_dynamic_init_code(scope, code)
1697                 code.putln(
1698                     "if (PyType_Ready(&%s) < 0) %s" % (
1699                         typeobj_cname,
1700                         code.error_goto(entry.pos)))
1701                 if type.vtable_cname:
1702                     code.putln(
1703                         "if (__Pyx_SetVtable(%s.tp_dict, %s) < 0) %s" % (
1704                             typeobj_cname,
1705                             type.vtabptr_cname,
1706                             code.error_goto(entry.pos)))
1707                     env.use_utility_code(Nodes.set_vtable_utility_code)
1708                 code.putln(
1709                     'if (PyObject_SetAttrString(%s, "%s", (PyObject *)&%s) < 0) %s' % (
1710                         Naming.module_cname,
1711                         scope.class_name,
1712                         typeobj_cname,
1713                         code.error_goto(entry.pos)))
1714                 weakref_entry = scope.lookup_here("__weakref__")
1715                 if weakref_entry:
1716                     if weakref_entry.type is py_object_type:
1717                         tp_weaklistoffset = "%s.tp_weaklistoffset" % typeobj_cname
1718                         code.putln("if (%s == 0) %s = offsetof(struct %s, %s);" % (
1719                             tp_weaklistoffset,
1720                             tp_weaklistoffset,
1721                             type.objstruct_cname,
1722                             weakref_entry.cname))
1723                     else:
1724                         error(weakref_entry.pos, "__weakref__ slot must be of type 'object'")
1725
1726     def generate_exttype_vtable_init_code(self, entry, code):
1727         # Generate code to initialise the C method table of an
1728         # extension type.
1729         type = entry.type
1730         if type.vtable_cname:
1731             code.putln(
1732                 "%s = &%s;" % (
1733                     type.vtabptr_cname,
1734                     type.vtable_cname))
1735             if type.base_type and type.base_type.vtabptr_cname:
1736                 code.putln(
1737                     "%s.%s = *%s;" % (
1738                         type.vtable_cname,
1739                         Naming.obj_base_cname,
1740                         type.base_type.vtabptr_cname))
1741             for meth_entry in type.scope.cfunc_entries:
1742                 if meth_entry.func_cname:
1743                     code.putln(
1744                         "*(void(**)(void))&%s.%s = (void(*)(void))%s;" % (
1745                             type.vtable_cname,
1746                             meth_entry.cname,
1747                             meth_entry.func_cname))
1748
1749     def generate_typeptr_assignment_code(self, entry, code):
1750         # Generate code to initialise the typeptr of an extension
1751         # type defined in this module to point to its type object.
1752         type = entry.type
1753         if type.typeobj_cname:
1754             code.putln(
1755                 "%s = &%s;" % (
1756                     type.typeptr_cname, type.typeobj_cname))
1757
1758     def generate_utility_functions(self, env, code):
1759         code.putln("")
1760         code.putln("/* Runtime support code */")
1761         code.putln("")
1762         code.putln("static void %s(void) {" % Naming.fileinit_cname)
1763         code.putln("%s = %s;" %
1764             (Naming.filetable_cname, Naming.filenames_cname))
1765         code.putln("}")
1766         for utility_code in env.utility_code_used:
1767             code.h.put(utility_code[0])
1768             code.put(utility_code[1])
1769         code.put(PyrexTypes.type_conversion_functions)
1770
1771 #------------------------------------------------------------------------------------
1772 #
1773 #  Runtime support code
1774 #
1775 #------------------------------------------------------------------------------------
1776
1777 builtin_module_name_utility_code = [
1778 """\
1779 #if PY_MAJOR_VERSION < 3
1780   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
1781 #else
1782   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
1783 #endif
1784 """]
1785
1786
1787 import_module_utility_code = [
1788 """
1789 static PyObject *__Pyx_ImportModule(char *name); /*proto*/
1790 ""","""
1791 #ifndef __PYX_HAVE_RT_ImportModule
1792 #define __PYX_HAVE_RT_ImportModule
1793 static PyObject *__Pyx_ImportModule(char *name) {
1794     PyObject *py_name = 0;
1795     PyObject *py_module = 0;
1796
1797     #if PY_MAJOR_VERSION < 3
1798     py_name = PyString_FromString(name);
1799     #else
1800     py_name = PyUnicode_FromString(name);
1801     #endif
1802     if (!py_name)
1803         goto bad;
1804     py_module = PyImport_Import(py_name);
1805     Py_DECREF(py_name);
1806     return py_module;
1807 bad:
1808     Py_XDECREF(py_name);
1809     return 0;
1810 }
1811 #endif
1812 """]
1813
1814 #------------------------------------------------------------------------------------
1815
1816 type_import_utility_code = [
1817 """
1818 static PyTypeObject *__Pyx_ImportType(char *module_name, char *class_name, long size);  /*proto*/
1819 ""","""
1820 #ifndef __PYX_HAVE_RT_ImportType
1821 #define __PYX_HAVE_RT_ImportType
1822 static PyTypeObject *__Pyx_ImportType(char *module_name, char *class_name,
1823     long size)
1824 {
1825     PyObject *py_module = 0;
1826     PyObject *result = 0;
1827     PyObject *py_name = 0;
1828
1829     #if PY_MAJOR_VERSION < 3
1830     py_name = PyString_FromString(module_name);
1831     #else
1832     py_name = PyUnicode_FromString(module_name);
1833     #endif
1834     if (!py_name)
1835         goto bad;
1836
1837     py_module = __Pyx_ImportModule(module_name);
1838     if (!py_module)
1839         goto bad;
1840     result = PyObject_GetAttrString(py_module, class_name);
1841     if (!result)
1842         goto bad;
1843     if (!PyType_Check(result)) {
1844         PyErr_Format(PyExc_TypeError,
1845             "%s.%s is not a type object",
1846             module_name, class_name);
1847         goto bad;
1848     }
1849     if (((PyTypeObject *)result)->tp_basicsize != size) {
1850         PyErr_Format(PyExc_ValueError,
1851             "%s.%s does not appear to be the correct type object",
1852             module_name, class_name);
1853         goto bad;
1854     }
1855     return (PyTypeObject *)result;
1856 bad:
1857     Py_XDECREF(py_name);
1858     Py_XDECREF(result);
1859     return 0;
1860 }
1861 #endif
1862 """]
1863
1864 #------------------------------------------------------------------------------------
1865
1866 function_export_utility_code = [
1867 """
1868 static int __Pyx_ExportFunction(char *name, void *f, char *sig); /*proto*/
1869 """,r"""
1870 static int __Pyx_ExportFunction(char *name, void *f, char *sig) {
1871     PyObject *d = 0;
1872     PyObject *p = 0;
1873     d = PyObject_GetAttrString(%(MODULE)s, "%(API)s");
1874     if (!d) {
1875         PyErr_Clear();
1876         d = PyDict_New();
1877         if (!d)
1878             goto bad;
1879         Py_INCREF(d);
1880         if (PyModule_AddObject(%(MODULE)s, "%(API)s", d) < 0)
1881             goto bad;
1882     }
1883     p = PyCObject_FromVoidPtrAndDesc(f, sig, 0);
1884     if (!p)
1885         goto bad;
1886     if (PyDict_SetItemString(d, name, p) < 0)
1887         goto bad;
1888     Py_DECREF(d);
1889     return 0;
1890 bad:
1891     Py_XDECREF(p);
1892     Py_XDECREF(d);
1893     return -1;
1894 }
1895 """ % {'MODULE': Naming.module_cname, 'API': Naming.api_name}]
1896
1897 #------------------------------------------------------------------------------------
1898
1899 function_import_utility_code = [
1900 """
1901 static int __Pyx_ImportFunction(PyObject *module, char *funcname, void **f, char *sig); /*proto*/
1902 ""","""
1903 #ifndef __PYX_HAVE_RT_ImportFunction
1904 #define __PYX_HAVE_RT_ImportFunction
1905 static int __Pyx_ImportFunction(PyObject *module, char *funcname, void **f, char *sig) {
1906     PyObject *d = 0;
1907     PyObject *cobj = 0;
1908     char *desc;
1909
1910     d = PyObject_GetAttrString(module, "%(API)s");
1911     if (!d)
1912         goto bad;
1913     cobj = PyDict_GetItemString(d, funcname);
1914     if (!cobj) {
1915         PyErr_Format(PyExc_ImportError,
1916             "%%s does not export expected C function %%s",
1917                 PyModule_GetName(module), funcname);
1918         goto bad;
1919     }
1920     desc = (char *)PyCObject_GetDesc(cobj);
1921     if (!desc)
1922         goto bad;
1923     if (strcmp(desc, sig) != 0) {
1924         PyErr_Format(PyExc_TypeError,
1925             "C function %%s.%%s has wrong signature (expected %%s, got %%s)",
1926                 PyModule_GetName(module), funcname, sig, desc);
1927         goto bad;
1928     }
1929     *f = PyCObject_AsVoidPtr(cobj);
1930     Py_DECREF(d);
1931     return 0;
1932 bad:
1933     Py_XDECREF(d);
1934     return -1;
1935 }
1936 #endif
1937 """ % dict(API = Naming.api_name)]
1938
1939 register_cleanup_utility_code = [
1940 """
1941 static int __Pyx_RegisterCleanup(void); /*proto*/
1942 static PyObject* __pyx_module_cleanup(PyObject *self, PyObject *unused); /*proto*/
1943 static PyMethodDef cleanup_def = {"__cleanup", (PyCFunction)&__pyx_module_cleanup, METH_NOARGS, 0};
1944 ""","""
1945 static int __Pyx_RegisterCleanup(void) {
1946     /* Don't use Py_AtExit because that has a 32-call limit
1947      * and is called after python finalization.
1948      */
1949
1950     PyObject *cleanup_func = 0;
1951     PyObject *atexit = 0;
1952     PyObject *reg = 0;
1953     PyObject *args = 0;
1954     PyObject *res = 0;
1955     int ret = -1;
1956
1957     cleanup_func = PyCFunction_New(&cleanup_def, 0);
1958     args = PyTuple_New(1);
1959     if (!cleanup_func || !args)
1960         goto bad;
1961     PyTuple_SET_ITEM(args, 0, cleanup_func);
1962     cleanup_func = 0;
1963
1964     atexit = __Pyx_ImportModule("atexit");
1965     if (!atexit)
1966         goto bad;
1967     reg = PyObject_GetAttrString(atexit, "register");
1968     if (!reg)
1969         goto bad;
1970     res = PyObject_CallObject(reg, args);
1971     if (!res)
1972         goto bad;
1973     ret = 0;
1974 bad:
1975     Py_XDECREF(cleanup_func);
1976     Py_XDECREF(atexit);
1977     Py_XDECREF(reg);
1978     Py_XDECREF(args);
1979     Py_XDECREF(res);
1980     return ret;
1981 }
1982 """]