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", 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         base_type = scope.parent_type.base_type
1201         set_entry = scope.lookup_here("__setslice__")
1202         del_entry = scope.lookup_here("__delslice__")
1203         code.putln("")
1204         code.putln(
1205             "static int %s(PyObject *o, Py_ssize_t i, Py_ssize_t j, PyObject *v) {" %
1206                 scope.mangle_internal("sq_ass_slice"))
1207         code.putln(
1208                 "if (v) {")
1209         if set_entry:
1210             code.putln(
1211                     "return %s(o, i, j, v);" %
1212                         set_entry.func_cname)
1213         else:
1214             self.generate_guarded_basetype_call(
1215                 base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)
1216             code.putln(
1217                     "PyErr_Format(PyExc_NotImplementedError,")
1218             code.putln(
1219                     '  "2-element slice assignment not supported by %s", Py_TYPE(o)->tp_name);')
1220             code.putln(
1221                     "return -1;")
1222         code.putln(
1223                 "}")
1224         code.putln(
1225                 "else {")
1226         if del_entry:
1227             code.putln(
1228                     "return %s(o, i, j);" %
1229                         del_entry.func_cname)
1230         else:
1231             self.generate_guarded_basetype_call(
1232                 base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)
1233             code.putln(
1234                     "PyErr_Format(PyExc_NotImplementedError,")
1235             code.putln(
1236                     '  "2-element slice deletion not supported by %s", Py_TYPE(o)->tp_name);')
1237             code.putln(
1238                     "return -1;")
1239         code.putln(
1240                 "}")
1241         code.putln(
1242             "}")
1243
1244     def generate_getattro_function(self, scope, code):
1245         # First try to get the attribute using __getattribute__, if defined, or
1246         # PyObject_GenericGetAttr.
1247         #
1248         # If that raises an AttributeError, call the __getattr__ if defined.
1249         #
1250         # In both cases, defined can be in this class, or any base class.
1251         def lookup_here_or_base(n,type=None):
1252             # Recursive lookup
1253             if type is None:
1254                 type = scope.parent_type
1255             r = type.scope.lookup_here(n)
1256             if r is None and \
1257                type.base_type is not None:
1258                 return lookup_here_or_base(n,type.base_type)
1259             else:
1260                 return r
1261         getattr_entry = lookup_here_or_base("__getattr__")
1262         getattribute_entry = lookup_here_or_base("__getattribute__")
1263         code.putln("")
1264         code.putln(
1265             "static PyObject *%s(PyObject *o, PyObject *n) {"
1266                 % scope.mangle_internal("tp_getattro"))
1267         if getattribute_entry is not None:
1268             code.putln(
1269                 "PyObject *v = %s(o, n);" %
1270                     getattribute_entry.func_cname)
1271         else:
1272             code.putln(
1273                 "PyObject *v = PyObject_GenericGetAttr(o, n);")
1274         if getattr_entry is not None:
1275             code.putln(
1276                 "if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) {")
1277             code.putln(
1278                 "PyErr_Clear();")
1279             code.putln(
1280                 "v = %s(o, n);" %
1281                     getattr_entry.func_cname)
1282             code.putln(
1283                 "}")
1284         code.putln(
1285             "return v;")
1286         code.putln(
1287             "}")
1288
1289     def generate_setattro_function(self, scope, code):
1290         # Setting and deleting an attribute are both done through
1291         # the setattro method, so we dispatch to user's __setattr__
1292         # or __delattr__ or fall back on PyObject_GenericSetAttr.
1293         base_type = scope.parent_type.base_type
1294         set_entry = scope.lookup_here("__setattr__")
1295         del_entry = scope.lookup_here("__delattr__")
1296         code.putln("")
1297         code.putln(
1298             "static int %s(PyObject *o, PyObject *n, PyObject *v) {" %
1299                 scope.mangle_internal("tp_setattro"))
1300         code.putln(
1301                 "if (v) {")
1302         if set_entry:
1303             code.putln(
1304                     "return %s(o, n, v);" %
1305                         set_entry.func_cname)
1306         else:
1307             self.generate_guarded_basetype_call(
1308                 base_type, None, "tp_setattro", "o, n, v", code)
1309             code.putln(
1310                     "return PyObject_GenericSetAttr(o, n, v);")
1311         code.putln(
1312                 "}")
1313         code.putln(
1314                 "else {")
1315         if del_entry:
1316             code.putln(
1317                     "return %s(o, n);" %
1318                         del_entry.func_cname)
1319         else:
1320             self.generate_guarded_basetype_call(
1321                 base_type, None, "tp_setattro", "o, n, v", code)
1322             code.putln(
1323                     "return PyObject_GenericSetAttr(o, n, 0);")
1324         code.putln(
1325                 "}")
1326         code.putln(
1327             "}")
1328
1329     def generate_descr_get_function(self, scope, code):
1330         # The __get__ function of a descriptor object can be
1331         # called with NULL for the second or third arguments
1332         # under some circumstances, so we replace them with
1333         # None in that case.
1334         user_get_entry = scope.lookup_here("__get__")
1335         code.putln("")
1336         code.putln(
1337             "static PyObject *%s(PyObject *o, PyObject *i, PyObject *c) {" %
1338                 scope.mangle_internal("tp_descr_get"))
1339         code.putln(
1340             "PyObject *r = 0;")
1341         code.putln(
1342             "if (!i) i = Py_None;")
1343         code.putln(
1344             "if (!c) c = Py_None;")
1345         #code.put_incref("i", py_object_type)
1346         #code.put_incref("c", py_object_type)
1347         code.putln(
1348             "r = %s(o, i, c);" %
1349                 user_get_entry.func_cname)
1350         #code.put_decref("i", py_object_type)
1351         #code.put_decref("c", py_object_type)
1352         code.putln(
1353             "return r;")
1354         code.putln(
1355             "}")
1356
1357     def generate_descr_set_function(self, scope, code):
1358         # Setting and deleting are both done through the __set__
1359         # method of a descriptor, so we dispatch to user's __set__
1360         # or __delete__ or raise an exception.
1361         base_type = scope.parent_type.base_type
1362         user_set_entry = scope.lookup_here("__set__")
1363         user_del_entry = scope.lookup_here("__delete__")
1364         code.putln("")
1365         code.putln(
1366             "static int %s(PyObject *o, PyObject *i, PyObject *v) {" %
1367                 scope.mangle_internal("tp_descr_set"))
1368         code.putln(
1369                 "if (v) {")
1370         if user_set_entry:
1371             code.putln(
1372                     "return %s(o, i, v);" %
1373                         user_set_entry.func_cname)
1374         else:
1375             self.generate_guarded_basetype_call(
1376                 base_type, None, "tp_descr_set", "o, i, v", code)
1377             code.putln(
1378                     'PyErr_SetString(PyExc_NotImplementedError, "__set__");')
1379             code.putln(
1380                     "return -1;")
1381         code.putln(
1382                 "}")
1383         code.putln(
1384                 "else {")
1385         if user_del_entry:
1386             code.putln(
1387                     "return %s(o, i);" %
1388                         user_del_entry.func_cname)
1389         else:
1390             self.generate_guarded_basetype_call(
1391                 base_type, None, "tp_descr_set", "o, i, v", code)
1392             code.putln(
1393                     'PyErr_SetString(PyExc_NotImplementedError, "__delete__");')
1394             code.putln(
1395                     "return -1;")
1396         code.putln(
1397                 "}")
1398         code.putln(
1399             "}")
1400
1401     def generate_property_accessors(self, cclass_scope, code):
1402         for entry in cclass_scope.property_entries:
1403             property_scope = entry.scope
1404             if property_scope.defines_any(["__get__"]):
1405                 self.generate_property_get_function(entry, code)
1406             if property_scope.defines_any(["__set__", "__del__"]):
1407                 self.generate_property_set_function(entry, code)
1408
1409     def generate_property_get_function(self, property_entry, code):
1410         property_scope = property_entry.scope
1411         property_entry.getter_cname = property_scope.parent_scope.mangle(
1412             Naming.prop_get_prefix, property_entry.name)
1413         get_entry = property_scope.lookup_here("__get__")
1414         code.putln("")
1415         code.putln(
1416             "static PyObject *%s(PyObject *o, void *x) {" %
1417                 property_entry.getter_cname)
1418         code.putln(
1419                 "return %s(o);" %
1420                     get_entry.func_cname)
1421         code.putln(
1422             "}")
1423
1424     def generate_property_set_function(self, property_entry, code):
1425         property_scope = property_entry.scope
1426         property_entry.setter_cname = property_scope.parent_scope.mangle(
1427             Naming.prop_set_prefix, property_entry.name)
1428         set_entry = property_scope.lookup_here("__set__")
1429         del_entry = property_scope.lookup_here("__del__")
1430         code.putln("")
1431         code.putln(
1432             "static int %s(PyObject *o, PyObject *v, void *x) {" %
1433                 property_entry.setter_cname)
1434         code.putln(
1435                 "if (v) {")
1436         if set_entry:
1437             code.putln(
1438                     "return %s(o, v);" %
1439                         set_entry.func_cname)
1440         else:
1441             code.putln(
1442                     'PyErr_SetString(PyExc_NotImplementedError, "__set__");')
1443             code.putln(
1444                     "return -1;")
1445         code.putln(
1446                 "}")
1447         code.putln(
1448                 "else {")
1449         if del_entry:
1450             code.putln(
1451                     "return %s(o);" %
1452                         del_entry.func_cname)
1453         else:
1454             code.putln(
1455                     'PyErr_SetString(PyExc_NotImplementedError, "__del__");')
1456             code.putln(
1457                     "return -1;")
1458         code.putln(
1459                 "}")
1460         code.putln(
1461             "}")
1462
1463     def generate_typeobj_definition(self, modname, entry, code):
1464         type = entry.type
1465         scope = type.scope
1466         for suite in TypeSlots.substructures:
1467             suite.generate_substructure(scope, code)
1468         code.putln("")
1469         if entry.visibility == 'public':
1470             header = "DL_EXPORT(PyTypeObject) %s = {"
1471         else:
1472             #header = "statichere PyTypeObject %s = {"
1473             header = "PyTypeObject %s = {"
1474         #code.putln(header % scope.parent_type.typeobj_cname)
1475         code.putln(header % type.typeobj_cname)
1476         code.putln(
1477             "PyVarObject_HEAD_INIT(0, 0)")
1478         code.putln(
1479             '__Pyx_NAMESTR("%s.%s"), /*tp_name*/' % (
1480                 self.full_module_name, scope.class_name))
1481         if type.typedef_flag:
1482             objstruct = type.objstruct_cname
1483         else:
1484             #objstruct = "struct %s" % scope.parent_type.objstruct_cname
1485             objstruct = "struct %s" % type.objstruct_cname
1486         code.putln(
1487             "sizeof(%s), /*tp_basicsize*/" %
1488                 objstruct)
1489         code.putln(
1490             "0, /*tp_itemsize*/")
1491         for slot in TypeSlots.slot_table:
1492             slot.generate(scope, code)
1493         code.putln(
1494             "};")
1495
1496     def generate_method_table(self, env, code):
1497         code.putln("")
1498         code.putln(
1499             "static struct PyMethodDef %s[] = {" %
1500                 env.method_table_cname)
1501         for entry in env.pyfunc_entries:
1502             code.put_pymethoddef(entry, ",")
1503         code.putln(
1504                 "{0, 0, 0, 0}")
1505         code.putln(
1506             "};")
1507
1508     def generate_member_table(self, env, code):
1509         #print "ModuleNode.generate_member_table: scope =", env ###
1510         if env.public_attr_entries:
1511             code.putln("")
1512             code.putln(
1513                 "static struct PyMemberDef %s[] = {" %
1514                     env.member_table_cname)
1515             type = env.parent_type
1516             if type.typedef_flag:
1517                 objstruct = type.objstruct_cname
1518             else:
1519                 objstruct = "struct %s" % type.objstruct_cname
1520             for entry in env.public_attr_entries:
1521                 type_code = entry.type.pymemberdef_typecode
1522                 if entry.visibility == 'readonly':
1523                     flags = "READONLY"
1524                 else:
1525                     flags = "0"
1526                 code.putln('{(char *)"%s", %s, %s, %s, 0},' % (
1527                     entry.name,
1528                     type_code,
1529                     "offsetof(%s, %s)" % (objstruct, entry.cname),
1530                     flags))
1531             code.putln(
1532                     "{0, 0, 0, 0, 0}")
1533             code.putln(
1534                 "};")
1535
1536     def generate_getset_table(self, env, code):
1537         if env.property_entries:
1538             code.putln("")
1539             code.putln(
1540                 "static struct PyGetSetDef %s[] = {" %
1541                     env.getset_table_cname)
1542             for entry in env.property_entries:
1543                 if entry.doc:
1544                     doc_code = "__Pyx_DOCSTR(%s)" % code.get_string_const(entry.doc)
1545                 else:
1546                     doc_code = "0"
1547                 code.putln(
1548                     '{(char *)"%s", %s, %s, %s, 0},' % (
1549                         entry.name,
1550                         entry.getter_cname or "0",
1551                         entry.setter_cname or "0",
1552                         doc_code))
1553             code.putln(
1554                     "{0, 0, 0, 0, 0}")
1555             code.putln(
1556                 "};")
1557
1558     def generate_filename_init_prototype(self, code):
1559         code.putln("");
1560         code.putln("static void %s(void); /*proto*/" % Naming.fileinit_cname)
1561
1562     def generate_import_star(self, env, code):
1563         env.use_utility_code(streq_utility_code)
1564         code.putln()
1565         code.putln("char* %s_type_names[] = {" % Naming.import_star)
1566         for name, entry in env.entries.items():
1567             if entry.is_type:
1568                 code.putln('"%s",' % name)
1569         code.putln("0")
1570         code.putln("};")
1571         code.putln()
1572         code.enter_cfunc_scope() # as we need labels
1573         code.putln("static int %s(PyObject *o, PyObject* py_name, char *name) {" % Naming.import_star_set)
1574         code.putln("char** type_name = %s_type_names;" % Naming.import_star)
1575         code.putln("while (*type_name) {")
1576         code.putln("if (__Pyx_StrEq(name, *type_name)) {")
1577         code.putln('PyErr_Format(PyExc_TypeError, "Cannot overwrite C type %s", name);')
1578         code.putln('goto bad;')
1579         code.putln("}")
1580         code.putln("type_name++;")
1581         code.putln("}")
1582         old_error_label = code.new_error_label()
1583         code.putln("if (0);") # so the first one can be "else if"
1584         for name, entry in env.entries.items():
1585             if entry.is_cglobal and entry.used:
1586                 code.putln('else if (__Pyx_StrEq(name, "%s")) {' % name)
1587                 if entry.type.is_pyobject:
1588                     if entry.type.is_extension_type or entry.type.is_builtin_type:
1589                         code.putln("if (!(%s)) %s;" % (
1590                             entry.type.type_test_code("o"),
1591                             code.error_goto(entry.pos)))
1592                     code.put_var_decref(entry)
1593                     code.putln("%s = %s;" % (
1594                         entry.cname,
1595                         PyrexTypes.typecast(entry.type, py_object_type, "o")))
1596                 elif entry.type.from_py_function:
1597                     rhs = "%s(o)" % entry.type.from_py_function
1598                     if entry.type.is_enum:
1599                         rhs = typecast(entry.type, c_long_type, rhs)
1600                     code.putln("%s = %s; if (%s) %s;" % (
1601                         entry.cname,
1602                         rhs,
1603                         entry.type.error_condition(entry.cname),
1604                         code.error_goto(entry.pos)))
1605                     code.putln("Py_DECREF(o);")
1606                 else:
1607                     code.putln('PyErr_Format(PyExc_TypeError, "Cannot convert Python object %s to %s");' % (name, entry.type))
1608                     code.putln(code.error_goto(entry.pos))
1609                 code.putln("}")
1610         code.putln("else {")
1611         code.putln("if (PyObject_SetAttr(%s, py_name, o) < 0) goto bad;" % Naming.module_cname)
1612         code.putln("}")
1613         code.putln("return 0;")
1614         code.put_label(code.error_label)
1615         # This helps locate the offending name.
1616         code.putln('__Pyx_AddTraceback("%s");' % self.full_module_name);
1617         code.error_label = old_error_label
1618         code.putln("bad:")
1619         code.putln("Py_DECREF(o);")
1620         code.putln("return -1;")
1621         code.putln("}")
1622         code.putln(import_star_utility_code)
1623         code.exit_cfunc_scope() # done with labels
1624
1625     def generate_module_init_func(self, imported_modules, env, code):
1626         code.enter_cfunc_scope()
1627         code.putln("")
1628         header2 = "PyMODINIT_FUNC init%s(void)" % env.module_name
1629         header3 = "PyMODINIT_FUNC PyInit_%s(void)" % env.module_name
1630         code.putln("#if PY_MAJOR_VERSION < 3")
1631         code.putln("%s; /*proto*/" % header2)
1632         code.putln(header2)
1633         code.putln("#else")
1634         code.putln("%s; /*proto*/" % header3)
1635         code.putln(header3)
1636         code.putln("#endif")
1637         code.putln("{")
1638         tempdecl_code = code.insertion_point()
1639
1640         code.putln("#if CYTHON_REFNANNY")
1641         code.putln("void* __pyx_refnanny = NULL;")
1642         code.putln("__Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"refnanny\");")
1643         code.putln("if (!__Pyx_RefNanny) {")
1644         code.putln("  PyErr_Clear();")
1645         code.putln("  __Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"Cython.Runtime.refnanny\");")
1646         code.putln("  if (!__Pyx_RefNanny)")
1647         code.putln("      Py_FatalError(\"failed to import 'refnanny' module\");")
1648         code.putln("}")
1649         code.putln("__pyx_refnanny = __Pyx_RefNanny->SetupContext(\"%s\", __LINE__, __FILE__);"% header3)
1650         code.putln("#endif")
1651
1652         self.generate_filename_init_call(code)
1653
1654         code.putln("%s = PyTuple_New(0); %s" % (Naming.empty_tuple, code.error_goto_if_null(Naming.empty_tuple, self.pos)));
1655         code.putln("#if PY_MAJOR_VERSION < 3");
1656         code.putln("%s = PyString_FromStringAndSize(\"\", 0); %s" % (Naming.empty_bytes, code.error_goto_if_null(Naming.empty_bytes, self.pos)));
1657         code.putln("#else");
1658         code.putln("%s = PyBytes_FromStringAndSize(\"\", 0); %s" % (Naming.empty_bytes, code.error_goto_if_null(Naming.empty_bytes, self.pos)));
1659         code.putln("#endif");
1660
1661         code.putln("/*--- Library function declarations ---*/")
1662         env.generate_library_function_declarations(code)
1663
1664         code.putln("/*--- Threads initialization code ---*/")
1665         code.putln("#if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS")
1666         code.putln("#ifdef WITH_THREAD /* Python build with threading support? */")
1667         code.putln("PyEval_InitThreads();")
1668         code.putln("#endif")
1669         code.putln("#endif")
1670
1671         code.putln("/*--- Module creation code ---*/")
1672         self.generate_module_creation_code(env, code)
1673
1674         code.putln("/*--- Initialize various global constants etc. ---*/")
1675         code.putln(code.error_goto_if_neg("__Pyx_InitGlobals()", self.pos))
1676
1677         __main__name = code.globalstate.get_py_string_const(
1678             EncodedString("__main__"), identifier=True)
1679         code.putln("if (%s%s) {" % (Naming.module_is_main, self.full_module_name.replace('.', '__')))
1680         code.putln(
1681             'if (__Pyx_SetAttrString(%s, "__name__", %s) < 0) %s;' % (
1682                 env.module_cname,
1683                 __main__name.cname,
1684                 code.error_goto(self.pos)))
1685         code.putln("}")
1686
1687         if Options.cache_builtins:
1688             code.putln("/*--- Builtin init code ---*/")
1689             code.putln(code.error_goto_if_neg("__Pyx_InitCachedBuiltins()",
1690                                               self.pos))
1691
1692         code.putln("/*--- Global init code ---*/")
1693         self.generate_global_init_code(env, code)
1694
1695         code.putln("/*--- Function export code ---*/")
1696         self.generate_c_function_export_code(env, code)
1697
1698         code.putln("/*--- Type init code ---*/")
1699         self.generate_type_init_code(env, code)
1700
1701         code.putln("/*--- Type import code ---*/")
1702         for module in imported_modules:
1703             self.generate_type_import_code_for_module(module, env, code)
1704
1705         code.putln("/*--- Function import code ---*/")
1706         for module in imported_modules:
1707             self.generate_c_function_import_code_for_module(module, env, code)
1708
1709         code.putln("/*--- Execution code ---*/")
1710         code.mark_pos(None)
1711
1712         self.body.generate_execution_code(code)
1713
1714         if Options.generate_cleanup_code:
1715             # this should be replaced by the module's tp_clear in Py3
1716             env.use_utility_code(import_module_utility_code)
1717             code.putln("if (__Pyx_RegisterCleanup()) %s;" % code.error_goto(self.pos))
1718
1719         code.put_goto(code.return_label)
1720         code.put_label(code.error_label)
1721         for cname, type in code.funcstate.all_managed_temps():
1722             code.put_xdecref(cname, type)
1723         code.putln('if (%s) {' % env.module_cname)
1724         code.putln('__Pyx_AddTraceback("init %s");' % env.qualified_name)
1725         env.use_utility_code(Nodes.traceback_utility_code)
1726         code.put_decref_clear(env.module_cname, py_object_type, nanny=False)
1727         code.putln('} else if (!PyErr_Occurred()) {')
1728         code.putln('PyErr_SetString(PyExc_ImportError, "init %s");' % env.qualified_name)
1729         code.putln('}')
1730         code.put_label(code.return_label)
1731
1732         code.put_finish_refcount_context()
1733
1734         code.putln("#if PY_MAJOR_VERSION < 3")
1735         code.putln("return;")
1736         code.putln("#else")
1737         code.putln("return %s;" % env.module_cname)
1738         code.putln("#endif")
1739         code.putln('}')
1740
1741         tempdecl_code.put_temp_declarations(code.funcstate)
1742
1743         code.exit_cfunc_scope()
1744
1745     def generate_module_cleanup_func(self, env, code):
1746         if not Options.generate_cleanup_code:
1747             return
1748         code.globalstate.use_utility_code(register_cleanup_utility_code)
1749         code.putln('static PyObject* %s(PyObject *self, PyObject *unused) {' % Naming.cleanup_cname)
1750         if Options.generate_cleanup_code >= 2:
1751             code.putln("/*--- Global cleanup code ---*/")
1752             rev_entries = list(env.var_entries)
1753             rev_entries.reverse()
1754             for entry in rev_entries:
1755                 if entry.visibility != 'extern':
1756                     if entry.type.is_pyobject and entry.used:
1757                         code.putln("Py_DECREF(%s); %s = 0;" % (
1758                             code.entry_as_pyobject(entry), entry.cname))
1759         code.putln("__Pyx_CleanupGlobals();")
1760         if Options.generate_cleanup_code >= 3:
1761             code.putln("/*--- Type import cleanup code ---*/")
1762             for type, _ in env.types_imported.items():
1763                 code.putln("Py_DECREF((PyObject *)%s);" % type.typeptr_cname)
1764         if Options.cache_builtins:
1765             code.putln("/*--- Builtin cleanup code ---*/")
1766             for entry in env.cached_builtins:
1767                 code.put_decref_clear(entry.cname,
1768                                       PyrexTypes.py_object_type,
1769                                       nanny=False)
1770         code.putln("/*--- Intern cleanup code ---*/")
1771         code.put_decref_clear(Naming.empty_tuple,
1772                               PyrexTypes.py_object_type,
1773                               nanny=False)
1774 #        for entry in env.pynum_entries:
1775 #            code.put_decref_clear(entry.cname,
1776 #                                  PyrexTypes.py_object_type,
1777 #                                  nanny=False)
1778 #        for entry in env.all_pystring_entries:
1779 #            if entry.is_interned:
1780 #                code.put_decref_clear(entry.pystring_cname,
1781 #                                      PyrexTypes.py_object_type,
1782 #                                      nanny=False)
1783 #        for entry in env.default_entries:
1784 #            if entry.type.is_pyobject and entry.used:
1785 #                code.putln("Py_DECREF(%s); %s = 0;" % (
1786 #                    code.entry_as_pyobject(entry), entry.cname))
1787         code.putln("Py_INCREF(Py_None); return Py_None;")
1788
1789     def generate_main_method(self, env, code):
1790         module_is_main = "%s%s" % (Naming.module_is_main, self.full_module_name.replace('.', '__'))
1791         code.globalstate.use_utility_code(main_method.specialize(module_name=env.module_name, module_is_main=module_is_main))
1792
1793     def generate_filename_init_call(self, code):
1794         code.putln("%s();" % Naming.fileinit_cname)
1795
1796     def generate_pymoduledef_struct(self, env, code):
1797         if env.doc:
1798             doc = "__Pyx_DOCSTR(%s)" % code.get_string_const(env.doc)
1799         else:
1800             doc = "0"
1801         code.putln("")
1802         code.putln("#if PY_MAJOR_VERSION >= 3")
1803         code.putln("static struct PyModuleDef %s = {" % Naming.pymoduledef_cname)
1804         code.putln("  PyModuleDef_HEAD_INIT,")
1805         code.putln('  __Pyx_NAMESTR("%s"),' % env.module_name)
1806         code.putln("  %s, /* m_doc */" % doc)
1807         code.putln("  -1, /* m_size */")
1808         code.putln("  %s /* m_methods */," % env.method_table_cname)
1809         code.putln("  NULL, /* m_reload */")
1810         code.putln("  NULL, /* m_traverse */")
1811         code.putln("  NULL, /* m_clear */")
1812         code.putln("  NULL /* m_free */")
1813         code.putln("};")
1814         code.putln("#endif")
1815
1816     def generate_module_creation_code(self, env, code):
1817         # Generate code to create the module object and
1818         # install the builtins.
1819         if env.doc:
1820             doc = "__Pyx_DOCSTR(%s)" % code.get_string_const(env.doc)
1821         else:
1822             doc = "0"
1823         code.putln("#if PY_MAJOR_VERSION < 3")
1824         code.putln(
1825             '%s = Py_InitModule4(__Pyx_NAMESTR("%s"), %s, %s, 0, PYTHON_API_VERSION);' % (
1826                 env.module_cname,
1827                 env.module_name,
1828                 env.method_table_cname,
1829                 doc))
1830         code.putln("#else")
1831         code.putln(
1832             "%s = PyModule_Create(&%s);" % (
1833                 env.module_cname,
1834                 Naming.pymoduledef_cname))
1835         code.putln("#endif")
1836         code.putln(
1837             "if (!%s) %s;" % (
1838                 env.module_cname,
1839                 code.error_goto(self.pos)));
1840         code.putln("#if PY_MAJOR_VERSION < 3")
1841         code.putln(
1842             "Py_INCREF(%s);" %
1843                 env.module_cname)
1844         code.putln("#endif")
1845         code.putln(
1846             '%s = PyImport_AddModule(__Pyx_NAMESTR(__Pyx_BUILTIN_MODULE_NAME));' %
1847                 Naming.builtins_cname)
1848         code.putln(
1849             "if (!%s) %s;" % (
1850                 Naming.builtins_cname,
1851                 code.error_goto(self.pos)));
1852         code.putln(
1853             'if (__Pyx_SetAttrString(%s, "__builtins__", %s) < 0) %s;' % (
1854                 env.module_cname,
1855                 Naming.builtins_cname,
1856                 code.error_goto(self.pos)))
1857         if Options.pre_import is not None:
1858             code.putln(
1859                 '%s = PyImport_AddModule(__Pyx_NAMESTR("%s"));' % (
1860                     Naming.preimport_cname,
1861                     Options.pre_import))
1862             code.putln(
1863                 "if (!%s) %s;" % (
1864                     Naming.preimport_cname,
1865                     code.error_goto(self.pos)));
1866
1867     def generate_global_init_code(self, env, code):
1868         # Generate code to initialise global PyObject *
1869         # variables to None.
1870         for entry in env.var_entries:
1871             if entry.visibility != 'extern':
1872                 if entry.type.is_pyobject and entry.used:
1873                     code.put_init_var_to_py_none(entry, nanny=False)
1874
1875     def generate_c_function_export_code(self, env, code):
1876         # Generate code to create PyCFunction wrappers for exported C functions.
1877         for entry in env.cfunc_entries:
1878             if entry.api or entry.defined_in_pxd:
1879                 env.use_utility_code(function_export_utility_code)
1880                 signature = entry.type.signature_string()
1881                 code.putln('if (__Pyx_ExportFunction("%s", (void (*)(void))%s, "%s") < 0) %s' % (
1882                     entry.name,
1883                     entry.cname,
1884                     signature,
1885                     code.error_goto(self.pos)))
1886
1887     def generate_type_import_code_for_module(self, module, env, code):
1888         # Generate type import code for all exported extension types in
1889         # an imported module.
1890         #if module.c_class_entries:
1891         for entry in module.c_class_entries:
1892             if entry.defined_in_pxd:
1893                 self.generate_type_import_code(env, entry.type, entry.pos, code)
1894
1895     def generate_c_function_import_code_for_module(self, module, env, code):
1896         # Generate import code for all exported C functions in a cimported module.
1897         entries = []
1898         for entry in module.cfunc_entries:
1899             if entry.defined_in_pxd:
1900                 entries.append(entry)
1901         if entries:
1902             env.use_utility_code(import_module_utility_code)
1903             env.use_utility_code(function_import_utility_code)
1904             temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
1905             code.putln(
1906                 '%s = __Pyx_ImportModule("%s"); if (!%s) %s' % (
1907                     temp,
1908                     module.qualified_name,
1909                     temp,
1910                     code.error_goto(self.pos)))
1911             for entry in entries:
1912                 code.putln(
1913                     'if (__Pyx_ImportFunction(%s, "%s", (void (**)(void))&%s, "%s") < 0) %s' % (
1914                         temp,
1915                         entry.name,
1916                         entry.cname,
1917                         entry.type.signature_string(),
1918                         code.error_goto(self.pos)))
1919             code.putln("Py_DECREF(%s); %s = 0;" % (temp, temp))
1920
1921     def generate_type_init_code(self, env, code):
1922         # Generate type import code for extern extension types
1923         # and type ready code for non-extern ones.
1924         for entry in env.c_class_entries:
1925             if entry.visibility == 'extern':
1926                 self.generate_type_import_code(env, entry.type, entry.pos, code)
1927             else:
1928                 self.generate_base_type_import_code(env, entry, code)
1929                 self.generate_exttype_vtable_init_code(entry, code)
1930                 self.generate_type_ready_code(env, entry, code)
1931                 self.generate_typeptr_assignment_code(entry, code)
1932
1933     def generate_base_type_import_code(self, env, entry, code):
1934         base_type = entry.type.base_type
1935         if base_type and base_type.module_name != env.qualified_name:
1936             self.generate_type_import_code(env, base_type, self.pos, code)
1937
1938     def use_type_import_utility_code(self, env):
1939         env.use_utility_code(type_import_utility_code)
1940         env.use_utility_code(import_module_utility_code)
1941
1942     def generate_type_import_code(self, env, type, pos, code):
1943         # If not already done, generate code to import the typeobject of an
1944         # extension type defined in another module, and extract its C method
1945         # table pointer if any.
1946         if type in env.types_imported:
1947             return
1948         if type.typedef_flag:
1949             objstruct = type.objstruct_cname
1950         else:
1951             objstruct = "struct %s" % type.objstruct_cname
1952         self.generate_type_import_call(type, code,
1953                                        code.error_goto_if_null(type.typeptr_cname, pos))
1954         self.use_type_import_utility_code(env)
1955         if type.vtabptr_cname:
1956             code.putln(
1957                 "if (__Pyx_GetVtable(%s->tp_dict, &%s) < 0) %s" % (
1958                     type.typeptr_cname,
1959                     type.vtabptr_cname,
1960                     code.error_goto(pos)))
1961             env.use_utility_code(Nodes.get_vtable_utility_code)
1962         env.types_imported[type] = 1
1963
1964     py3_type_name_map = {'str' : 'bytes', 'unicode' : 'str'}
1965
1966     def generate_type_import_call(self, type, code, error_code):
1967         if type.typedef_flag:
1968             objstruct = type.objstruct_cname
1969         else:
1970             objstruct = "struct %s" % type.objstruct_cname
1971         module_name = type.module_name
1972         if module_name not in ('__builtin__', 'builtins'):
1973             module_name = '"%s"' % module_name
1974         else:
1975             module_name = '__Pyx_BUILTIN_MODULE_NAME'
1976         if type.name in self.py3_type_name_map:
1977             code.putln("#if PY_MAJOR_VERSION >= 3")
1978             code.putln('%s = __Pyx_ImportType(%s, "%s", sizeof(%s)); %s' % (
1979                     type.typeptr_cname,
1980                     module_name,
1981                     self.py3_type_name_map[type.name],
1982                     objstruct,
1983                     error_code))
1984             code.putln("#else")
1985         code.putln('%s = __Pyx_ImportType(%s, "%s", sizeof(%s)); %s' % (
1986                 type.typeptr_cname,
1987                 module_name,
1988                 type.name,
1989                 objstruct,
1990                 error_code))
1991         if type.name in self.py3_type_name_map:
1992             code.putln("#endif")
1993
1994     def generate_type_ready_code(self, env, entry, code):
1995         # Generate a call to PyType_Ready for an extension
1996         # type defined in this module.
1997         type = entry.type
1998         typeobj_cname = type.typeobj_cname
1999         scope = type.scope
2000         if scope: # could be None if there was an error
2001             if entry.visibility != 'extern':
2002                 for slot in TypeSlots.slot_table:
2003                     slot.generate_dynamic_init_code(scope, code)
2004                 code.putln(
2005                     "if (PyType_Ready(&%s) < 0) %s" % (
2006                         typeobj_cname,
2007                         code.error_goto(entry.pos)))
2008                 if type.vtable_cname:
2009                     code.putln(
2010                         "if (__Pyx_SetVtable(%s.tp_dict, %s) < 0) %s" % (
2011                             typeobj_cname,
2012                             type.vtabptr_cname,
2013                             code.error_goto(entry.pos)))
2014                     env.use_utility_code(Nodes.set_vtable_utility_code)
2015                 code.putln(
2016                     'if (__Pyx_SetAttrString(%s, "%s", (PyObject *)&%s) < 0) %s' % (
2017                         Naming.module_cname,
2018                         scope.class_name,
2019                         typeobj_cname,
2020                         code.error_goto(entry.pos)))
2021                 weakref_entry = scope.lookup_here("__weakref__")
2022                 if weakref_entry:
2023                     if weakref_entry.type is py_object_type:
2024                         tp_weaklistoffset = "%s.tp_weaklistoffset" % typeobj_cname
2025                         if type.typedef_flag:
2026                             objstruct = type.objstruct_cname
2027                         else:
2028                             objstruct = "struct %s" % type.objstruct_cname
2029                         code.putln("if (%s == 0) %s = offsetof(%s, %s);" % (
2030                             tp_weaklistoffset,
2031                             tp_weaklistoffset,
2032                             objstruct,
2033                             weakref_entry.cname))
2034                     else:
2035                         error(weakref_entry.pos, "__weakref__ slot must be of type 'object'")
2036
2037     def generate_exttype_vtable_init_code(self, entry, code):
2038         # Generate code to initialise the C method table of an
2039         # extension type.
2040         type = entry.type
2041         if type.vtable_cname:
2042             code.putln(
2043                 "%s = &%s;" % (
2044                     type.vtabptr_cname,
2045                     type.vtable_cname))
2046             if type.base_type and type.base_type.vtabptr_cname:
2047                 code.putln(
2048                     "%s.%s = *%s;" % (
2049                         type.vtable_cname,
2050                         Naming.obj_base_cname,
2051                         type.base_type.vtabptr_cname))
2052
2053             c_method_entries = [
2054                 entry for entry in type.scope.cfunc_entries
2055                 if entry.func_cname ]
2056             if c_method_entries:
2057                 code.putln('#if PY_MAJOR_VERSION >= 3')
2058                 for meth_entry in c_method_entries:
2059                     cast = meth_entry.type.signature_cast_string()
2060                     code.putln(
2061                         "%s.%s = %s%s;" % (
2062                             type.vtable_cname,
2063                             meth_entry.cname,
2064                             cast,
2065                             meth_entry.func_cname))
2066                 code.putln('#else')
2067                 for meth_entry in c_method_entries:
2068                     code.putln(
2069                         "*(void(**)(void))&%s.%s = (void(*)(void))%s;" % (
2070                             type.vtable_cname,
2071                             meth_entry.cname,
2072                             meth_entry.func_cname))
2073                 code.putln('#endif')
2074
2075     def generate_typeptr_assignment_code(self, entry, code):
2076         # Generate code to initialise the typeptr of an extension
2077         # type defined in this module to point to its type object.
2078         type = entry.type
2079         if type.typeobj_cname:
2080             code.putln(
2081                 "%s = &%s;" % (
2082                     type.typeptr_cname, type.typeobj_cname))
2083
2084 #------------------------------------------------------------------------------------
2085 #
2086 #  Runtime support code
2087 #
2088 #------------------------------------------------------------------------------------
2089
2090 builtin_module_name_utility_code = UtilityCode(
2091 proto = """\
2092 #if PY_MAJOR_VERSION < 3
2093   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
2094 #else
2095   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
2096 #endif
2097 """)
2098
2099 #------------------------------------------------------------------------------------
2100
2101 streq_utility_code = UtilityCode(
2102 proto = """
2103 static INLINE int __Pyx_StrEq(const char *, const char *); /*proto*/
2104 """,
2105 impl = """
2106 static INLINE int __Pyx_StrEq(const char *s1, const char *s2) {
2107      while (*s1 != '\\0' && *s1 == *s2) { s1++; s2++; }
2108      return *s1 == *s2;
2109 }
2110 """)
2111
2112 #------------------------------------------------------------------------------------
2113
2114 import_module_utility_code = UtilityCode(
2115 proto = """
2116 static PyObject *__Pyx_ImportModule(const char *name); /*proto*/
2117 """,
2118 impl = """
2119 #ifndef __PYX_HAVE_RT_ImportModule
2120 #define __PYX_HAVE_RT_ImportModule
2121 static PyObject *__Pyx_ImportModule(const char *name) {
2122     PyObject *py_name = 0;
2123     PyObject *py_module = 0;
2124
2125     #if PY_MAJOR_VERSION < 3
2126     py_name = PyString_FromString(name);
2127     #else
2128     py_name = PyUnicode_FromString(name);
2129     #endif
2130     if (!py_name)
2131         goto bad;
2132     py_module = PyImport_Import(py_name);
2133     Py_DECREF(py_name);
2134     return py_module;
2135 bad:
2136     Py_XDECREF(py_name);
2137     return 0;
2138 }
2139 #endif
2140 """)
2141
2142 #------------------------------------------------------------------------------------
2143
2144 type_import_utility_code = UtilityCode(
2145 proto = """
2146 static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, long size);  /*proto*/
2147 """,
2148 impl = """
2149 #ifndef __PYX_HAVE_RT_ImportType
2150 #define __PYX_HAVE_RT_ImportType
2151 static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
2152     long size)
2153 {
2154     PyObject *py_module = 0;
2155     PyObject *result = 0;
2156     PyObject *py_name = 0;
2157
2158     py_module = __Pyx_ImportModule(module_name);
2159     if (!py_module)
2160         goto bad;
2161     #if PY_MAJOR_VERSION < 3
2162     py_name = PyString_FromString(class_name);
2163     #else
2164     py_name = PyUnicode_FromString(class_name);
2165     #endif
2166     if (!py_name)
2167         goto bad;
2168     result = PyObject_GetAttr(py_module, py_name);
2169     Py_DECREF(py_name);
2170     py_name = 0;
2171     Py_DECREF(py_module);
2172     py_module = 0;
2173     if (!result)
2174         goto bad;
2175     if (!PyType_Check(result)) {
2176         PyErr_Format(PyExc_TypeError,
2177             "%s.%s is not a type object",
2178             module_name, class_name);
2179         goto bad;
2180     }
2181     if (((PyTypeObject *)result)->tp_basicsize != size) {
2182         PyErr_Format(PyExc_ValueError,
2183             "%s.%s does not appear to be the correct type object",
2184             module_name, class_name);
2185         goto bad;
2186     }
2187     return (PyTypeObject *)result;
2188 bad:
2189     Py_XDECREF(py_module);
2190     Py_XDECREF(result);
2191     return 0;
2192 }
2193 #endif
2194 """)
2195
2196 #------------------------------------------------------------------------------------
2197
2198 function_export_utility_code = UtilityCode(
2199 proto = """
2200 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); /*proto*/
2201 """,
2202 impl = r"""
2203 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) {
2204     PyObject *d = 0;
2205     PyObject *cobj = 0;
2206     union {
2207         void (*fp)(void);
2208         void *p;
2209     } tmp;
2210
2211     d = PyObject_GetAttrString(%(MODULE)s, (char *)"%(API)s");
2212     if (!d) {
2213         PyErr_Clear();
2214         d = PyDict_New();
2215         if (!d)
2216             goto bad;
2217         Py_INCREF(d);
2218         if (PyModule_AddObject(%(MODULE)s, (char *)"%(API)s", d) < 0)
2219             goto bad;
2220     }
2221     tmp.fp = f;
2222 #if PY_VERSION_HEX < 0x03010000
2223     cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
2224 #else
2225     cobj = PyCapsule_New(tmp.p, sig, 0);
2226 #endif
2227     if (!cobj)
2228         goto bad;
2229     if (PyDict_SetItemString(d, name, cobj) < 0)
2230         goto bad;
2231     Py_DECREF(cobj);
2232     Py_DECREF(d);
2233     return 0;
2234 bad:
2235     Py_XDECREF(cobj);
2236     Py_XDECREF(d);
2237     return -1;
2238 }
2239 """ % {'MODULE': Naming.module_cname, 'API': Naming.api_name}
2240 )
2241
2242 function_import_utility_code = UtilityCode(
2243 proto = """
2244 static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /*proto*/
2245 """,
2246 impl = """
2247 #ifndef __PYX_HAVE_RT_ImportFunction
2248 #define __PYX_HAVE_RT_ImportFunction
2249 static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
2250     PyObject *d = 0;
2251     PyObject *cobj = 0;
2252     union {
2253         void (*fp)(void);
2254         void *p;
2255     } tmp;
2256 #if PY_VERSION_HEX < 0x03010000
2257     const char *desc, *s1, *s2;
2258 #endif
2259
2260     d = PyObject_GetAttrString(module, (char *)"%(API)s");
2261     if (!d)
2262         goto bad;
2263     cobj = PyDict_GetItemString(d, funcname);
2264     if (!cobj) {
2265         PyErr_Format(PyExc_ImportError,
2266             "%%s does not export expected C function %%s",
2267                 PyModule_GetName(module), funcname);
2268         goto bad;
2269     }
2270 #if PY_VERSION_HEX < 0x03010000
2271     desc = (const char *)PyCObject_GetDesc(cobj);
2272     if (!desc)
2273         goto bad;
2274     s1 = desc; s2 = sig;
2275     while (*s1 != '\\0' && *s1 == *s2) { s1++; s2++; }
2276     if (*s1 != *s2) {
2277         PyErr_Format(PyExc_TypeError,
2278             "C function %%s.%%s has wrong signature (expected %%s, got %%s)",
2279              PyModule_GetName(module), funcname, sig, desc);
2280         goto bad;
2281     }
2282     tmp.p = PyCObject_AsVoidPtr(cobj);
2283 #else
2284     if (!PyCapsule_IsValid(cobj, sig)) {
2285         PyErr_Format(PyExc_TypeError,
2286             "C function %%s.%%s has wrong signature (expected %%s, got %%s)",
2287              PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
2288         goto bad;
2289     }
2290     tmp.p = PyCapsule_GetPointer(cobj, sig);
2291 #endif
2292     *f = tmp.fp;
2293     if (!(*f))
2294         goto bad;
2295     Py_DECREF(d);
2296     return 0;
2297 bad:
2298     Py_XDECREF(d);
2299     return -1;
2300 }
2301 #endif
2302 """ % dict(API = Naming.api_name)
2303 )
2304
2305 #------------------------------------------------------------------------------------
2306
2307 register_cleanup_utility_code = UtilityCode(
2308 proto = """
2309 static int __Pyx_RegisterCleanup(void); /*proto*/
2310 static PyObject* __pyx_module_cleanup(PyObject *self, PyObject *unused); /*proto*/
2311 static PyMethodDef cleanup_def = {__Pyx_NAMESTR("__cleanup"), (PyCFunction)&__pyx_module_cleanup, METH_NOARGS, 0};
2312 """,
2313 impl = """
2314 static int __Pyx_RegisterCleanup(void) {
2315     /* Don't use Py_AtExit because that has a 32-call limit
2316      * and is called after python finalization.
2317      */
2318
2319     PyObject *cleanup_func = 0;
2320     PyObject *atexit = 0;
2321     PyObject *reg = 0;
2322     PyObject *args = 0;
2323     PyObject *res = 0;
2324     int ret = -1;
2325
2326     cleanup_func = PyCFunction_New(&cleanup_def, 0);
2327     args = PyTuple_New(1);
2328     if (!cleanup_func || !args)
2329         goto bad;
2330     PyTuple_SET_ITEM(args, 0, cleanup_func);
2331     cleanup_func = 0;
2332
2333     atexit = __Pyx_ImportModule("atexit");
2334     if (!atexit)
2335         goto bad;
2336     reg = __Pyx_GetAttrString(atexit, "register");
2337     if (!reg)
2338         goto bad;
2339     res = PyObject_CallObject(reg, args);
2340     if (!res)
2341         goto bad;
2342     ret = 0;
2343 bad:
2344     Py_XDECREF(cleanup_func);
2345     Py_XDECREF(atexit);
2346     Py_XDECREF(reg);
2347     Py_XDECREF(args);
2348     Py_XDECREF(res);
2349     return ret;
2350 }
2351 """)
2352
2353 import_star_utility_code = """
2354
2355 /* import_all_from is an unexposed function from ceval.c */
2356
2357 static int
2358 __Pyx_import_all_from(PyObject *locals, PyObject *v)
2359 {
2360     PyObject *all = __Pyx_GetAttrString(v, "__all__");
2361     PyObject *dict, *name, *value;
2362     int skip_leading_underscores = 0;
2363     int pos, err;
2364
2365     if (all == NULL) {
2366         if (!PyErr_ExceptionMatches(PyExc_AttributeError))
2367             return -1; /* Unexpected error */
2368         PyErr_Clear();
2369         dict = __Pyx_GetAttrString(v, "__dict__");
2370         if (dict == NULL) {
2371             if (!PyErr_ExceptionMatches(PyExc_AttributeError))
2372                 return -1;
2373             PyErr_SetString(PyExc_ImportError,
2374             "from-import-* object has no __dict__ and no __all__");
2375             return -1;
2376         }
2377         all = PyMapping_Keys(dict);
2378         Py_DECREF(dict);
2379         if (all == NULL)
2380             return -1;
2381         skip_leading_underscores = 1;
2382     }
2383
2384     for (pos = 0, err = 0; ; pos++) {
2385         name = PySequence_GetItem(all, pos);
2386         if (name == NULL) {
2387             if (!PyErr_ExceptionMatches(PyExc_IndexError))
2388                 err = -1;
2389             else
2390                 PyErr_Clear();
2391             break;
2392         }
2393         if (skip_leading_underscores &&
2394 #if PY_MAJOR_VERSION < 3
2395             PyString_Check(name) &&
2396             PyString_AS_STRING(name)[0] == '_')
2397 #else
2398             PyUnicode_Check(name) &&
2399             PyUnicode_AS_UNICODE(name)[0] == '_')
2400 #endif
2401         {
2402             Py_DECREF(name);
2403             continue;
2404         }
2405         value = PyObject_GetAttr(v, name);
2406         if (value == NULL)
2407             err = -1;
2408         else if (PyDict_CheckExact(locals))
2409             err = PyDict_SetItem(locals, name, value);
2410         else
2411             err = PyObject_SetItem(locals, name, value);
2412         Py_DECREF(name);
2413         Py_XDECREF(value);
2414         if (err != 0)
2415             break;
2416     }
2417     Py_DECREF(all);
2418     return err;
2419 }
2420
2421
2422 static int %(IMPORT_STAR)s(PyObject* m) {
2423
2424     int i;
2425     int ret = -1;
2426     char* s;
2427     PyObject *locals = 0;
2428     PyObject *list = 0;
2429     PyObject *name;
2430     PyObject *item;
2431
2432     locals = PyDict_New();              if (!locals) goto bad;
2433     if (__Pyx_import_all_from(locals, m) < 0) goto bad;
2434     list = PyDict_Items(locals);        if (!list) goto bad;
2435
2436     for(i=0; i<PyList_GET_SIZE(list); i++) {
2437         name = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 0);
2438         item = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 1);
2439 #if PY_MAJOR_VERSION < 3
2440         s = PyString_AsString(name);
2441 #else
2442         s = PyUnicode_AsString(name);
2443 #endif
2444         if (!s) goto bad;
2445         if (%(IMPORT_STAR_SET)s(item, name, s) < 0) goto bad;
2446     }
2447     ret = 0;
2448
2449 bad:
2450     Py_XDECREF(locals);
2451     Py_XDECREF(list);
2452     return ret;
2453 }
2454 """ % {'IMPORT_STAR'     : Naming.import_star,
2455        'IMPORT_STAR_SET' : Naming.import_star_set }
2456
2457 refnanny_utility_code = UtilityCode(proto="""
2458 #ifndef CYTHON_REFNANNY
2459   #define CYTHON_REFNANNY 0
2460 #endif
2461
2462 #if CYTHON_REFNANNY
2463   typedef struct {
2464     void (*INCREF)(void*, PyObject*, int);
2465     void (*DECREF)(void*, PyObject*, int);
2466     void (*GOTREF)(void*, PyObject*, int);
2467     void (*GIVEREF)(void*, PyObject*, int);
2468     void* (*SetupContext)(const char*, int, const char*);
2469     void (*FinishContext)(void**);
2470   } __Pyx_RefNannyAPIStruct;
2471   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
2472   static __Pyx_RefNannyAPIStruct * __Pyx_RefNannyImportAPI(const char *modname) {
2473     PyObject *m = NULL, *p = NULL;
2474     void *r = NULL;
2475     m = PyImport_ImportModule((char *)modname);
2476     if (!m) goto end;
2477     p = PyObject_GetAttrString(m, (char *)\"RefNannyAPI\");
2478     if (!p) goto end;
2479     r = PyLong_AsVoidPtr(p);
2480   end:
2481     Py_XDECREF(p);
2482     Py_XDECREF(m);
2483     return (__Pyx_RefNannyAPIStruct *)r;
2484   }
2485   #define __Pyx_RefNannySetupContext(name) \
2486           void *__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
2487   #define __Pyx_RefNannyFinishContext() \
2488           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
2489   #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
2490   #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
2491   #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
2492   #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
2493   #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r);} } while(0)
2494 #else
2495   #define __Pyx_RefNannySetupContext(name)
2496   #define __Pyx_RefNannyFinishContext()
2497   #define __Pyx_INCREF(r) Py_INCREF(r)
2498   #define __Pyx_DECREF(r) Py_DECREF(r)
2499   #define __Pyx_GOTREF(r)
2500   #define __Pyx_GIVEREF(r)
2501   #define __Pyx_XDECREF(r) Py_XDECREF(r)
2502 #endif /* CYTHON_REFNANNY */
2503 #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);} } while(0)
2504 #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r);} } while(0)
2505 """)
2506
2507
2508 main_method = UtilityCode(
2509 impl = """
2510 #if PY_MAJOR_VERSION < 3 || (!defined(WIN32) && !defined(MS_WINDOWS))
2511 int main(int argc, char** argv) {
2512 #else
2513 int wmain(int argc, wchar_t **argv) {
2514 #endif
2515     int r = 0;
2516     PyObject* m = NULL;
2517     Py_SetProgramName(argv[0]);
2518     Py_Initialize();
2519     PySys_SetArgv(argc, argv);
2520     %(module_is_main)s = 1;
2521 #if PY_MAJOR_VERSION < 3
2522         init%(module_name)s();
2523 #else
2524         m = PyInit_%(module_name)s(name);
2525 #endif
2526     if (PyErr_Occurred() != NULL) {
2527         r = 1;
2528         PyErr_Print(); /* This exits with the right code if SystemExit. */
2529         if (Py_FlushLine()) PyErr_Clear();
2530     }
2531     Py_XDECREF(m);
2532     Py_Finalize();
2533     return r;
2534 }
2535 """)
2536
2537 packed_struct_utility_code = UtilityCode(proto="""
2538 #if defined(__GNUC__)
2539 #define __Pyx_PACKED __attribute__((__packed__))
2540 #else
2541 #define __Pyx_PACKED
2542 #endif
2543 """, impl="", proto_block='utility_code_proto_before_types')