Cython/Compiler/ModuleNode.py

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