Cython/Compiler/ModuleNode.py

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