Cython/Compiler/ModuleNode.py

   1 #
   2 #   Pyrex - Module parse tree node
   3 #
   4
   5 import os, time
   6 from PyrexTypes import CPtrType
   7 import Future
   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 import DebugFlags
  23
  24 from Errors import error, warning
  25 from PyrexTypes import py_object_type
  26 from Cython.Utils import open_new_file, replace_suffix
  27 from Code import UtilityCode
  28 from StringEncoding import escape_byte_string, EncodedString
  29
  30
  31 def check_c_declarations_pxd(module_node):
  32     module_node.scope.check_c_classes_pxd()
  33     return module_node
  34
  35 def check_c_declarations(module_node):
  36     module_node.scope.check_c_classes()
  37     module_node.scope.check_c_functions()
  38     return module_node
  39
  40 class ModuleNode(Nodes.Node, Nodes.BlockNode):
  41     #  doc       string or None
  42     #  body      StatListNode
  43     #
  44     #  referenced_modules   [ModuleScope]
  45     #  full_module_name     string
  46     #
  47     #  scope                The module scope.
  48     #  compilation_source   A CompilationSource (see Main)
  49     #  directives           Top-level compiler directives
  50
  51     child_attrs = ["body"]
  52     directives = None
  53
  54     def analyse_declarations(self, env):
  55         if Options.embed_pos_in_docstring:
  56             env.doc = EncodedString(u'File: %s (starting at line %s)' % Nodes.relative_position(self.pos))
  57             if not self.doc is None:
  58                 env.doc = EncodedString(env.doc + u'\n' + self.doc)
  59                 env.doc.encoding = self.doc.encoding
  60         else:
  61             env.doc = self.doc
  62         env.directives = self.directives
  63         self.body.analyse_declarations(env)
  64
  65     def process_implementation(self, options, result):
  66         env = self.scope
  67         env.return_type = PyrexTypes.c_void_type
  68         self.referenced_modules = []
  69         self.find_referenced_modules(env, self.referenced_modules, {})
  70         if options.recursive:
  71             self.generate_dep_file(env, result)
  72         self.generate_c_code(env, options, result)
  73         self.generate_h_code(env, options, result)
  74         self.generate_api_code(env, result)
  75
  76     def has_imported_c_functions(self):
  77         for module in self.referenced_modules:
  78             for entry in module.cfunc_entries:
  79                 if entry.defined_in_pxd:
  80                     return 1
  81         return 0
  82
  83     def generate_dep_file(self, env, result):
  84         modules = self.referenced_modules
  85         if len(modules) > 1 or env.included_files:
  86             dep_file = replace_suffix(result.c_file, ".dep")
  87             f = open(dep_file, "w")
  88             try:
  89                 for module in modules:
  90                     if module is not env:
  91                         f.write("cimport %s\n" % module.qualified_name)
  92                     for path in module.included_files:
  93                         f.write("include %s\n" % path)
  94             finally:
  95                 f.close()
  96
  97     def generate_h_code(self, env, options, result):
  98         def h_entries(entries, pxd = 0):
  99             return [entry for entry in entries
 100                 if entry.visibility == 'public' or pxd and entry.defined_in_pxd]
 101         h_types = h_entries(env.type_entries)
 102         h_vars = h_entries(env.var_entries)
 103         h_funcs = h_entries(env.cfunc_entries)
 104         h_extension_types = h_entries(env.c_class_entries)
 105         if h_types or h_vars or h_funcs or h_extension_types:
 106             result.h_file = replace_suffix(result.c_file, ".h")
 107             h_code = Code.CCodeWriter()
 108             Code.GlobalState(h_code)
 109             if options.generate_pxi:
 110                 result.i_file = replace_suffix(result.c_file, ".pxi")
 111                 i_code = Code.PyrexCodeWriter(result.i_file)
 112             else:
 113                 i_code = None
 114             guard = Naming.h_guard_prefix + env.qualified_name.replace(".", "__")
 115             h_code.put_h_guard(guard)
 116             self.generate_extern_c_macro_definition(h_code)
 117             self.generate_type_header_code(h_types, h_code)
 118             h_code.putln("")
 119             h_code.putln("#ifndef %s" % Naming.api_guard_prefix + self.api_name(env))
 120             if h_vars:
 121                 h_code.putln("")
 122                 for entry in h_vars:
 123                     self.generate_public_declaration(entry, h_code, i_code)
 124             if h_funcs:
 125                 h_code.putln("")
 126                 for entry in h_funcs:
 127                     self.generate_public_declaration(entry, h_code, i_code)
 128             if h_extension_types:
 129                 h_code.putln("")
 130                 for entry in h_extension_types:
 131                     self.generate_cclass_header_code(entry.type, h_code)
 132                     if i_code:
 133                         self.generate_cclass_include_code(entry.type, i_code)
 134             h_code.putln("")
 135             h_code.putln("#endif")
 136             h_code.putln("")
 137             h_code.putln("PyMODINIT_FUNC init%s(void);" % env.module_name)
 138             h_code.putln("")
 139             h_code.putln("#endif")
 140
 141             h_code.copyto(open_new_file(result.h_file))
 142
 143     def generate_public_declaration(self, entry, h_code, i_code):
 144         h_code.putln("%s %s;" % (
 145             Naming.extern_c_macro,
 146             entry.type.declaration_code(
 147                 entry.cname, dll_linkage = "DL_IMPORT")))
 148         if i_code:
 149             i_code.putln("cdef extern %s" %
 150                 entry.type.declaration_code(entry.cname, pyrex = 1))
 151
 152     def api_name(self, env):
 153         return env.qualified_name.replace(".", "__")
 154
 155     def generate_api_code(self, env, result):
 156         api_funcs = []
 157         public_extension_types = []
 158         has_api_extension_types = 0
 159         for entry in env.cfunc_entries:
 160             if entry.api:
 161                 api_funcs.append(entry)
 162         for entry in env.c_class_entries:
 163             if entry.visibility == 'public':
 164                 public_extension_types.append(entry)
 165             if entry.api:
 166                 has_api_extension_types = 1
 167         if api_funcs or has_api_extension_types:
 168             result.api_file = replace_suffix(result.c_file, "_api.h")
 169             h_code = Code.CCodeWriter()
 170             Code.GlobalState(h_code)
 171             name = self.api_name(env)
 172             guard = Naming.api_guard_prefix + name
 173             h_code.put_h_guard(guard)
 174             h_code.putln('#include "Python.h"')
 175             if result.h_file:
 176                 h_code.putln('#include "%s"' % os.path.basename(result.h_file))
 177             for entry in public_extension_types:
 178                 type = entry.type
 179                 h_code.putln("")
 180                 h_code.putln("static PyTypeObject *%s;" % type.typeptr_cname)
 181                 h_code.putln("#define %s (*%s)" % (
 182                     type.typeobj_cname, type.typeptr_cname))
 183             if api_funcs:
 184                 h_code.putln("")
 185                 for entry in api_funcs:
 186                     type = CPtrType(entry.type)
 187                     h_code.putln("static %s;" % type.declaration_code(entry.cname))
 188             h_code.putln("")
 189             h_code.put_h_guard(Naming.api_func_guard + "import_module")
 190             h_code.put(import_module_utility_code.impl)
 191             h_code.putln("")
 192             h_code.putln("#endif")
 193             if api_funcs:
 194                 h_code.putln("")
 195                 h_code.put(function_import_utility_code.impl)
 196             if public_extension_types:
 197                 h_code.putln("")
 198                 h_code.put(type_import_utility_code.impl)
 199             h_code.putln("")
 200             h_code.putln("static int import_%s(void) {" % name)
 201             h_code.putln("PyObject *module = 0;")
 202             h_code.putln('module = __Pyx_ImportModule("%s");' % env.qualified_name)
 203             h_code.putln("if (!module) goto bad;")
 204             for entry in api_funcs:
 205                 sig = entry.type.signature_string()
 206                 h_code.putln(
 207                     'if (__Pyx_ImportFunction(module, "%s", (void (**)(void))&%s, "%s") < 0) goto bad;' % (
 208                         entry.name,
 209                         entry.cname,
 210                         sig))
 211             h_code.putln("Py_DECREF(module); module = 0;")
 212             for entry in public_extension_types:
 213                 self.generate_type_import_call(
 214                     entry.type, h_code,
 215                     "if (!%s) goto bad;" % entry.type.typeptr_cname)
 216             h_code.putln("return 0;")
 217             h_code.putln("bad:")
 218             h_code.putln("Py_XDECREF(module);")
 219             h_code.putln("return -1;")
 220             h_code.putln("}")
 221             h_code.putln("")
 222             h_code.putln("#endif")
 223
 224             h_code.copyto(open_new_file(result.api_file))
 225
 226     def generate_cclass_header_code(self, type, h_code):
 227         h_code.putln("%s DL_IMPORT(PyTypeObject) %s;" % (
 228             Naming.extern_c_macro,
 229             type.typeobj_cname))
 230         #self.generate_obj_struct_definition(type, h_code)
 231
 232     def generate_cclass_include_code(self, type, i_code):
 233         i_code.putln("cdef extern class %s.%s:" % (
 234             type.module_name, type.name))
 235         i_code.indent()
 236         var_entries = type.scope.var_entries
 237         if var_entries:
 238             for entry in var_entries:
 239                 i_code.putln("cdef %s" %
 240                     entry.type.declaration_code(entry.cname, pyrex = 1))
 241         else:
 242             i_code.putln("pass")
 243         i_code.dedent()
 244
 245     def generate_c_code(self, env, options, result):
 246         modules = self.referenced_modules
 247
 248         if Options.annotate or options.annotate:
 249             emit_linenums = False
 250             rootwriter = Annotate.AnnotationCCodeWriter()
 251         else:
 252             emit_linenums = options.emit_linenums
 253             rootwriter = Code.CCodeWriter(emit_linenums=emit_linenums)
 254         globalstate = Code.GlobalState(rootwriter, emit_linenums)
 255         globalstate.initialize_main_c_code()
 256         h_code = globalstate['h_code']
 257
 258         self.generate_module_preamble(env, modules, h_code)
 259
 260         globalstate.module_pos = self.pos
 261         globalstate.directives = self.directives
 262
 263         globalstate.use_utility_code(refnanny_utility_code)
 264
 265         code = globalstate['before_global_var']
 266         code.putln('#define __Pyx_MODULE_NAME "%s"' % self.full_module_name)
 267         code.putln("int %s%s = 0;" % (Naming.module_is_main, self.full_module_name.replace('.', '__')))
 268         code.putln("")
 269         code.putln("/* Implementation of %s */" % env.qualified_name)
 270
 271         code = globalstate['all_the_rest']
 272
 273         self.generate_cached_builtins_decls(env, code)
 274         self.body.generate_function_definitions(env, code)
 275         code.mark_pos(None)
 276         self.generate_typeobj_definitions(env, code)
 277         self.generate_method_table(env, code)
 278         self.generate_filename_init_prototype(code)
 279         if env.has_import_star:
 280             self.generate_import_star(env, code)
 281         self.generate_pymoduledef_struct(env, code)
 282
 283         # init_globals is inserted before this
 284         self.generate_module_init_func(modules[:-1], env, globalstate['init_module'])
 285         self.generate_module_cleanup_func(env, globalstate['cleanup_module'])
 286         if Options.embed:
 287             self.generate_main_method(env, globalstate['main_method'])
 288         self.generate_filename_table(globalstate['filename_table'])
 289
 290         self.generate_declarations_for_modules(env, modules, globalstate)
 291         h_code.write('\n')
 292
 293         for utilcode in env.utility_code_list:
 294             globalstate.use_utility_code(utilcode)
 295         globalstate.finalize_main_c_code()
 296
 297         f = open_new_file(result.c_file)
 298         rootwriter.copyto(f)
 299         f.close()
 300         result.c_file_generated = 1
 301         if Options.annotate or options.annotate:
 302             self.annotate(rootwriter)
 303             rootwriter.save_annotation(result.main_source_file, result.c_file)
 304
 305     def find_referenced_modules(self, env, module_list, modules_seen):
 306         if env not in modules_seen:
 307             modules_seen[env] = 1
 308             for imported_module in env.cimported_modules:
 309                 self.find_referenced_modules(imported_module, module_list, modules_seen)
 310             module_list.append(env)
 311
 312     def sort_types_by_inheritance(self, type_dict, getkey):
 313         # copy the types into a list moving each parent type before
 314         # its first child
 315         type_items = type_dict.items()
 316         type_list = []
 317         for i, item in enumerate(type_items):
 318             key, new_entry = item
 319
 320             # collect all base classes to check for children
 321             hierarchy = set()
 322             base = new_entry
 323             while base:
 324                 base_type = base.type.base_type
 325                 if not base_type:
 326                     break
 327                 base_key = getkey(base_type)
 328                 hierarchy.add(base_key)
 329                 base = type_dict.get(base_key)
 330             new_entry.base_keys = hierarchy
 331
 332             # find the first (sub-)subclass and insert before that
 333             for j in range(i):
 334                 entry = type_list[j]
 335                 if key in entry.base_keys:
 336                     type_list.insert(j, new_entry)
 337                     break
 338             else:
 339                 type_list.append(new_entry)
 340         return type_list
 341
 342     def sort_type_hierarchy(self, module_list, env):
 343         vtab_dict = {}
 344         vtabslot_dict = {}
 345         for module in module_list:
 346             for entry in module.c_class_entries:
 347                 if not entry.in_cinclude:
 348                     type = entry.type
 349                     if type.vtabstruct_cname:
 350                         vtab_dict[type.vtabstruct_cname] = entry
 351             all_defined_here = module is env
 352             for entry in module.type_entries:
 353                 if all_defined_here or entry.defined_in_pxd:
 354                     type = entry.type
 355                     if type.is_extension_type and not entry.in_cinclude:
 356                         type = entry.type
 357                         vtabslot_dict[type.objstruct_cname] = entry
 358
 359         def vtabstruct_cname(entry_type):
 360             return entry_type.vtabstruct_cname
 361         vtab_list = self.sort_types_by_inheritance(
 362             vtab_dict, vtabstruct_cname)
 363
 364         def objstruct_cname(entry_type):
 365             return entry_type.objstruct_cname
 366         vtabslot_list = self.sort_types_by_inheritance(
 367             vtabslot_dict, objstruct_cname)
 368
 369         return (vtab_list, vtabslot_list)
 370
 371     def generate_type_definitions(self, env, modules, vtab_list, vtabslot_list, code):
 372         vtabslot_entries = set(vtabslot_list)
 373         for module in modules:
 374             definition = module is env
 375             if definition:
 376                 type_entries = module.type_entries
 377             else:
 378                 type_entries = []
 379                 for entry in module.type_entries:
 380                     if entry.defined_in_pxd:
 381                         type_entries.append(entry)
 382             for entry in type_entries:
 383                 if not entry.in_cinclude:
 384                     #print "generate_type_header_code:", entry.name, repr(entry.type) ###
 385                     type = entry.type
 386                     if type.is_typedef: # Must test this first!
 387                         self.generate_typedef(entry, code)
 388                     elif type.is_struct_or_union:
 389                         self.generate_struct_union_definition(entry, code)
 390                     elif type.is_enum:
 391                         self.generate_enum_definition(entry, code)
 392                     elif type.is_extension_type and entry not in vtabslot_entries:
 393                         self.generate_obj_struct_definition(type, code)
 394         for entry in vtabslot_list:
 395             self.generate_obj_struct_definition(entry.type, code)
 396         for entry in vtab_list:
 397             self.generate_typeobject_predeclaration(entry, code)
 398             self.generate_exttype_vtable_struct(entry, code)
 399             self.generate_exttype_vtabptr_declaration(entry, code)
 400
 401     def generate_declarations_for_modules(self, env, modules, globalstate):
 402         typecode = globalstate['type_declarations']
 403         typecode.putln("")
 404         typecode.putln("/* Type declarations */")
 405         vtab_list, vtabslot_list = self.sort_type_hierarchy(modules, env)
 406         self.generate_type_definitions(
 407             env, modules, vtab_list, vtabslot_list, typecode)
 408         modulecode = globalstate['module_declarations']
 409         for module in modules:
 410             defined_here = module is env
 411             modulecode.putln("/* Module declarations from %s */" %
 412                        module.qualified_name.encode("ASCII", "ignore"))
 413             self.generate_global_declarations(module, modulecode, defined_here)
 414             self.generate_cfunction_predeclarations(module, modulecode, defined_here)
 415
 416     def generate_module_preamble(self, env, cimported_modules, code):
 417         code.putln('/* Generated by Cython %s on %s */' % (
 418             Version.version, time.asctime()))
 419         code.putln('')
 420         code.putln('#define PY_SSIZE_T_CLEAN')
 421         for filename in env.python_include_files:
 422             code.putln('#include "%s"' % filename)
 423         code.putln("#ifndef Py_PYTHON_H")
 424         code.putln("    #error Python headers needed to compile C extensions, please install development version of Python.")
 425         code.putln("#else")
 426         code.globalstate["end"].putln("#endif /* Py_PYTHON_H */")
 427         code.putln("#ifndef PY_LONG_LONG")
 428         code.putln("  #define PY_LONG_LONG LONG_LONG")
 429         code.putln("#endif")
 430         code.putln("#ifndef DL_EXPORT")
 431         code.putln("  #define DL_EXPORT(t) t")
 432         code.putln("#endif")
 433         code.putln("#if PY_VERSION_HEX < 0x02040000")
 434         code.putln("  #define METH_COEXIST 0")
 435         code.putln("  #define PyDict_CheckExact(op) (Py_TYPE(op) == &PyDict_Type)")
 436         code.putln("  #define PyDict_Contains(d,o)   PySequence_Contains(d,o)")
 437         code.putln("#endif")
 438
 439         code.putln("#if PY_VERSION_HEX < 0x02050000")
 440         code.putln("  typedef int Py_ssize_t;")
 441         code.putln("  #define PY_SSIZE_T_MAX INT_MAX")
 442         code.putln("  #define PY_SSIZE_T_MIN INT_MIN")
 443         code.putln("  #define PY_FORMAT_SIZE_T \"\"")
 444         code.putln("  #define PyInt_FromSsize_t(z) PyInt_FromLong(z)")
 445         code.putln("  #define PyInt_AsSsize_t(o)   PyInt_AsLong(o)")
 446         code.putln("  #define PyNumber_Index(o)    PyNumber_Int(o)")
 447         code.putln("  #define PyIndex_Check(o)     PyNumber_Check(o)")
 448         code.putln("#endif")
 449
 450         code.putln("#if PY_VERSION_HEX < 0x02060000")
 451         code.putln("  #define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)")
 452         code.putln("  #define Py_TYPE(ob)   (((PyObject*)(ob))->ob_type)")
 453         code.putln("  #define Py_SIZE(ob)   (((PyVarObject*)(ob))->ob_size)")
 454         code.putln("  #define PyVarObject_HEAD_INIT(type, size) \\")
 455         code.putln("          PyObject_HEAD_INIT(type) size,")
 456         code.putln("  #define PyType_Modified(t)")
 457         code.putln("  #define PyBytes_CheckExact PyString_CheckExact")
 458         code.putln("")
 459         code.putln("  typedef struct {")
 460         code.putln("     void *buf;")
 461         code.putln("     PyObject *obj;")
 462         code.putln("     Py_ssize_t len;")
 463         code.putln("     Py_ssize_t itemsize;")
 464         code.putln("     int readonly;")
 465         code.putln("     int ndim;")
 466         code.putln("     char *format;")
 467         code.putln("     Py_ssize_t *shape;")
 468         code.putln("     Py_ssize_t *strides;")
 469         code.putln("     Py_ssize_t *suboffsets;")
 470         code.putln("     void *internal;")
 471         code.putln("  } Py_buffer;")
 472         code.putln("")
 473         code.putln("  #define PyBUF_SIMPLE 0")
 474         code.putln("  #define PyBUF_WRITABLE 0x0001")
 475         code.putln("  #define PyBUF_FORMAT 0x0004")
 476         code.putln("  #define PyBUF_ND 0x0008")
 477         code.putln("  #define PyBUF_STRIDES (0x0010 | PyBUF_ND)")
 478         code.putln("  #define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)")
 479         code.putln("  #define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)")
 480         code.putln("  #define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)")
 481         code.putln("  #define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)")
 482         code.putln("")
 483         code.putln("#endif")
 484
 485         code.put(builtin_module_name_utility_code.proto)
 486
 487         code.putln("#if PY_MAJOR_VERSION >= 3")
 488         code.putln("  #define Py_TPFLAGS_CHECKTYPES 0")
 489         code.putln("  #define Py_TPFLAGS_HAVE_INDEX 0")
 490         code.putln("#endif")
 491
 492         code.putln("#if (PY_VERSION_HEX < 0x02060000) || (PY_MAJOR_VERSION >= 3)")
 493         code.putln("  #define Py_TPFLAGS_HAVE_NEWBUFFER 0")
 494         code.putln("#endif")
 495
 496         code.putln("#if PY_MAJOR_VERSION >= 3")
 497         code.putln("  #define PyBaseString_Type            PyUnicode_Type")
 498         code.putln("  #define PyString_Type                PyUnicode_Type")
 499         code.putln("  #define PyString_CheckExact          PyUnicode_CheckExact")
 500         code.putln("  #define PyInt_Type                   PyLong_Type")
 501         code.putln("  #define PyInt_Check(op)              PyLong_Check(op)")
 502         code.putln("  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)")
 503         code.putln("  #define PyInt_FromString             PyLong_FromString")
 504         code.putln("  #define PyInt_FromUnicode            PyLong_FromUnicode")
 505         code.putln("  #define PyInt_FromLong               PyLong_FromLong")
 506         code.putln("  #define PyInt_FromSize_t             PyLong_FromSize_t")
 507         code.putln("  #define PyInt_FromSsize_t            PyLong_FromSsize_t")
 508         code.putln("  #define PyInt_AsLong                 PyLong_AsLong")
 509         code.putln("  #define PyInt_AS_LONG                PyLong_AS_LONG")
 510         code.putln("  #define PyInt_AsSsize_t              PyLong_AsSsize_t")
 511         code.putln("  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask")
 512         code.putln("  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask")
 513         code.putln("  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)")
 514         code.putln("  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)")
 515         code.putln("#else")
 516         if Future.division in env.context.future_directives:
 517             code.putln("  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)")
 518             code.putln("  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)")
 519         else:
 520             code.putln("  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)")
 521             code.putln("  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)")
 522         code.putln("  #define PyBytes_Type                 PyString_Type")
 523         code.putln("#endif")
 524
 525         code.putln("#if PY_MAJOR_VERSION >= 3")
 526         code.putln("  #define PyMethod_New(func, self, klass) PyInstanceMethod_New(func)")
 527         code.putln("#endif")
 528
 529         code.putln("#if !defined(WIN32) && !defined(MS_WINDOWS)")
 530         code.putln("  #ifndef __stdcall")
 531         code.putln("    #define __stdcall")
 532         code.putln("  #endif")
 533         code.putln("  #ifndef __cdecl")
 534         code.putln("    #define __cdecl")
 535         code.putln("  #endif")
 536         code.putln("  #ifndef __fastcall")
 537         code.putln("    #define __fastcall")
 538         code.putln("  #endif")
 539         code.putln("#else")
 540         code.putln("  #define _USE_MATH_DEFINES")
 541         code.putln("#endif")
 542
 543         code.putln("#if PY_VERSION_HEX < 0x02050000")
 544         code.putln("  #define __Pyx_GetAttrString(o,n)   PyObject_GetAttrString((o),((char *)(n)))")
 545         code.putln("  #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),((char *)(n)),(a))")
 546         code.putln("  #define __Pyx_DelAttrString(o,n)   PyObject_DelAttrString((o),((char *)(n)))")
 547         code.putln("#else")
 548         code.putln("  #define __Pyx_GetAttrString(o,n)   PyObject_GetAttrString((o),(n))")
 549         code.putln("  #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),(n),(a))")
 550         code.putln("  #define __Pyx_DelAttrString(o,n)   PyObject_DelAttrString((o),(n))")
 551         code.putln("#endif")
 552
 553         code.putln("#if PY_VERSION_HEX < 0x02050000")
 554         code.putln("  #define __Pyx_NAMESTR(n) ((char *)(n))")
 555         code.putln("  #define __Pyx_DOCSTR(n)  ((char *)(n))")
 556         code.putln("#else")
 557         code.putln("  #define __Pyx_NAMESTR(n) (n)")
 558         code.putln("  #define __Pyx_DOCSTR(n)  (n)")
 559         code.putln("#endif")
 560
 561         self.generate_extern_c_macro_definition(code)
 562         code.putln("#include <math.h>")
 563         code.putln("#define %s" % Naming.api_guard_prefix + self.api_name(env))
 564         self.generate_includes(env, cimported_modules, code)
 565         if env.directives['ccomplex']:
 566             code.putln("")
 567             code.putln("#if !defined(CYTHON_CCOMPLEX)")
 568             code.putln("#define CYTHON_CCOMPLEX 1")
 569             code.putln("#endif")
 570             code.putln("")
 571         code.put(Nodes.utility_function_predeclarations)
 572         code.put(PyrexTypes.type_conversion_predeclarations)
 573         code.put(Nodes.branch_prediction_macros)
 574         code.putln('')
 575         code.putln('static PyObject *%s;' % env.module_cname)
 576         code.putln('static PyObject *%s;' % Naming.builtins_cname)
 577         code.putln('static PyObject *%s;' % Naming.empty_tuple)
 578         code.putln('static PyObject *%s;' % Naming.empty_bytes)
 579         if Options.pre_import is not None:
 580             code.putln('static PyObject *%s;' % Naming.preimport_cname)
 581         code.putln('static int %s;' % Naming.lineno_cname)
 582         code.putln('static int %s = 0;' % Naming.clineno_cname)
 583         code.putln('static const char * %s= %s;' % (Naming.cfilenm_cname, Naming.file_c_macro))
 584         code.putln('static const char *%s;' % Naming.filename_cname)
 585         code.putln('static const char **%s;' % Naming.filetable_cname)
 586
 587         # XXX this is a mess
 588         for utility_code in PyrexTypes.c_int_from_py_function.specialize_list:
 589             env.use_utility_code(utility_code)
 590         for utility_code in PyrexTypes.c_long_from_py_function.specialize_list:
 591             env.use_utility_code(utility_code)
 592
 593     def generate_extern_c_macro_definition(self, code):
 594         name = Naming.extern_c_macro
 595         code.putln("#ifdef __cplusplus")
 596         code.putln('#define %s extern "C"' % name)
 597         code.putln("#else")
 598         code.putln("#define %s extern" % name)
 599         code.putln("#endif")
 600
 601     def generate_includes(self, env, cimported_modules, code):
 602         includes = []
 603         for filename in env.include_files:
 604             # fake decoding of filenames to their original byte sequence
 605             code.putln('#include "%s"' % filename)
 606
 607     def generate_filename_table(self, code):
 608         code.putln("")
 609         code.putln("static const char *%s[] = {" % Naming.filenames_cname)
 610         if code.globalstate.filename_list:
 611             for source_desc in code.globalstate.filename_list:
 612                 filename = os.path.basename(source_desc.get_filenametable_entry())
 613                 escaped_filename = filename.replace("\\", "\\\\").replace('"', r'\"')
 614                 code.putln('"%s",' %
 615                     escaped_filename)
 616         else:
 617             # Some C compilers don't like an empty array
 618             code.putln("0")
 619         code.putln("};")
 620
 621     def generate_type_predeclarations(self, env, code):
 622         pass
 623
 624     def generate_type_header_code(self, type_entries, code):
 625         # Generate definitions of structs/unions/enums/typedefs/objstructs.
 626         #self.generate_gcc33_hack(env, code) # Is this still needed?
 627         #for entry in env.type_entries:
 628         for entry in type_entries:
 629             if not entry.in_cinclude:
 630                 #print "generate_type_header_code:", entry.name, repr(entry.type) ###
 631                 type = entry.type
 632                 if type.is_typedef: # Must test this first!
 633                     self.generate_typedef(entry, code)
 634                 elif type.is_struct_or_union:
 635                     self.generate_struct_union_definition(entry, code)
 636                 elif type.is_enum:
 637                     self.generate_enum_definition(entry, code)
 638                 elif type.is_extension_type:
 639                     self.generate_obj_struct_definition(type, code)
 640
 641     def generate_gcc33_hack(self, env, code):
 642         # Workaround for spurious warning generation in gcc 3.3
 643         code.putln("")
 644         for entry in env.c_class_entries:
 645             type = entry.type
 646             if not type.typedef_flag:
 647                 name = type.objstruct_cname
 648                 if name.startswith("__pyx_"):
 649                     tail = name[6:]
 650                 else:
 651                     tail = name
 652                 code.putln("typedef struct %s __pyx_gcc33_%s;" % (
 653                     name, tail))
 654
 655     def generate_typedef(self, entry, code):
 656         base_type = entry.type.typedef_base_type
 657         code.putln("")
 658         code.putln("typedef %s;" % base_type.declaration_code(entry.cname))
 659
 660     def sue_header_footer(self, type, kind, name):
 661         if type.typedef_flag:
 662             header = "typedef %s {" % kind
 663             footer = "} %s;" % name
 664         else:
 665             header = "%s %s {" % (kind, name)
 666             footer = "};"
 667         return header, footer
 668
 669     def generate_struct_union_definition(self, entry, code):
 670         code.mark_pos(entry.pos)
 671         type = entry.type
 672         scope = type.scope
 673         if scope:
 674             kind = type.kind
 675             packed = type.is_struct and type.packed
 676             if packed:
 677                 kind = "%s %s" % (type.kind, "__Pyx_PACKED")
 678                 code.globalstate.use_utility_code(packed_struct_utility_code)
 679             header, footer = \
 680                 self.sue_header_footer(type, kind, type.cname)
 681             code.putln("")
 682             if packed:
 683                 code.putln("#if !defined(__GNUC__)")
 684                 code.putln("#pragma pack(push, 1)")
 685                 code.putln("#endif")
 686             code.putln(header)
 687             var_entries = scope.var_entries
 688             if not var_entries:
 689                 error(entry.pos,
 690                     "Empty struct or union definition not allowed outside a"
 691                     " 'cdef extern from' block")
 692             for attr in var_entries:
 693                 code.putln(
 694                     "%s;" %
 695                         attr.type.declaration_code(attr.cname))
 696             code.putln(footer)
 697             if packed:
 698                 code.putln("#if !defined(__GNUC__)")
 699                 code.putln("#pragma pack(pop)")
 700                 code.putln("#endif")
 701
 702     def generate_enum_definition(self, entry, code):
 703         code.mark_pos(entry.pos)
 704         type = entry.type
 705         name = entry.cname or entry.name or ""
 706         header, footer = \
 707             self.sue_header_footer(type, "enum", name)
 708         code.putln("")
 709         code.putln(header)
 710         enum_values = entry.enum_values
 711         if not enum_values:
 712             error(entry.pos,
 713                 "Empty enum definition not allowed outside a"
 714                 " 'cdef extern from' block")
 715         else:
 716             last_entry = enum_values[-1]
 717             # this does not really generate code, just builds the result value
 718             for value_entry in enum_values:
 719                 if value_entry.value_node is not None:
 720                     value_entry.value_node.generate_evaluation_code(code)
 721
 722             for value_entry in enum_values:
 723                 if value_entry.value_node is None:
 724                     value_code = value_entry.cname
 725                 else:
 726                     value_code = ("%s = %s" % (
 727                         value_entry.cname,
 728                         value_entry.value_node.result()))
 729                 if value_entry is not last_entry:
 730                     value_code += ","
 731                 code.putln(value_code)
 732         code.putln(footer)
 733
 734     def generate_typeobject_predeclaration(self, entry, code):
 735         code.putln("")
 736         name = entry.type.typeobj_cname
 737         if name:
 738             if entry.visibility == 'extern' and not entry.in_cinclude:
 739                 code.putln("%s DL_IMPORT(PyTypeObject) %s;" % (
 740                     Naming.extern_c_macro,
 741                     name))
 742             elif entry.visibility == 'public':
 743                 #code.putln("DL_EXPORT(PyTypeObject) %s;" % name)
 744                 code.putln("%s DL_EXPORT(PyTypeObject) %s;" % (
 745                     Naming.extern_c_macro,
 746                     name))
 747             # ??? Do we really need the rest of this? ???
 748             #else:
 749             #    code.putln("staticforward PyTypeObject %s;" % name)
 750
 751     def generate_exttype_vtable_struct(self, entry, code):
 752         code.mark_pos(entry.pos)
 753         # Generate struct declaration for an extension type's vtable.
 754         type = entry.type
 755         scope = type.scope
 756         if type.vtabstruct_cname:
 757             code.putln("")
 758             code.putln(
 759                 "struct %s {" %
 760                     type.vtabstruct_cname)
 761             if type.base_type and type.base_type.vtabstruct_cname:
 762                 code.putln("struct %s %s;" % (
 763                     type.base_type.vtabstruct_cname,
 764                     Naming.obj_base_cname))
 765             for method_entry in scope.cfunc_entries:
 766                 if not method_entry.is_inherited:
 767                     code.putln(
 768                         "%s;" % method_entry.type.declaration_code("(*%s)" % method_entry.name))
 769             code.putln(
 770                 "};")
 771
 772     def generate_exttype_vtabptr_declaration(self, entry, code):
 773         code.mark_pos(entry.pos)
 774         # Generate declaration of pointer to an extension type's vtable.
 775         type = entry.type
 776         if type.vtabptr_cname:
 777             code.putln("static struct %s *%s;" % (
 778                 type.vtabstruct_cname,
 779                 type.vtabptr_cname))
 780
 781     def generate_obj_struct_definition(self, type, code):
 782         code.mark_pos(type.pos)
 783         # Generate object struct definition for an
 784         # extension type.
 785         if not type.scope:
 786             return # Forward declared but never defined
 787         header, footer = \
 788             self.sue_header_footer(type, "struct", type.objstruct_cname)
 789         code.putln("")
 790         code.putln(header)
 791         base_type = type.base_type
 792         if base_type:
 793             code.putln(
 794                 "%s%s %s;" % (
 795                     ("struct ", "")[base_type.typedef_flag],
 796                     base_type.objstruct_cname,
 797                     Naming.obj_base_cname))
 798         else:
 799             code.putln(
 800                 "PyObject_HEAD")
 801         if type.vtabslot_cname and not (type.base_type and type.base_type.vtabslot_cname):
 802             code.putln(
 803                 "struct %s *%s;" % (
 804                     type.vtabstruct_cname,
 805                     type.vtabslot_cname))
 806         for attr in type.scope.var_entries:
 807             code.putln(
 808                 "%s;" %
 809                     attr.type.declaration_code(attr.cname))
 810         code.putln(footer)
 811         if type.objtypedef_cname is not None:
 812             # Only for exposing public typedef name.
 813             code.putln("typedef struct %s %s;" % (type.objstruct_cname, type.objtypedef_cname))
 814
 815     def generate_global_declarations(self, env, code, definition):
 816         code.putln("")
 817         for entry in env.c_class_entries:
 818             if definition or entry.defined_in_pxd:
 819                 code.putln("static PyTypeObject *%s = 0;" %
 820                     entry.type.typeptr_cname)
 821         code.put_var_declarations(env.var_entries, static = 1,
 822             dll_linkage = "DL_EXPORT", definition = definition)
 823
 824     def generate_cfunction_predeclarations(self, env, code, definition):
 825         for entry in env.cfunc_entries:
 826             if entry.inline_func_in_pxd or (not entry.in_cinclude and (definition
 827                     or entry.defined_in_pxd or entry.visibility == 'extern')):
 828                 if entry.visibility in ('public', 'extern'):
 829                     dll_linkage = "DL_EXPORT"
 830                 else:
 831                     dll_linkage = None
 832                 type = entry.type
 833                 if not definition and entry.defined_in_pxd:
 834                     type = CPtrType(type)
 835                 header = type.declaration_code(entry.cname,
 836                     dll_linkage = dll_linkage)
 837                 if entry.visibility == 'private':
 838                     storage_class = "static "
 839                 elif entry.visibility == 'public':
 840                     storage_class = ""
 841                 else:
 842                     storage_class = "%s " % Naming.extern_c_macro
 843                 if entry.func_modifiers:
 844                     modifiers = '%s ' % ' '.join([
 845                             modifier.upper() for modifier in entry.func_modifiers])
 846                 else:
 847                     modifiers = ''
 848                 code.putln("%s%s%s; /*proto*/" % (
 849                     storage_class,
 850                     modifiers,
 851                     header))
 852
 853     def generate_typeobj_definitions(self, env, code):
 854         full_module_name = env.qualified_name
 855         for entry in env.c_class_entries:
 856             #print "generate_typeobj_definitions:", entry.name
 857             #print "...visibility =", entry.visibility
 858             if entry.visibility != 'extern':
 859                 type = entry.type
 860                 scope = type.scope
 861                 if scope: # could be None if there was an error
 862                     self.generate_exttype_vtable(scope, code)
 863                     self.generate_new_function(scope, code)
 864                     self.generate_dealloc_function(scope, code)
 865                     if scope.needs_gc():
 866                         self.generate_traverse_function(scope, code)
 867                         self.generate_clear_function(scope, code)
 868                     if scope.defines_any(["__getitem__"]):
 869                         self.generate_getitem_int_function(scope, code)
 870                     if scope.defines_any(["__setitem__", "__delitem__"]):
 871                         self.generate_ass_subscript_function(scope, code)
 872                     if scope.defines_any(["__setslice__", "__delslice__"]):
 873                         warning(self.pos, "__setslice__ and __delslice__ are not supported by Python 3, use __setitem__ and __getitem__ instead", 1)
 874                         self.generate_ass_slice_function(scope, code)
 875                     if scope.defines_any(["__getattr__","__getattribute__"]):
 876                         self.generate_getattro_function(scope, code)
 877                     if scope.defines_any(["__setattr__", "__delattr__"]):
 878                         self.generate_setattro_function(scope, code)
 879                     if scope.defines_any(["__get__"]):
 880                         self.generate_descr_get_function(scope, code)
 881                     if scope.defines_any(["__set__", "__delete__"]):
 882                         self.generate_descr_set_function(scope, code)
 883                     self.generate_property_accessors(scope, code)
 884                     self.generate_method_table(scope, code)
 885                     self.generate_member_table(scope, code)
 886                     self.generate_getset_table(scope, code)
 887                     self.generate_typeobj_definition(full_module_name, entry, code)
 888
 889     def generate_exttype_vtable(self, scope, code):
 890         # Generate the definition of an extension type's vtable.
 891         type = scope.parent_type
 892         if type.vtable_cname:
 893             code.putln("static struct %s %s;" % (
 894                 type.vtabstruct_cname,
 895                 type.vtable_cname))
 896
 897     def generate_self_cast(self, scope, code):
 898         type = scope.parent_type
 899         code.putln(
 900             "%s = (%s)o;" % (
 901                 type.declaration_code("p"),
 902                 type.declaration_code("")))
 903
 904     def generate_new_function(self, scope, code):
 905         tp_slot = TypeSlots.ConstructorSlot("tp_new", '__new__')
 906         slot_func = scope.mangle_internal("tp_new")
 907         type = scope.parent_type
 908         base_type = type.base_type
 909         py_attrs = []
 910         for entry in scope.var_entries:
 911             if entry.type.is_pyobject:
 912                 py_attrs.append(entry)
 913         need_self_cast = type.vtabslot_cname or py_attrs
 914         code.putln("")
 915         code.putln(
 916             "static PyObject *%s(PyTypeObject *t, PyObject *a, PyObject *k) {"
 917                 % scope.mangle_internal("tp_new"))
 918         if need_self_cast:
 919             code.putln(
 920                 "%s;"
 921                     % scope.parent_type.declaration_code("p"))
 922         if base_type:
 923             tp_new = TypeSlots.get_base_slot_function(scope, tp_slot)
 924             if tp_new is None:
 925                 tp_new = "%s->tp_new" % base_type.typeptr_cname
 926             code.putln(
 927                 "PyObject *o = %s(t, a, k);" % tp_new)
 928         else:
 929             code.putln(
 930                 "PyObject *o = (*t->tp_alloc)(t, 0);")
 931         code.putln(
 932                 "if (!o) return 0;")
 933         if need_self_cast:
 934             code.putln(
 935                 "p = %s;"
 936                     % type.cast_code("o"))
 937         #if need_self_cast:
 938         #    self.generate_self_cast(scope, code)
 939         if type.vtabslot_cname:
 940             vtab_base_type = type
 941             while vtab_base_type.base_type and vtab_base_type.base_type.vtabstruct_cname:
 942                 vtab_base_type = vtab_base_type.base_type
 943             if vtab_base_type is not type:
 944                 struct_type_cast = "(struct %s*)" % vtab_base_type.vtabstruct_cname
 945             else:
 946                 struct_type_cast = ""
 947             code.putln("p->%s = %s%s;" % (
 948                 type.vtabslot_cname,
 949                 struct_type_cast, type.vtabptr_cname))
 950         for entry in py_attrs:
 951             if entry.name == "__weakref__":
 952                 code.putln("p->%s = 0;" % entry.cname)
 953             else:
 954                 code.put_init_var_to_py_none(entry, "p->%s", nanny=False)
 955         entry = scope.lookup_here("__new__")
 956         if entry and entry.is_special:
 957             if entry.trivial_signature:
 958                 cinit_args = "o, %s, NULL" % Naming.empty_tuple
 959             else:
 960                 cinit_args = "o, a, k"
 961             code.putln(
 962                 "if (%s(%s) < 0) {" %
 963                     (entry.func_cname, cinit_args))
 964             code.put_decref_clear("o", py_object_type, nanny=False);
 965             code.putln(
 966                 "}")
 967         code.putln(
 968             "return o;")
 969         code.putln(
 970             "}")
 971
 972     def generate_dealloc_function(self, scope, code):
 973         tp_slot = TypeSlots.ConstructorSlot("tp_dealloc", '__dealloc__')
 974         slot_func = scope.mangle_internal("tp_dealloc")
 975         base_type = scope.parent_type.base_type
 976         if tp_slot.slot_code(scope) != slot_func:
 977             return # never used
 978         code.putln("")
 979         code.putln(
 980             "static void %s(PyObject *o) {"
 981                 % scope.mangle_internal("tp_dealloc"))
 982         py_attrs = []
 983         weakref_slot = scope.lookup_here("__weakref__")
 984         for entry in scope.var_entries:
 985             if entry.type.is_pyobject and entry is not weakref_slot:
 986                 py_attrs.append(entry)
 987         if py_attrs or weakref_slot in scope.var_entries:
 988             self.generate_self_cast(scope, code)
 989         self.generate_usr_dealloc_call(scope, code)
 990         if weakref_slot in scope.var_entries:
 991             code.putln("if (p->__weakref__) PyObject_ClearWeakRefs(o);")
 992         for entry in py_attrs:
 993             code.put_xdecref("p->%s" % entry.cname, entry.type, nanny=False)
 994         if base_type:
 995             tp_dealloc = TypeSlots.get_base_slot_function(scope, tp_slot)
 996             if tp_dealloc is None:
 997                 tp_dealloc = "%s->tp_dealloc" % base_type.typeptr_cname
 998             code.putln(
 999                     "%s(o);" % tp_dealloc)
1000         else:
1001             code.putln(
1002                     "(*Py_TYPE(o)->tp_free)(o);")
1003         code.putln(
1004             "}")
1005
1006     def generate_usr_dealloc_call(self, scope, code):
1007         entry = scope.lookup_here("__dealloc__")
1008         if entry:
1009             code.putln(
1010                 "{")
1011             code.putln(
1012                     "PyObject *etype, *eval, *etb;")
1013             code.putln(
1014                     "PyErr_Fetch(&etype, &eval, &etb);")
1015             code.putln(
1016                     "++Py_REFCNT(o);")
1017             code.putln(
1018                     "%s(o);" %
1019                         entry.func_cname)
1020             code.putln(
1021                     "if (PyErr_Occurred()) PyErr_WriteUnraisable(o);")
1022             code.putln(
1023                     "--Py_REFCNT(o);")
1024             code.putln(
1025                     "PyErr_Restore(etype, eval, etb);")
1026             code.putln(
1027                 "}")
1028
1029     def generate_traverse_function(self, scope, code):
1030         tp_slot = TypeSlots.GCDependentSlot("tp_traverse")
1031         slot_func = scope.mangle_internal("tp_traverse")
1032         base_type = scope.parent_type.base_type
1033         if tp_slot.slot_code(scope) != slot_func:
1034             return # never used
1035         code.putln("")
1036         code.putln(
1037             "static int %s(PyObject *o, visitproc v, void *a) {"
1038                 % slot_func)
1039         py_attrs = []
1040         for entry in scope.var_entries:
1041             if entry.type.is_pyobject and entry.name != "__weakref__":
1042                 py_attrs.append(entry)
1043         if base_type or py_attrs:
1044             code.putln("int e;")
1045         if py_attrs:
1046             self.generate_self_cast(scope, code)
1047         if base_type:
1048             # want to call it explicitly if possible so inlining can be performed
1049             static_call = TypeSlots.get_base_slot_function(scope, tp_slot)
1050             if static_call:
1051                 code.putln("e = %s(o, v, a); if (e) return e;" % static_call)
1052             else:
1053                 code.putln("if (%s->tp_traverse) {" % base_type.typeptr_cname)
1054                 code.putln(
1055                         "e = %s->tp_traverse(o, v, a); if (e) return e;" %
1056                             base_type.typeptr_cname)
1057                 code.putln("}")
1058         for entry in py_attrs:
1059             var_code = "p->%s" % entry.cname
1060             code.putln(
1061                     "if (%s) {"
1062                         % var_code)
1063             if entry.type.is_extension_type:
1064                 var_code = "((PyObject*)%s)" % var_code
1065             code.putln(
1066                         "e = (*v)(%s, a); if (e) return e;"
1067                             % var_code)
1068             code.putln(
1069                     "}")
1070         code.putln(
1071                 "return 0;")
1072         code.putln(
1073             "}")
1074
1075     def generate_clear_function(self, scope, code):
1076         tp_slot = TypeSlots.GCDependentSlot("tp_clear")
1077         slot_func = scope.mangle_internal("tp_clear")
1078         base_type = scope.parent_type.base_type
1079         if tp_slot.slot_code(scope) != slot_func:
1080             return # never used
1081         code.putln("")
1082         code.putln("static int %s(PyObject *o) {" % slot_func)
1083         py_attrs = []
1084         for entry in scope.var_entries:
1085             if entry.type.is_pyobject and entry.name != "__weakref__":
1086                 py_attrs.append(entry)
1087         if py_attrs:
1088             self.generate_self_cast(scope, code)
1089             code.putln("PyObject* tmp;")
1090         if base_type:
1091             # want to call it explicitly if possible so inlining can be performed
1092             static_call = TypeSlots.get_base_slot_function(scope, tp_slot)
1093             if static_call:
1094                 code.putln("%s(o);" % static_call)
1095             else:
1096                 code.putln("if (%s->tp_clear) {" % base_type.typeptr_cname)
1097                 code.putln("%s->tp_clear(o);" % base_type.typeptr_cname)
1098                 code.putln("}")
1099         for entry in py_attrs:
1100             name = "p->%s" % entry.cname
1101             code.putln("tmp = ((PyObject*)%s);" % name)
1102             code.put_init_to_py_none(name, entry.type, nanny=False)
1103             code.putln("Py_XDECREF(tmp);")
1104         code.putln(
1105             "return 0;")
1106         code.putln(
1107             "}")
1108
1109     def generate_getitem_int_function(self, scope, code):
1110         # This function is put into the sq_item slot when
1111         # a __getitem__ method is present. It converts its
1112         # argument to a Python integer and calls mp_subscript.
1113         code.putln(
1114             "static PyObject *%s(PyObject *o, Py_ssize_t i) {" %
1115                 scope.mangle_internal("sq_item"))
1116         code.putln(
1117                 "PyObject *r;")
1118         code.putln(
1119                 "PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;")
1120         code.putln(
1121                 "r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);")
1122         code.putln(
1123                 "Py_DECREF(x);")
1124         code.putln(
1125                 "return r;")
1126         code.putln(
1127             "}")
1128
1129     def generate_ass_subscript_function(self, scope, code):
1130         # Setting and deleting an item are both done through
1131         # the ass_subscript method, so we dispatch to user's __setitem__
1132         # or __delitem__, or raise an exception.
1133         base_type = scope.parent_type.base_type
1134         set_entry = scope.lookup_here("__setitem__")
1135         del_entry = scope.lookup_here("__delitem__")
1136         code.putln("")
1137         code.putln(
1138             "static int %s(PyObject *o, PyObject *i, PyObject *v) {" %
1139                 scope.mangle_internal("mp_ass_subscript"))
1140         code.putln(
1141                 "if (v) {")
1142         if set_entry:
1143             code.putln(
1144                     "return %s(o, i, v);" %
1145                         set_entry.func_cname)
1146         else:
1147             self.generate_guarded_basetype_call(
1148                 base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code)
1149             code.putln(
1150                     "PyErr_Format(PyExc_NotImplementedError,")
1151             code.putln(
1152                     '  "Subscript assignment not supported by %s", Py_TYPE(o)->tp_name);')
1153             code.putln(
1154                     "return -1;")
1155         code.putln(
1156                 "}")
1157         code.putln(
1158                 "else {")
1159         if del_entry:
1160             code.putln(
1161                     "return %s(o, i);" %
1162                         del_entry.func_cname)
1163         else:
1164             self.generate_guarded_basetype_call(
1165                 base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code)
1166             code.putln(
1167                     "PyErr_Format(PyExc_NotImplementedError,")
1168             code.putln(
1169                     '  "Subscript deletion not supported by %s", Py_TYPE(o)->tp_name);')
1170             code.putln(
1171                     "return -1;")
1172         code.putln(
1173                 "}")
1174         code.putln(
1175             "}")
1176
1177     def generate_guarded_basetype_call(
1178             self, base_type, substructure, slot, args, code):
1179         if base_type:
1180             base_tpname = base_type.typeptr_cname
1181             if substructure:
1182                 code.putln(
1183                     "if (%s->%s && %s->%s->%s)" % (
1184                         base_tpname, substructure, base_tpname, substructure, slot))
1185                 code.putln(
1186                     "  return %s->%s->%s(%s);" % (
1187                         base_tpname, substructure, slot, args))
1188             else:
1189                 code.putln(
1190                     "if (%s->%s)" % (
1191                         base_tpname, slot))
1192                 code.putln(
1193                     "  return %s->%s(%s);" % (
1194                         base_tpname, slot, args))
1195
1196     def generate_ass_slice_function(self, scope, code):
1197         # Setting and deleting a slice are both done through
1198         # the ass_slice method, so we dispatch to user's __setslice__
1199         # or __delslice__, or raise an exception.
1200         code.putln("#if PY_MAJOR_VERSION >= 3")
1201         code.putln("#error __setslice__ and __delslice__ not supported in Python 3.")
1202         code.putln("#endif")
1203         base_type = scope.parent_type.base_type
1204         set_entry = scope.lookup_here("__setslice__")
1205         del_entry = scope.lookup_here("__delslice__")
1206         code.putln("")
1207         code.putln(
1208             "static int %s(PyObject *o, Py_ssize_t i, Py_ssize_t j, PyObject *v) {" %
1209                 scope.mangle_internal("sq_ass_slice"))
1210         code.putln(
1211                 "if (v) {")
1212         if set_entry:
1213             code.putln(
1214                     "return %s(o, i, j, v);" %
1215                         set_entry.func_cname)
1216         else:
1217             self.generate_guarded_basetype_call(
1218                 base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)
1219             code.putln(
1220                     "PyErr_Format(PyExc_NotImplementedError,")
1221             code.putln(
1222                     '  "2-element slice assignment not supported by %s", Py_TYPE(o)->tp_name);')
1223             code.putln(
1224                     "return -1;")
1225         code.putln(
1226                 "}")
1227         code.putln(
1228                 "else {")
1229         if del_entry:
1230             code.putln(
1231                     "return %s(o, i, j);" %
1232                         del_entry.func_cname)
1233         else:
1234             self.generate_guarded_basetype_call(
1235                 base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)
1236             code.putln(
1237                     "PyErr_Format(PyExc_NotImplementedError,")
1238             code.putln(
1239                     '  "2-element slice deletion not supported by %s", Py_TYPE(o)->tp_name);')
1240             code.putln(
1241                     "return -1;")
1242         code.putln(
1243                 "}")
1244         code.putln(
1245             "}")
1246
1247     def generate_getattro_function(self, scope, code):
1248         # First try to get the attribute using __getattribute__, if defined, or
1249         # PyObject_GenericGetAttr.
1250         #
1251         # If that raises an AttributeError, call the __getattr__ if defined.
1252         #
1253         # In both cases, defined can be in this class, or any base class.
1254         def lookup_here_or_base(n,type=None):
1255             # Recursive lookup
1256             if type is None:
1257                 type = scope.parent_type
1258             r = type.scope.lookup_here(n)
1259             if r is None and \
1260                type.base_type is not None:
1261                 return lookup_here_or_base(n,type.base_type)
1262             else:
1263                 return r
1264         getattr_entry = lookup_here_or_base("__getattr__")
1265         getattribute_entry = lookup_here_or_base("__getattribute__")
1266         code.putln("")
1267         code.putln(
1268             "static PyObject *%s(PyObject *o, PyObject *n) {"
1269                 % scope.mangle_internal("tp_getattro"))
1270         if getattribute_entry is not None:
1271             code.putln(
1272                 "PyObject *v = %s(o, n);" %
1273                     getattribute_entry.func_cname)
1274         else:
1275             code.putln(
1276                 "PyObject *v = PyObject_GenericGetAttr(o, n);")
1277         if getattr_entry is not None:
1278             code.putln(
1279                 "if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) {")
1280             code.putln(
1281                 "PyErr_Clear();")
1282             code.putln(
1283                 "v = %s(o, n);" %
1284                     getattr_entry.func_cname)
1285             code.putln(
1286                 "}")
1287         code.putln(
1288             "return v;")
1289         code.putln(
1290             "}")
1291
1292     def generate_setattro_function(self, scope, code):
1293         # Setting and deleting an attribute are both done through
1294         # the setattro method, so we dispatch to user's __setattr__
1295         # or __delattr__ or fall back on PyObject_GenericSetAttr.
1296         base_type = scope.parent_type.base_type
1297         set_entry = scope.lookup_here("__setattr__")
1298         del_entry = scope.lookup_here("__delattr__")
1299         code.putln("")
1300         code.putln(
1301             "static int %s(PyObject *o, PyObject *n, PyObject *v) {" %
1302                 scope.mangle_internal("tp_setattro"))
1303         code.putln(
1304                 "if (v) {")
1305         if set_entry:
1306             code.putln(
1307                     "return %s(o, n, v);" %
1308                         set_entry.func_cname)
1309         else:
1310             self.generate_guarded_basetype_call(
1311                 base_type, None, "tp_setattro", "o, n, v", code)
1312             code.putln(
1313                     "return PyObject_GenericSetAttr(o, n, v);")
1314         code.putln(
1315                 "}")
1316         code.putln(
1317                 "else {")
1318         if del_entry:
1319             code.putln(
1320                     "return %s(o, n);" %
1321                         del_entry.func_cname)
1322         else:
1323             self.generate_guarded_basetype_call(
1324                 base_type, None, "tp_setattro", "o, n, v", code)
1325             code.putln(
1326                     "return PyObject_GenericSetAttr(o, n, 0);")
1327         code.putln(
1328                 "}")
1329         code.putln(
1330             "}")
1331
1332     def generate_descr_get_function(self, scope, code):
1333         # The __get__ function of a descriptor object can be
1334         # called with NULL for the second or third arguments
1335         # under some circumstances, so we replace them with
1336         # None in that case.
1337         user_get_entry = scope.lookup_here("__get__")
1338         code.putln("")
1339         code.putln(
1340             "static PyObject *%s(PyObject *o, PyObject *i, PyObject *c) {" %
1341                 scope.mangle_internal("tp_descr_get"))
1342         code.putln(
1343             "PyObject *r = 0;")
1344         code.putln(
1345             "if (!i) i = Py_None;")
1346         code.putln(
1347             "if (!c) c = Py_None;")
1348         #code.put_incref("i", py_object_type)
1349         #code.put_incref("c", py_object_type)
1350         code.putln(
1351             "r = %s(o, i, c);" %
1352                 user_get_entry.func_cname)
1353         #code.put_decref("i", py_object_type)
1354         #code.put_decref("c", py_object_type)
1355         code.putln(
1356             "return r;")
1357         code.putln(
1358             "}")
1359
1360     def generate_descr_set_function(self, scope, code):
1361         # Setting and deleting are both done through the __set__
1362         # method of a descriptor, so we dispatch to user's __set__
1363         # or __delete__ or raise an exception.
1364         base_type = scope.parent_type.base_type
1365         user_set_entry = scope.lookup_here("__set__")
1366         user_del_entry = scope.lookup_here("__delete__")
1367         code.putln("")
1368         code.putln(
1369             "static int %s(PyObject *o, PyObject *i, PyObject *v) {" %
1370                 scope.mangle_internal("tp_descr_set"))
1371         code.putln(
1372                 "if (v) {")
1373         if user_set_entry:
1374             code.putln(
1375                     "return %s(o, i, v);" %
1376                         user_set_entry.func_cname)
1377         else:
1378             self.generate_guarded_basetype_call(
1379                 base_type, None, "tp_descr_set", "o, i, v", code)
1380             code.putln(
1381                     'PyErr_SetString(PyExc_NotImplementedError, "__set__");')
1382             code.putln(
1383                     "return -1;")
1384         code.putln(
1385                 "}")
1386         code.putln(
1387                 "else {")
1388         if user_del_entry:
1389             code.putln(
1390                     "return %s(o, i);" %
1391                         user_del_entry.func_cname)
1392         else:
1393             self.generate_guarded_basetype_call(
1394                 base_type, None, "tp_descr_set", "o, i, v", code)
1395             code.putln(
1396                     'PyErr_SetString(PyExc_NotImplementedError, "__delete__");')
1397             code.putln(
1398                     "return -1;")
1399         code.putln(
1400                 "}")
1401         code.putln(
1402             "}")
1403
1404     def generate_property_accessors(self, cclass_scope, code):
1405         for entry in cclass_scope.property_entries:
1406             property_scope = entry.scope
1407             if property_scope.defines_any(["__get__"]):
1408                 self.generate_property_get_function(entry, code)
1409             if property_scope.defines_any(["__set__", "__del__"]):
1410                 self.generate_property_set_function(entry, code)
1411
1412     def generate_property_get_function(self, property_entry, code):
1413         property_scope = property_entry.scope
1414         property_entry.getter_cname = property_scope.parent_scope.mangle(
1415             Naming.prop_get_prefix, property_entry.name)
1416         get_entry = property_scope.lookup_here("__get__")
1417         code.putln("")
1418         code.putln(
1419             "static PyObject *%s(PyObject *o, void *x) {" %
1420                 property_entry.getter_cname)
1421         code.putln(
1422                 "return %s(o);" %
1423                     get_entry.func_cname)
1424         code.putln(
1425             "}")
1426
1427     def generate_property_set_function(self, property_entry, code):
1428         property_scope = property_entry.scope
1429         property_entry.setter_cname = property_scope.parent_scope.mangle(
1430             Naming.prop_set_prefix, property_entry.name)
1431         set_entry = property_scope.lookup_here("__set__")
1432         del_entry = property_scope.lookup_here("__del__")
1433         code.putln("")
1434         code.putln(
1435             "static int %s(PyObject *o, PyObject *v, void *x) {" %
1436                 property_entry.setter_cname)
1437         code.putln(
1438                 "if (v) {")
1439         if set_entry:
1440             code.putln(
1441                     "return %s(o, v);" %
1442                         set_entry.func_cname)
1443         else:
1444             code.putln(
1445                     'PyErr_SetString(PyExc_NotImplementedError, "__set__");')
1446             code.putln(
1447                     "return -1;")
1448         code.putln(
1449                 "}")
1450         code.putln(
1451                 "else {")
1452         if del_entry:
1453             code.putln(
1454                     "return %s(o);" %
1455                         del_entry.func_cname)
1456         else:
1457             code.putln(
1458                     'PyErr_SetString(PyExc_NotImplementedError, "__del__");')
1459             code.putln(
1460                     "return -1;")
1461         code.putln(
1462                 "}")
1463         code.putln(
1464             "}")
1465
1466     def generate_typeobj_definition(self, modname, entry, code):
1467         type = entry.type
1468         scope = type.scope
1469         for suite in TypeSlots.substructures:
1470             suite.generate_substructure(scope, code)
1471         code.putln("")
1472         if entry.visibility == 'public':
1473             header = "DL_EXPORT(PyTypeObject) %s = {"
1474         else:
1475             #header = "statichere PyTypeObject %s = {"
1476             header = "PyTypeObject %s = {"
1477         #code.putln(header % scope.parent_type.typeobj_cname)
1478         code.putln(header % type.typeobj_cname)
1479         code.putln(
1480             "PyVarObject_HEAD_INIT(0, 0)")
1481         code.putln(
1482             '__Pyx_NAMESTR("%s.%s"), /*tp_name*/' % (
1483                 self.full_module_name, scope.class_name))
1484         if type.typedef_flag:
1485             objstruct = type.objstruct_cname
1486         else:
1487             #objstruct = "struct %s" % scope.parent_type.objstruct_cname
1488             objstruct = "struct %s" % type.objstruct_cname
1489         code.putln(
1490             "sizeof(%s), /*tp_basicsize*/" %
1491                 objstruct)
1492         code.putln(
1493             "0, /*tp_itemsize*/")
1494         for slot in TypeSlots.slot_table:
1495             slot.generate(scope, code)
1496         code.putln(
1497             "};")
1498
1499     def generate_method_table(self, env, code):
1500         code.putln("")
1501         code.putln(
1502             "static struct PyMethodDef %s[] = {" %
1503                 env.method_table_cname)
1504         for entry in env.pyfunc_entries:
1505             code.put_pymethoddef(entry, ",")
1506         code.putln(
1507                 "{0, 0, 0, 0}")
1508         code.putln(
1509             "};")
1510
1511     def generate_member_table(self, env, code):
1512         #print "ModuleNode.generate_member_table: scope =", env ###
1513         if env.public_attr_entries:
1514             code.putln("")
1515             code.putln(
1516                 "static struct PyMemberDef %s[] = {" %
1517                     env.member_table_cname)
1518             type = env.parent_type
1519             if type.typedef_flag:
1520                 objstruct = type.objstruct_cname
1521             else:
1522                 objstruct = "struct %s" % type.objstruct_cname
1523             for entry in env.public_attr_entries:
1524                 type_code = entry.type.pymemberdef_typecode
1525                 if entry.visibility == 'readonly':
1526                     flags = "READONLY"
1527                 else:
1528                     flags = "0"
1529                 code.putln('{(char *)"%s", %s, %s, %s, 0},' % (
1530                     entry.name,
1531                     type_code,
1532                     "offsetof(%s, %s)" % (objstruct, entry.cname),
1533                     flags))
1534             code.putln(
1535                     "{0, 0, 0, 0, 0}")
1536             code.putln(
1537                 "};")
1538
1539     def generate_getset_table(self, env, code):
1540         if env.property_entries:
1541             code.putln("")
1542             code.putln(
1543                 "static struct PyGetSetDef %s[] = {" %
1544                     env.getset_table_cname)
1545             for entry in env.property_entries:
1546                 if entry.doc:
1547                     doc_code = "__Pyx_DOCSTR(%s)" % code.get_string_const(entry.doc)
1548                 else:
1549                     doc_code = "0"
1550                 code.putln(
1551                     '{(char *)"%s", %s, %s, %s, 0},' % (
1552                         entry.name,
1553                         entry.getter_cname or "0",
1554                         entry.setter_cname or "0",
1555                         doc_code))
1556             code.putln(
1557                     "{0, 0, 0, 0, 0}")
1558             code.putln(
1559                 "};")
1560
1561     def generate_filename_init_prototype(self, code):
1562         code.putln("");
1563         code.putln("static void %s(void); /*proto*/" % Naming.fileinit_cname)
1564
1565     def generate_import_star(self, env, code):
1566         env.use_utility_code(streq_utility_code)
1567         code.putln()
1568         code.putln("char* %s_type_names[] = {" % Naming.import_star)
1569         for name, entry in env.entries.items():
1570             if entry.is_type:
1571                 code.putln('"%s",' % name)
1572         code.putln("0")
1573         code.putln("};")
1574         code.putln()
1575         code.enter_cfunc_scope() # as we need labels
1576         code.putln("static int %s(PyObject *o, PyObject* py_name, char *name) {" % Naming.import_star_set)
1577         code.putln("char** type_name = %s_type_names;" % Naming.import_star)
1578         code.putln("while (*type_name) {")
1579         code.putln("if (__Pyx_StrEq(name, *type_name)) {")
1580         code.putln('PyErr_Format(PyExc_TypeError, "Cannot overwrite C type %s", name);')
1581         code.putln('goto bad;')
1582         code.putln("}")
1583         code.putln("type_name++;")
1584         code.putln("}")
1585         old_error_label = code.new_error_label()
1586         code.putln("if (0);") # so the first one can be "else if"
1587         for name, entry in env.entries.items():
1588             if entry.is_cglobal and entry.used:
1589                 code.putln('else if (__Pyx_StrEq(name, "%s")) {' % name)
1590                 if entry.type.is_pyobject:
1591                     if entry.type.is_extension_type or entry.type.is_builtin_type:
1592                         code.putln("if (!(%s)) %s;" % (
1593                             entry.type.type_test_code("o"),
1594                             code.error_goto(entry.pos)))
1595                     code.put_var_decref(entry)
1596                     code.putln("%s = %s;" % (
1597                         entry.cname,
1598                         PyrexTypes.typecast(entry.type, py_object_type, "o")))
1599                 elif entry.type.from_py_function:
1600                     rhs = "%s(o)" % entry.type.from_py_function
1601                     if entry.type.is_enum:
1602                         rhs = typecast(entry.type, c_long_type, rhs)
1603                     code.putln("%s = %s; if (%s) %s;" % (
1604                         entry.cname,
1605                         rhs,
1606                         entry.type.error_condition(entry.cname),
1607                         code.error_goto(entry.pos)))
1608                     code.putln("Py_DECREF(o);")
1609                 else:
1610                     code.putln('PyErr_Format(PyExc_TypeError, "Cannot convert Python object %s to %s");' % (name, entry.type))
1611                     code.putln(code.error_goto(entry.pos))
1612                 code.putln("}")
1613         code.putln("else {")
1614         code.putln("if (PyObject_SetAttr(%s, py_name, o) < 0) goto bad;" % Naming.module_cname)
1615         code.putln("}")
1616         code.putln("return 0;")
1617         code.put_label(code.error_label)
1618         # This helps locate the offending name.
1619         code.putln('__Pyx_AddTraceback("%s");' % self.full_module_name);
1620         code.error_label = old_error_label
1621         code.putln("bad:")
1622         code.putln("Py_DECREF(o);")
1623         code.putln("return -1;")
1624         code.putln("}")
1625         code.putln(import_star_utility_code)
1626         code.exit_cfunc_scope() # done with labels
1627
1628     def generate_module_init_func(self, imported_modules, env, code):
1629         code.enter_cfunc_scope()
1630         code.putln("")
1631         header2 = "PyMODINIT_FUNC init%s(void)" % env.module_name
1632         header3 = "PyMODINIT_FUNC PyInit_%s(void)" % env.module_name
1633         code.putln("#if PY_MAJOR_VERSION < 3")
1634         code.putln("%s; /*proto*/" % header2)
1635         code.putln(header2)
1636         code.putln("#else")
1637         code.putln("%s; /*proto*/" % header3)
1638         code.putln(header3)
1639         code.putln("#endif")
1640         code.putln("{")
1641         tempdecl_code = code.insertion_point()
1642
1643         code.putln("#if CYTHON_REFNANNY")
1644         code.putln("void* __pyx_refnanny = NULL;")
1645         code.putln("__Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"refnanny\");")
1646         code.putln("if (!__Pyx_RefNanny) {")
1647         code.putln("  PyErr_Clear();")
1648         code.putln("  __Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"Cython.Runtime.refnanny\");")
1649         code.putln("  if (!__Pyx_RefNanny)")
1650         code.putln("      Py_FatalError(\"failed to import 'refnanny' module\");")
1651         code.putln("}")
1652         code.putln("__pyx_refnanny = __Pyx_RefNanny->SetupContext(\"%s\", __LINE__, __FILE__);"% header3)
1653         code.putln("#endif")
1654
1655         self.generate_filename_init_call(code)
1656
1657         code.putln("%s = PyTuple_New(0); %s" % (Naming.empty_tuple, code.error_goto_if_null(Naming.empty_tuple, self.pos)));
1658         code.putln("#if PY_MAJOR_VERSION < 3");
1659         code.putln("%s = PyString_FromStringAndSize(\"\", 0); %s" % (Naming.empty_bytes, code.error_goto_if_null(Naming.empty_bytes, self.pos)));
1660         code.putln("#else");
1661         code.putln("%s = PyBytes_FromStringAndSize(\"\", 0); %s" % (Naming.empty_bytes, code.error_goto_if_null(Naming.empty_bytes, self.pos)));
1662         code.putln("#endif");
1663
1664         code.putln("/*--- Library function declarations ---*/")
1665         env.generate_library_function_declarations(code)
1666
1667         code.putln("/*--- Threads initialization code ---*/")
1668         code.putln("#if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS")
1669         code.putln("#ifdef WITH_THREAD /* Python build with threading support? */")
1670         code.putln("PyEval_InitThreads();")
1671         code.putln("#endif")
1672         code.putln("#endif")
1673
1674         code.putln("/*--- Module creation code ---*/")
1675         self.generate_module_creation_code(env, code)
1676
1677         code.putln("/*--- Initialize various global constants etc. ---*/")
1678         code.putln(code.error_goto_if_neg("__Pyx_InitGlobals()", self.pos))
1679
1680         __main__name = code.globalstate.get_py_string_const(
1681             EncodedString("__main__"), identifier=True)
1682         code.putln("if (%s%s) {" % (Naming.module_is_main, self.full_module_name.replace('.', '__')))
1683         code.putln(
1684             'if (__Pyx_SetAttrString(%s, "__name__", %s) < 0) %s;' % (
1685                 env.module_cname,
1686                 __main__name.cname,
1687                 code.error_goto(self.pos)))
1688         code.putln("}")
1689
1690         if Options.cache_builtins:
1691             code.putln("/*--- Builtin init code ---*/")
1692             code.putln(code.error_goto_if_neg("__Pyx_InitCachedBuiltins()",
1693                                               self.pos))
1694
1695         code.putln("/*--- Global init code ---*/")
1696         self.generate_global_init_code(env, code)
1697
1698         code.putln("/*--- Function export code ---*/")
1699         self.generate_c_function_export_code(env, code)
1700
1701         code.putln("/*--- Type init code ---*/")
1702         self.generate_type_init_code(env, code)
1703
1704         code.putln("/*--- Type import code ---*/")
1705         for module in imported_modules:
1706             self.generate_type_import_code_for_module(module, env, code)
1707
1708         code.putln("/*--- Function import code ---*/")
1709         for module in imported_modules:
1710             self.generate_c_function_import_code_for_module(module, env, code)
1711
1712         code.putln("/*--- Execution code ---*/")
1713         code.mark_pos(None)
1714
1715         self.body.generate_execution_code(code)
1716
1717         if Options.generate_cleanup_code:
1718             # this should be replaced by the module's tp_clear in Py3
1719             env.use_utility_code(import_module_utility_code)
1720             code.putln("if (__Pyx_RegisterCleanup()) %s;" % code.error_goto(self.pos))
1721
1722         code.put_goto(code.return_label)
1723         code.put_label(code.error_label)
1724         for cname, type in code.funcstate.all_managed_temps():
1725             code.put_xdecref(cname, type)
1726         code.putln('if (%s) {' % env.module_cname)
1727         code.putln('__Pyx_AddTraceback("init %s");' % env.qualified_name)
1728         env.use_utility_code(Nodes.traceback_utility_code)
1729         code.put_decref_clear(env.module_cname, py_object_type, nanny=False)
1730         code.putln('} else if (!PyErr_Occurred()) {')
1731         code.putln('PyErr_SetString(PyExc_ImportError, "init %s");' % env.qualified_name)
1732         code.putln('}')
1733         code.put_label(code.return_label)
1734
1735         code.put_finish_refcount_context()
1736
1737         code.putln("#if PY_MAJOR_VERSION < 3")
1738         code.putln("return;")
1739         code.putln("#else")
1740         code.putln("return %s;" % env.module_cname)
1741         code.putln("#endif")
1742         code.putln('}')
1743
1744         tempdecl_code.put_temp_declarations(code.funcstate)
1745
1746         code.exit_cfunc_scope()
1747
1748     def generate_module_cleanup_func(self, env, code):
1749         if not Options.generate_cleanup_code:
1750             return
1751         code.globalstate.use_utility_code(register_cleanup_utility_code)
1752         code.putln('static PyObject* %s(PyObject *self, PyObject *unused) {' % Naming.cleanup_cname)
1753         if Options.generate_cleanup_code >= 2:
1754             code.putln("/*--- Global cleanup code ---*/")
1755             rev_entries = list(env.var_entries)
1756             rev_entries.reverse()
1757             for entry in rev_entries:
1758                 if entry.visibility != 'extern':
1759                     if entry.type.is_pyobject and entry.used:
1760                         code.putln("Py_DECREF(%s); %s = 0;" % (
1761                             code.entry_as_pyobject(entry), entry.cname))
1762         code.putln("__Pyx_CleanupGlobals();")
1763         if Options.generate_cleanup_code >= 3:
1764             code.putln("/*--- Type import cleanup code ---*/")
1765             for type, _ in env.types_imported.items():
1766                 code.putln("Py_DECREF((PyObject *)%s);" % type.typeptr_cname)
1767         if Options.cache_builtins:
1768             code.putln("/*--- Builtin cleanup code ---*/")
1769             for entry in env.cached_builtins:
1770                 code.put_decref_clear(entry.cname,
1771                                       PyrexTypes.py_object_type,
1772                                       nanny=False)
1773         code.putln("/*--- Intern cleanup code ---*/")
1774         code.put_decref_clear(Naming.empty_tuple,
1775                               PyrexTypes.py_object_type,
1776                               nanny=False)
1777 #        for entry in env.pynum_entries:
1778 #            code.put_decref_clear(entry.cname,
1779 #                                  PyrexTypes.py_object_type,
1780 #                                  nanny=False)
1781 #        for entry in env.all_pystring_entries:
1782 #            if entry.is_interned:
1783 #                code.put_decref_clear(entry.pystring_cname,
1784 #                                      PyrexTypes.py_object_type,
1785 #                                      nanny=False)
1786 #        for entry in env.default_entries:
1787 #            if entry.type.is_pyobject and entry.used:
1788 #                code.putln("Py_DECREF(%s); %s = 0;" % (
1789 #                    code.entry_as_pyobject(entry), entry.cname))
1790         code.putln("Py_INCREF(Py_None); return Py_None;")
1791
1792     def generate_main_method(self, env, code):
1793         module_is_main = "%s%s" % (Naming.module_is_main, self.full_module_name.replace('.', '__'))
1794         code.globalstate.use_utility_code(main_method.specialize(module_name=env.module_name, module_is_main=module_is_main))
1795
1796     def generate_filename_init_call(self, code):
1797         code.putln("%s();" % Naming.fileinit_cname)
1798
1799     def generate_pymoduledef_struct(self, env, code):
1800         if env.doc:
1801             doc = "__Pyx_DOCSTR(%s)" % code.get_string_const(env.doc)
1802         else:
1803             doc = "0"
1804         code.putln("")
1805         code.putln("#if PY_MAJOR_VERSION >= 3")
1806         code.putln("static struct PyModuleDef %s = {" % Naming.pymoduledef_cname)
1807         code.putln("  PyModuleDef_HEAD_INIT,")
1808         code.putln('  __Pyx_NAMESTR("%s"),' % env.module_name)
1809         code.putln("  %s, /* m_doc */" % doc)
1810         code.putln("  -1, /* m_size */")
1811         code.putln("  %s /* m_methods */," % env.method_table_cname)
1812         code.putln("  NULL, /* m_reload */")
1813         code.putln("  NULL, /* m_traverse */")
1814         code.putln("  NULL, /* m_clear */")
1815         code.putln("  NULL /* m_free */")
1816         code.putln("};")
1817         code.putln("#endif")
1818
1819     def generate_module_creation_code(self, env, code):
1820         # Generate code to create the module object and
1821         # install the builtins.
1822         if env.doc:
1823             doc = "__Pyx_DOCSTR(%s)" % code.get_string_const(env.doc)
1824         else:
1825             doc = "0"
1826         code.putln("#if PY_MAJOR_VERSION < 3")
1827         code.putln(
1828             '%s = Py_InitModule4(__Pyx_NAMESTR("%s"), %s, %s, 0, PYTHON_API_VERSION);' % (
1829                 env.module_cname,
1830                 env.module_name,
1831                 env.method_table_cname,
1832                 doc))
1833         code.putln("#else")
1834         code.putln(
1835             "%s = PyModule_Create(&%s);" % (
1836                 env.module_cname,
1837                 Naming.pymoduledef_cname))
1838         code.putln("#endif")
1839         code.putln(
1840             "if (!%s) %s;" % (
1841                 env.module_cname,
1842                 code.error_goto(self.pos)));
1843         code.putln("#if PY_MAJOR_VERSION < 3")
1844         code.putln(
1845             "Py_INCREF(%s);" %
1846                 env.module_cname)
1847         code.putln("#endif")
1848         code.putln(
1849             '%s = PyImport_AddModule(__Pyx_NAMESTR(__Pyx_BUILTIN_MODULE_NAME));' %
1850                 Naming.builtins_cname)
1851         code.putln(
1852             "if (!%s) %s;" % (
1853                 Naming.builtins_cname,
1854                 code.error_goto(self.pos)));
1855         code.putln(
1856             'if (__Pyx_SetAttrString(%s, "__builtins__", %s) < 0) %s;' % (
1857                 env.module_cname,
1858                 Naming.builtins_cname,
1859                 code.error_goto(self.pos)))
1860         if Options.pre_import is not None:
1861             code.putln(
1862                 '%s = PyImport_AddModule(__Pyx_NAMESTR("%s"));' % (
1863                     Naming.preimport_cname,
1864                     Options.pre_import))
1865             code.putln(
1866                 "if (!%s) %s;" % (
1867                     Naming.preimport_cname,
1868                     code.error_goto(self.pos)));
1869
1870     def generate_global_init_code(self, env, code):
1871         # Generate code to initialise global PyObject *
1872         # variables to None.
1873         for entry in env.var_entries:
1874             if entry.visibility != 'extern':
1875                 if entry.type.is_pyobject and entry.used:
1876                     code.put_init_var_to_py_none(entry, nanny=False)
1877
1878     def generate_c_function_export_code(self, env, code):
1879         # Generate code to create PyCFunction wrappers for exported C functions.
1880         for entry in env.cfunc_entries:
1881             if entry.api or entry.defined_in_pxd:
1882                 env.use_utility_code(function_export_utility_code)
1883                 signature = entry.type.signature_string()
1884                 code.putln('if (__Pyx_ExportFunction("%s", (void (*)(void))%s, "%s") < 0) %s' % (
1885                     entry.name,
1886                     entry.cname,
1887                     signature,
1888                     code.error_goto(self.pos)))
1889
1890     def generate_type_import_code_for_module(self, module, env, code):
1891         # Generate type import code for all exported extension types in
1892         # an imported module.
1893         #if module.c_class_entries:
1894         for entry in module.c_class_entries:
1895             if entry.defined_in_pxd:
1896                 self.generate_type_import_code(env, entry.type, entry.pos, code)
1897
1898     def generate_c_function_import_code_for_module(self, module, env, code):
1899         # Generate import code for all exported C functions in a cimported module.
1900         entries = []
1901         for entry in module.cfunc_entries:
1902             if entry.defined_in_pxd:
1903                 entries.append(entry)
1904         if entries:
1905             env.use_utility_code(import_module_utility_code)
1906             env.use_utility_code(function_import_utility_code)
1907             temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
1908             code.putln(
1909                 '%s = __Pyx_ImportModule("%s"); if (!%s) %s' % (
1910                     temp,
1911                     module.qualified_name,
1912                     temp,
1913                     code.error_goto(self.pos)))
1914             for entry in entries:
1915                 code.putln(
1916                     'if (__Pyx_ImportFunction(%s, "%s", (void (**)(void))&%s, "%s") < 0) %s' % (
1917                         temp,
1918                         entry.name,
1919                         entry.cname,
1920                         entry.type.signature_string(),
1921                         code.error_goto(self.pos)))
1922             code.putln("Py_DECREF(%s); %s = 0;" % (temp, temp))
1923
1924     def generate_type_init_code(self, env, code):
1925         # Generate type import code for extern extension types
1926         # and type ready code for non-extern ones.
1927         for entry in env.c_class_entries:
1928             if entry.visibility == 'extern':
1929                 self.generate_type_import_code(env, entry.type, entry.pos, code)
1930             else:
1931                 self.generate_base_type_import_code(env, entry, code)
1932                 self.generate_exttype_vtable_init_code(entry, code)
1933                 self.generate_type_ready_code(env, entry, code)
1934                 self.generate_typeptr_assignment_code(entry, code)
1935
1936     def generate_base_type_import_code(self, env, entry, code):
1937         base_type = entry.type.base_type
1938         if base_type and base_type.module_name != env.qualified_name:
1939             self.generate_type_import_code(env, base_type, self.pos, code)
1940
1941     def use_type_import_utility_code(self, env):
1942         env.use_utility_code(type_import_utility_code)
1943         env.use_utility_code(import_module_utility_code)
1944
1945     def generate_type_import_code(self, env, type, pos, code):
1946         # If not already done, generate code to import the typeobject of an
1947         # extension type defined in another module, and extract its C method
1948         # table pointer if any.
1949         if type in env.types_imported:
1950             return
1951         if type.typedef_flag:
1952             objstruct = type.objstruct_cname
1953         else:
1954             objstruct = "struct %s" % type.objstruct_cname
1955         self.generate_type_import_call(type, code,
1956                                        code.error_goto_if_null(type.typeptr_cname, pos))
1957         self.use_type_import_utility_code(env)
1958         if type.vtabptr_cname:
1959             code.putln(
1960                 "if (__Pyx_GetVtable(%s->tp_dict, &%s) < 0) %s" % (
1961                     type.typeptr_cname,
1962                     type.vtabptr_cname,
1963                     code.error_goto(pos)))
1964             env.use_utility_code(Nodes.get_vtable_utility_code)
1965         env.types_imported[type] = 1
1966
1967     py3_type_name_map = {'str' : 'bytes', 'unicode' : 'str'}
1968
1969     def generate_type_import_call(self, type, code, error_code):
1970         if type.typedef_flag:
1971             objstruct = type.objstruct_cname
1972         else:
1973             objstruct = "struct %s" % type.objstruct_cname
1974         module_name = type.module_name
1975         if module_name not in ('__builtin__', 'builtins'):
1976             module_name = '"%s"' % module_name
1977         else:
1978             module_name = '__Pyx_BUILTIN_MODULE_NAME'
1979         if type.name in self.py3_type_name_map:
1980             code.putln("#if PY_MAJOR_VERSION >= 3")
1981             code.putln('%s = __Pyx_ImportType(%s, "%s", sizeof(%s)); %s' % (
1982                     type.typeptr_cname,
1983                     module_name,
1984                     self.py3_type_name_map[type.name],
1985                     objstruct,
1986                     error_code))
1987             code.putln("#else")
1988         code.putln('%s = __Pyx_ImportType(%s, "%s", sizeof(%s)); %s' % (
1989                 type.typeptr_cname,
1990                 module_name,
1991                 type.name,
1992                 objstruct,
1993                 error_code))
1994         if type.name in self.py3_type_name_map:
1995             code.putln("#endif")
1996
1997     def generate_type_ready_code(self, env, entry, code):
1998         # Generate a call to PyType_Ready for an extension
1999         # type defined in this module.
2000         type = entry.type
2001         typeobj_cname = type.typeobj_cname
2002         scope = type.scope
2003         if scope: # could be None if there was an error
2004             if entry.visibility != 'extern':
2005                 for slot in TypeSlots.slot_table:
2006                     slot.generate_dynamic_init_code(scope, code)
2007                 code.putln(
2008                     "if (PyType_Ready(&%s) < 0) %s" % (
2009                         typeobj_cname,
2010                         code.error_goto(entry.pos)))
2011                 if type.vtable_cname:
2012                     code.putln(
2013                         "if (__Pyx_SetVtable(%s.tp_dict, %s) < 0) %s" % (
2014                             typeobj_cname,
2015                             type.vtabptr_cname,
2016                             code.error_goto(entry.pos)))
2017                     env.use_utility_code(Nodes.set_vtable_utility_code)
2018                 code.putln(
2019                     'if (__Pyx_SetAttrString(%s, "%s", (PyObject *)&%s) < 0) %s' % (
2020                         Naming.module_cname,
2021                         scope.class_name,
2022                         typeobj_cname,
2023                         code.error_goto(entry.pos)))
2024                 weakref_entry = scope.lookup_here("__weakref__")
2025                 if weakref_entry:
2026                     if weakref_entry.type is py_object_type:
2027                         tp_weaklistoffset = "%s.tp_weaklistoffset" % typeobj_cname
2028                         if type.typedef_flag:
2029                             objstruct = type.objstruct_cname
2030                         else:
2031                             objstruct = "struct %s" % type.objstruct_cname
2032                         code.putln("if (%s == 0) %s = offsetof(%s, %s);" % (
2033                             tp_weaklistoffset,
2034                             tp_weaklistoffset,
2035                             objstruct,
2036                             weakref_entry.cname))
2037                     else:
2038                         error(weakref_entry.pos, "__weakref__ slot must be of type 'object'")
2039
2040     def generate_exttype_vtable_init_code(self, entry, code):
2041         # Generate code to initialise the C method table of an
2042         # extension type.
2043         type = entry.type
2044         if type.vtable_cname:
2045             code.putln(
2046                 "%s = &%s;" % (
2047                     type.vtabptr_cname,
2048                     type.vtable_cname))
2049             if type.base_type and type.base_type.vtabptr_cname:
2050                 code.putln(
2051                     "%s.%s = *%s;" % (
2052                         type.vtable_cname,
2053                         Naming.obj_base_cname,
2054                         type.base_type.vtabptr_cname))
2055
2056             c_method_entries = [
2057                 entry for entry in type.scope.cfunc_entries
2058                 if entry.func_cname ]
2059             if c_method_entries:
2060                 code.putln('#if PY_MAJOR_VERSION >= 3')
2061                 for meth_entry in c_method_entries:
2062                     cast = meth_entry.type.signature_cast_string()
2063                     code.putln(
2064                         "%s.%s = %s%s;" % (
2065                             type.vtable_cname,
2066                             meth_entry.cname,
2067                             cast,
2068                             meth_entry.func_cname))
2069                 code.putln('#else')
2070                 for meth_entry in c_method_entries:
2071                     code.putln(
2072                         "*(void(**)(void))&%s.%s = (void(*)(void))%s;" % (
2073                             type.vtable_cname,
2074                             meth_entry.cname,
2075                             meth_entry.func_cname))
2076                 code.putln('#endif')
2077
2078     def generate_typeptr_assignment_code(self, entry, code):
2079         # Generate code to initialise the typeptr of an extension
2080         # type defined in this module to point to its type object.
2081         type = entry.type
2082         if type.typeobj_cname:
2083             code.putln(
2084                 "%s = &%s;" % (
2085                     type.typeptr_cname, type.typeobj_cname))
2086
2087 #------------------------------------------------------------------------------------
2088 #
2089 #  Runtime support code
2090 #
2091 #------------------------------------------------------------------------------------
2092
2093 builtin_module_name_utility_code = UtilityCode(
2094 proto = """\
2095 #if PY_MAJOR_VERSION < 3
2096   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
2097 #else
2098   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
2099 #endif
2100 """)
2101
2102 #------------------------------------------------------------------------------------
2103
2104 streq_utility_code = UtilityCode(
2105 proto = """
2106 static INLINE int __Pyx_StrEq(const char *, const char *); /*proto*/
2107 """,
2108 impl = """
2109 static INLINE int __Pyx_StrEq(const char *s1, const char *s2) {
2110      while (*s1 != '\\0' && *s1 == *s2) { s1++; s2++; }
2111      return *s1 == *s2;
2112 }
2113 """)
2114
2115 #------------------------------------------------------------------------------------
2116
2117 import_module_utility_code = UtilityCode(
2118 proto = """
2119 static PyObject *__Pyx_ImportModule(const char *name); /*proto*/
2120 """,
2121 impl = """
2122 #ifndef __PYX_HAVE_RT_ImportModule
2123 #define __PYX_HAVE_RT_ImportModule
2124 static PyObject *__Pyx_ImportModule(const char *name) {
2125     PyObject *py_name = 0;
2126     PyObject *py_module = 0;
2127
2128     #if PY_MAJOR_VERSION < 3
2129     py_name = PyString_FromString(name);
2130     #else
2131     py_name = PyUnicode_FromString(name);
2132     #endif
2133     if (!py_name)
2134         goto bad;
2135     py_module = PyImport_Import(py_name);
2136     Py_DECREF(py_name);
2137     return py_module;
2138 bad:
2139     Py_XDECREF(py_name);
2140     return 0;
2141 }
2142 #endif
2143 """)
2144
2145 #------------------------------------------------------------------------------------
2146
2147 type_import_utility_code = UtilityCode(
2148 proto = """
2149 static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, long size);  /*proto*/
2150 """,
2151 impl = """
2152 #ifndef __PYX_HAVE_RT_ImportType
2153 #define __PYX_HAVE_RT_ImportType
2154 static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
2155     long size)
2156 {
2157     PyObject *py_module = 0;
2158     PyObject *result = 0;
2159     PyObject *py_name = 0;
2160
2161     py_module = __Pyx_ImportModule(module_name);
2162     if (!py_module)
2163         goto bad;
2164     #if PY_MAJOR_VERSION < 3
2165     py_name = PyString_FromString(class_name);
2166     #else
2167     py_name = PyUnicode_FromString(class_name);
2168     #endif
2169     if (!py_name)
2170         goto bad;
2171     result = PyObject_GetAttr(py_module, py_name);
2172     Py_DECREF(py_name);
2173     py_name = 0;
2174     Py_DECREF(py_module);
2175     py_module = 0;
2176     if (!result)
2177         goto bad;
2178     if (!PyType_Check(result)) {
2179         PyErr_Format(PyExc_TypeError,
2180             "%s.%s is not a type object",
2181             module_name, class_name);
2182         goto bad;
2183     }
2184     if (((PyTypeObject *)result)->tp_basicsize != size) {
2185         PyErr_Format(PyExc_ValueError,
2186             "%s.%s does not appear to be the correct type object",
2187             module_name, class_name);
2188         goto bad;
2189     }
2190     return (PyTypeObject *)result;
2191 bad:
2192     Py_XDECREF(py_module);
2193     Py_XDECREF(result);
2194     return 0;
2195 }
2196 #endif
2197 """)
2198
2199 #------------------------------------------------------------------------------------
2200
2201 function_export_utility_code = UtilityCode(
2202 proto = """
2203 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); /*proto*/
2204 """,
2205 impl = r"""
2206 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) {
2207     PyObject *d = 0;
2208     PyObject *cobj = 0;
2209     union {
2210         void (*fp)(void);
2211         void *p;
2212     } tmp;
2213
2214     d = PyObject_GetAttrString(%(MODULE)s, (char *)"%(API)s");
2215     if (!d) {
2216         PyErr_Clear();
2217         d = PyDict_New();
2218         if (!d)
2219             goto bad;
2220         Py_INCREF(d);
2221         if (PyModule_AddObject(%(MODULE)s, (char *)"%(API)s", d) < 0)
2222             goto bad;
2223     }
2224     tmp.fp = f;
2225 #if PY_VERSION_HEX < 0x03010000
2226     cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
2227 #else
2228     cobj = PyCapsule_New(tmp.p, sig, 0);
2229 #endif
2230     if (!cobj)
2231         goto bad;
2232     if (PyDict_SetItemString(d, name, cobj) < 0)
2233         goto bad;
2234     Py_DECREF(cobj);
2235     Py_DECREF(d);
2236     return 0;
2237 bad:
2238     Py_XDECREF(cobj);
2239     Py_XDECREF(d);
2240     return -1;
2241 }
2242 """ % {'MODULE': Naming.module_cname, 'API': Naming.api_name}
2243 )
2244
2245 function_import_utility_code = UtilityCode(
2246 proto = """
2247 static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /*proto*/
2248 """,
2249 impl = """
2250 #ifndef __PYX_HAVE_RT_ImportFunction
2251 #define __PYX_HAVE_RT_ImportFunction
2252 static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
2253     PyObject *d = 0;
2254     PyObject *cobj = 0;
2255     union {
2256         void (*fp)(void);
2257         void *p;
2258     } tmp;
2259 #if PY_VERSION_HEX < 0x03010000
2260     const char *desc, *s1, *s2;
2261 #endif
2262
2263     d = PyObject_GetAttrString(module, (char *)"%(API)s");
2264     if (!d)
2265         goto bad;
2266     cobj = PyDict_GetItemString(d, funcname);
2267     if (!cobj) {
2268         PyErr_Format(PyExc_ImportError,
2269             "%%s does not export expected C function %%s",
2270                 PyModule_GetName(module), funcname);
2271         goto bad;
2272     }
2273 #if PY_VERSION_HEX < 0x03010000
2274     desc = (const char *)PyCObject_GetDesc(cobj);
2275     if (!desc)
2276         goto bad;
2277     s1 = desc; s2 = sig;
2278     while (*s1 != '\\0' && *s1 == *s2) { s1++; s2++; }
2279     if (*s1 != *s2) {
2280         PyErr_Format(PyExc_TypeError,
2281             "C function %%s.%%s has wrong signature (expected %%s, got %%s)",
2282              PyModule_GetName(module), funcname, sig, desc);
2283         goto bad;
2284     }
2285     tmp.p = PyCObject_AsVoidPtr(cobj);
2286 #else
2287     if (!PyCapsule_IsValid(cobj, sig)) {
2288         PyErr_Format(PyExc_TypeError,
2289             "C function %%s.%%s has wrong signature (expected %%s, got %%s)",
2290              PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
2291         goto bad;
2292     }
2293     tmp.p = PyCapsule_GetPointer(cobj, sig);
2294 #endif
2295     *f = tmp.fp;
2296     if (!(*f))
2297         goto bad;
2298     Py_DECREF(d);
2299     return 0;
2300 bad:
2301     Py_XDECREF(d);
2302     return -1;
2303 }
2304 #endif
2305 """ % dict(API = Naming.api_name)
2306 )
2307
2308 #------------------------------------------------------------------------------------
2309
2310 register_cleanup_utility_code = UtilityCode(
2311 proto = """
2312 static int __Pyx_RegisterCleanup(void); /*proto*/
2313 static PyObject* __pyx_module_cleanup(PyObject *self, PyObject *unused); /*proto*/
2314 static PyMethodDef cleanup_def = {__Pyx_NAMESTR("__cleanup"), (PyCFunction)&__pyx_module_cleanup, METH_NOARGS, 0};
2315 """,
2316 impl = """
2317 static int __Pyx_RegisterCleanup(void) {
2318     /* Don't use Py_AtExit because that has a 32-call limit
2319      * and is called after python finalization.
2320      */
2321
2322     PyObject *cleanup_func = 0;
2323     PyObject *atexit = 0;
2324     PyObject *reg = 0;
2325     PyObject *args = 0;
2326     PyObject *res = 0;
2327     int ret = -1;
2328
2329     cleanup_func = PyCFunction_New(&cleanup_def, 0);
2330     args = PyTuple_New(1);
2331     if (!cleanup_func || !args)
2332         goto bad;
2333     PyTuple_SET_ITEM(args, 0, cleanup_func);
2334     cleanup_func = 0;
2335
2336     atexit = __Pyx_ImportModule("atexit");
2337     if (!atexit)
2338         goto bad;
2339     reg = __Pyx_GetAttrString(atexit, "register");
2340     if (!reg)
2341         goto bad;
2342     res = PyObject_CallObject(reg, args);
2343     if (!res)
2344         goto bad;
2345     ret = 0;
2346 bad:
2347     Py_XDECREF(cleanup_func);
2348     Py_XDECREF(atexit);
2349     Py_XDECREF(reg);
2350     Py_XDECREF(args);
2351     Py_XDECREF(res);
2352     return ret;
2353 }
2354 """)
2355
2356 import_star_utility_code = """
2357
2358 /* import_all_from is an unexposed function from ceval.c */
2359
2360 static int
2361 __Pyx_import_all_from(PyObject *locals, PyObject *v)
2362 {
2363     PyObject *all = __Pyx_GetAttrString(v, "__all__");
2364     PyObject *dict, *name, *value;
2365     int skip_leading_underscores = 0;
2366     int pos, err;
2367
2368     if (all == NULL) {
2369         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
2370             return -1; /* Unexpected error */
2371         PyErr_Clear();
2372         dict = __Pyx_GetAttrString(v, "__dict__");
2373         if (dict == NULL) {
2374             if (!PyErr_ExceptionMatches(PyExc_AttributeError))
2375                 return -1;
2376             PyErr_SetString(PyExc_ImportError,
2377             "from-import-* object has no __dict__ and no __all__");
2378             return -1;
2379         }
2380         all = PyMapping_Keys(dict);
2381         Py_DECREF(dict);
2382         if (all == NULL)
2383             return -1;
2384         skip_leading_underscores = 1;
2385     }
2386
2387     for (pos = 0, err = 0; ; pos++) {
2388         name = PySequence_GetItem(all, pos);
2389         if (name == NULL) {
2390             if (!PyErr_ExceptionMatches(PyExc_IndexError))
2391                 err = -1;
2392             else
2393                 PyErr_Clear();
2394             break;
2395         }
2396         if (skip_leading_underscores &&
2397 #if PY_MAJOR_VERSION < 3
2398             PyString_Check(name) &&
2399             PyString_AS_STRING(name)[0] == '_')
2400 #else
2401             PyUnicode_Check(name) &&
2402             PyUnicode_AS_UNICODE(name)[0] == '_')
2403 #endif
2404         {
2405             Py_DECREF(name);
2406             continue;
2407         }
2408         value = PyObject_GetAttr(v, name);
2409         if (value == NULL)
2410             err = -1;
2411         else if (PyDict_CheckExact(locals))
2412             err = PyDict_SetItem(locals, name, value);
2413         else
2414             err = PyObject_SetItem(locals, name, value);
2415         Py_DECREF(name);
2416         Py_XDECREF(value);
2417         if (err != 0)
2418             break;
2419     }
2420     Py_DECREF(all);
2421     return err;
2422 }
2423
2424
2425 static int %(IMPORT_STAR)s(PyObject* m) {
2426
2427     int i;
2428     int ret = -1;
2429     char* s;
2430     PyObject *locals = 0;
2431     PyObject *list = 0;
2432     PyObject *name;
2433     PyObject *item;
2434
2435     locals = PyDict_New();              if (!locals) goto bad;
2436     if (__Pyx_import_all_from(locals, m) < 0) goto bad;
2437     list = PyDict_Items(locals);        if (!list) goto bad;
2438
2439     for(i=0; i<PyList_GET_SIZE(list); i++) {
2440         name = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 0);
2441         item = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 1);
2442 #if PY_MAJOR_VERSION < 3
2443         s = PyString_AsString(name);
2444 #else
2445         s = PyUnicode_AsString(name);
2446 #endif
2447         if (!s) goto bad;
2448         if (%(IMPORT_STAR_SET)s(item, name, s) < 0) goto bad;
2449     }
2450     ret = 0;
2451
2452 bad:
2453     Py_XDECREF(locals);
2454     Py_XDECREF(list);
2455     return ret;
2456 }
2457 """ % {'IMPORT_STAR'     : Naming.import_star,
2458        'IMPORT_STAR_SET' : Naming.import_star_set }
2459
2460 refnanny_utility_code = UtilityCode(proto="""
2461 #ifndef CYTHON_REFNANNY
2462   #define CYTHON_REFNANNY 0
2463 #endif
2464
2465 #if CYTHON_REFNANNY
2466   typedef struct {
2467     void (*INCREF)(void*, PyObject*, int);
2468     void (*DECREF)(void*, PyObject*, int);
2469     void (*GOTREF)(void*, PyObject*, int);
2470     void (*GIVEREF)(void*, PyObject*, int);
2471     void* (*SetupContext)(const char*, int, const char*);
2472     void (*FinishContext)(void**);
2473   } __Pyx_RefNannyAPIStruct;
2474   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
2475   static __Pyx_RefNannyAPIStruct * __Pyx_RefNannyImportAPI(const char *modname) {
2476     PyObject *m = NULL, *p = NULL;
2477     void *r = NULL;
2478     m = PyImport_ImportModule((char *)modname);
2479     if (!m) goto end;
2480     p = PyObject_GetAttrString(m, (char *)\"RefNannyAPI\");
2481     if (!p) goto end;
2482     r = PyLong_AsVoidPtr(p);
2483   end:
2484     Py_XDECREF(p);
2485     Py_XDECREF(m);
2486     return (__Pyx_RefNannyAPIStruct *)r;
2487   }
2488   #define __Pyx_RefNannySetupContext(name) \
2489           void *__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
2490   #define __Pyx_RefNannyFinishContext() \
2491           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
2492   #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
2493   #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
2494   #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
2495   #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
2496   #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r);} } while(0)
2497 #else
2498   #define __Pyx_RefNannySetupContext(name)
2499   #define __Pyx_RefNannyFinishContext()
2500   #define __Pyx_INCREF(r) Py_INCREF(r)
2501   #define __Pyx_DECREF(r) Py_DECREF(r)
2502   #define __Pyx_GOTREF(r)
2503   #define __Pyx_GIVEREF(r)
2504   #define __Pyx_XDECREF(r) Py_XDECREF(r)
2505 #endif /* CYTHON_REFNANNY */
2506 #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);} } while(0)
2507 #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r);} } while(0)
2508 """)
2509
2510
2511 main_method = UtilityCode(
2512 impl = """
2513 #if PY_MAJOR_VERSION < 3 || (!defined(WIN32) && !defined(MS_WINDOWS))
2514 int main(int argc, char** argv) {
2515 #else
2516 int wmain(int argc, wchar_t **argv) {
2517 #endif
2518     int r = 0;
2519     PyObject* m = NULL;
2520     Py_SetProgramName(argv[0]);
2521     Py_Initialize();
2522     PySys_SetArgv(argc, argv);
2523     %(module_is_main)s = 1;
2524 #if PY_MAJOR_VERSION < 3
2525         init%(module_name)s();
2526 #else
2527         m = PyInit_%(module_name)s(name);
2528 #endif
2529     if (PyErr_Occurred() != NULL) {
2530         r = 1;
2531         PyErr_Print(); /* This exits with the right code if SystemExit. */
2532         if (Py_FlushLine()) PyErr_Clear();
2533     }
2534     Py_XDECREF(m);
2535     Py_Finalize();
2536     return r;
2537 }
2538 """)
2539
2540 packed_struct_utility_code = UtilityCode(proto="""
2541 #if defined(__GNUC__)
2542 #define __Pyx_PACKED __attribute__((__packed__))
2543 #else
2544 #define __Pyx_PACKED
2545 #endif
2546 """, impl="", proto_block='utility_code_proto_before_types')