Cython/Compiler/ModuleNode.py

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