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