Cython/Compiler/ModuleNode.py

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