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