Lines Matching defs:code
58 # to code generation.
62 # CodeGenerator, and tell that CodeGenerator to generate code
83 # Ensure that we don't generate import code for these entries!
314 code = globalstate['before_global_var']
315 code.putln('#define __Pyx_MODULE_NAME "%s"' % self.full_module_name)
316 code.putln("int %s%s = 0;" % (Naming.module_is_main, self.full_module_name.replace('.', '__')))
317 code.putln("")
318 code.putln("/* Implementation of '%s' */" % env.qualified_name)
320 code = globalstate['all_the_rest']
322 self.generate_cached_builtins_decls(env, code)
323 self.generate_lambda_definitions(env, code)
325 self.generate_variable_definitions(env, code)
326 self.body.generate_function_definitions(env, code)
327 code.mark_pos(None)
328 self.generate_typeobj_definitions(env, code)
329 self.generate_method_table(env, code)
331 self.generate_import_star(env, code)
332 self.generate_pymoduledef_struct(env, code)
457 # for Cython generated utility code
498 def generate_type_definitions(self, env, modules, vtab_list, vtabslot_list, code):
501 self.generate_objstruct_predeclaration(entry.type, code)
513 self.generate_type_header_code(type_entries, code)
515 self.generate_objstruct_definition(entry.type, code)
516 self.generate_typeobj_predeclaration(entry, code)
518 self.generate_typeobj_predeclaration(entry, code)
519 self.generate_exttype_vtable_struct(entry, code)
520 self.generate_exttype_vtabptr_declaration(entry, code)
521 self.generate_exttype_final_methods_declaration(entry, code)
528 # but we need to declare it earlier than utility code.
546 def generate_module_preamble(self, env, cimported_modules, code):
547 code.putln("/* Generated by Cython %s */" % Version.watermark)
548 code.putln("")
549 code.putln("#define PY_SSIZE_T_CLEAN")
557 code.putln("#ifndef CYTHON_USE_PYLONG_INTERNALS")
558 code.putln("#ifdef PYLONG_BITS_IN_DIGIT")
560 code.putln("#define CYTHON_USE_PYLONG_INTERNALS 0")
561 code.putln("#else")
562 code.putln('#include "pyconfig.h"')
563 code.putln("#ifdef PYLONG_BITS_IN_DIGIT")
564 code.putln("#define CYTHON_USE_PYLONG_INTERNALS 1")
565 code.putln("#else")
566 code.putln("#define CYTHON_USE_PYLONG_INTERNALS 0")
567 code.putln("#endif")
568 code.putln("#endif")
569 code.putln("#endif")
572 code.putln('#include "%s"' % filename)
573 code.putln("#ifndef Py_PYTHON_H")
574 code.putln(" #error Python headers needed to compile C extensions, please install development version of Python.")
575 code.putln("#elif PY_VERSION_HEX < 0x02040000")
576 code.putln(" #error Cython requires Python 2.4+.")
577 code.putln("#else")
578 code.globalstate["end"].putln("#endif /* Py_PYTHON_H */")
581 code.putln('#define CYTHON_ABI "%s"' % __version__.replace('.', '_'))
583 code.put(UtilityCode.load_as_string("CModulePreamble", "ModuleSetupCode.c")[1])
585 code.put("""
592 code.putln(" #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)")
593 code.putln(" #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)")
595 code.putln(" #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y)")
596 code.putln(" #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y)")
597 code.putln("#endif")
599 code.putln("")
600 self.generate_extern_c_macro_definition(code)
601 code.putln("")
603 code.putln("#if defined(WIN32) || defined(MS_WINDOWS)")
604 code.putln("#define _USE_MATH_DEFINES")
605 code.putln("#endif")
606 code.putln("#include <math.h>")
608 code.putln("#define %s" % Naming.h_guard_prefix + self.api_name(env))
609 code.putln("#define %s" % Naming.api_guard_prefix + self.api_name(env))
610 self.generate_includes(env, cimported_modules, code)
611 code.putln("")
612 code.putln("#ifdef PYREX_WITHOUT_ASSERTIONS")
613 code.putln("#define CYTHON_WITHOUT_ASSERTIONS")
614 code.putln("#endif")
615 code.putln("")
618 code.putln("")
619 code.putln("#if !defined(CYTHON_CCOMPLEX)")
620 code.putln("#define CYTHON_CCOMPLEX 1")
621 code.putln("#endif")
622 code.putln("")
623 code.put(UtilityCode.load_as_string("UtilityFunctionPredeclarations", "ModuleSetupCode.c")[0])
629 code.putln('#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII %s' % int(c_string_encoding == 'ascii'))
631 code.putln('#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 1')
633 code.putln('#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0')
634 code.putln('#define __PYX_DEFAULT_STRING_ENCODING "%s"' % c_string_encoding)
639 code.putln('#define __Pyx_PyObject_FromString __Pyx_Py%s_FromString' % c_string_func_name)
640 code.putln('#define __Pyx_PyObject_FromStringAndSize __Pyx_Py%s_FromStringAndSize' % c_string_func_name)
641 code.put(UtilityCode.load_as_string("TypeConversions", "TypeConversion.c")[0])
648 code.put(Nodes.branch_prediction_macros)
649 code.putln('')
650 code.putln('static PyObject *%s;' % env.module_cname)
651 code.putln('static PyObject *%s;' % env.module_dict_cname)
652 code.putln('static PyObject *%s;' % Naming.builtins_cname)
653 code.putln('static PyObject *%s;' % Naming.empty_tuple)
654 code.putln('static PyObject *%s;' % Naming.empty_bytes)
656 code.putln('static PyObject *%s;' % Naming.preimport_cname)
657 code.putln('static int %s;' % Naming.lineno_cname)
658 code.putln('static int %s = 0;' % Naming.clineno_cname)
659 code.putln('static const char * %s= %s;' % (Naming.cfilenm_cname, Naming.file_c_macro))
660 code.putln('static const char *%s;' % Naming.filename_cname)
662 def generate_extern_c_macro_definition(self, code):
664 code.putln("#ifndef %s" % name)
665 code.putln(" #ifdef __cplusplus")
666 code.putln(' #define %s extern "C"' % name)
667 code.putln(" #else")
668 code.putln(" #define %s extern" % name)
669 code.putln(" #endif")
670 code.putln("#endif")
672 def generate_includes(self, env, cimported_modules, code):
677 code.putln('#include %s' % byte_decoded_filenname)
679 code.putln('#include "%s"' % byte_decoded_filenname)
681 code.putln_openmp("#include <omp.h>")
683 def generate_filename_table(self, code):
684 code.putln("")
685 code.putln("static const char *%s[] = {" % Naming.filetable_cname)
686 if code.globalstate.filename_list:
687 for source_desc in code.globalstate.filename_list:
690 code.putln('"%s",' % escaped_filename)
693 code.putln("0")
694 code.putln("};")
696 def generate_type_predeclarations(self, env, code):
699 def generate_type_header_code(self, type_entries, code):
701 #self.generate_gcc33_hack(env, code) # Is this still needed?
710 self.generate_struct_union_predeclaration(entry, code)
712 self.generate_objstruct_predeclaration(type, code)
719 self.generate_typedef(entry, code)
721 self.generate_enum_definition(entry, code)
723 self.generate_struct_union_definition(entry, code)
725 self.generate_cpp_class_definition(entry, code)
727 self.generate_objstruct_definition(type, code)
729 def generate_gcc33_hack(self, env, code):
731 code.putln("")
740 code.putln("typedef struct %s __pyx_gcc33_%s;" % (
743 def generate_typedef(self, entry, code):
747 writer = code.globalstate['numeric_typedefs']
749 writer = code
751 writer = code
763 def generate_struct_union_predeclaration(self, entry, code):
766 code.putln("template <typename %s>" % ", typename ".join([T.declaration_code("") for T in type.templates]))
767 code.putln(self.sue_predeclaration(type, type.kind, type.cname))
774 def generate_struct_union_definition(self, entry, code):
775 code.mark_pos(entry.pos)
783 code.globalstate.use_utility_code(packed_struct_utility_code)
787 code.putln("#if defined(__SUNPRO_C)")
788 code.putln(" #pragma pack(1)")
789 code.putln("#elif !defined(__GNUC__)")
790 code.putln(" #pragma pack(push, 1)")
791 code.putln("#endif")
792 code.putln(header)
799 code.putln(
802 code.putln(footer)
804 code.putln("#if defined(__SUNPRO_C)")
805 code.putln(" #pragma pack()")
806 code.putln("#elif !defined(__GNUC__)")
807 code.putln(" #pragma pack(pop)")
808 code.putln("#endif")
810 def generate_cpp_class_definition(self, entry, code):
811 code.mark_pos(entry.pos)
816 code.putln("template <class %s>" % ", class ".join([T.declaration_code("") for T in type.templates]))
818 code.put("struct %s" % type.cname)
822 code.put(" : public %s" % base_class_decl)
823 code.putln(" {")
828 code.put("virtual ")
832 code.putln(
836 code.put("virtual ~%s() { }" % type.cname)
837 code.putln("};")
839 def generate_enum_definition(self, entry, code):
840 code.mark_pos(entry.pos)
845 code.putln(header)
853 # this does not really generate code, just builds the result value
856 value_entry.value_node.generate_evaluation_code(code)
867 code.putln(value_code)
868 code.putln(footer)
871 code.putln("typedef enum %s %s;" % (name, name))
873 def generate_typeobj_predeclaration(self, entry, code):
874 code.putln("")
878 code.putln("%s %s %s;" % (
883 code.putln("%s %s %s;" % (
889 # code.putln("static PyTypeObject %s;" % name)
891 def generate_exttype_vtable_struct(self, entry, code):
895 code.mark_pos(entry.pos)
903 code.putln("")
904 code.putln(
908 code.putln("struct %s %s;" % (
913 code.putln(
915 code.putln(
918 def generate_exttype_vtabptr_declaration(self, entry, code):
922 code.mark_pos(entry.pos)
926 code.putln("static struct %s *%s;" % (
930 def generate_exttype_final_methods_declaration(self, entry, code):
934 code.mark_pos(entry.pos)
941 modifiers = code.build_function_modifiers(method_entry.func_modifiers)
942 code.putln("static %s%s;" % (modifiers, declaration))
944 def generate_objstruct_predeclaration(self, type, code):
947 code.putln(self.sue_predeclaration(type, "struct", type.objstruct_cname))
949 def generate_objstruct_definition(self, type, code):
950 code.mark_pos(type.pos)
957 code.putln(header)
964 code.putln(
970 code.putln(
973 code.putln(
982 code.putln(
985 code.putln(footer)
988 code.putln("typedef struct %s %s;" % (type.objstruct_cname, type.objtypedef_cname))
990 def generate_c_class_declarations(self, env, code, definition):
993 code.putln("static PyTypeObject *%s = 0;" %
996 def generate_cvariable_declarations(self, env, code, definition):
1035 code.put("%s " % storage_class)
1036 code.put(type.declaration_code(
1039 code.put_safe(" = %s" % init)
1040 code.putln(";")
1042 code.putln("#define %s (*%s)" % (entry.cname, cname))
1044 def generate_cfunction_declarations(self, env, code, definition):
1047 generate_cfunction_declaration(entry, env, code, definition)
1049 def generate_variable_definitions(self, env, code):
1053 code.put(entry.type.declaration_code(entry.cname))
1056 code.put_safe(" = %s" % init)
1057 code.putln(";")
1059 def generate_typeobj_definitions(self, env, code):
1068 self.generate_exttype_vtable(scope, code)
1069 self.generate_new_function(scope, code, entry)
1070 self.generate_dealloc_function(scope, code)
1072 self.generate_traverse_function(scope, code, entry)
1074 self.generate_clear_function(scope, code, entry)
1076 self.generate_getitem_int_function(scope, code)
1078 self.generate_ass_subscript_function(scope, code)
1081 code.putln("#if PY_MAJOR_VERSION >= 3")
1082 code.putln("#error __getslice__, __setslice__, and __delslice__ not supported in Python 3.")
1083 code.putln("#endif")
1085 self.generate_ass_slice_function(scope, code)
1087 self.generate_getattro_function(scope, code)
1089 self.generate_setattro_function(scope, code)
1091 self.generate_descr_get_function(scope, code)
1093 self.generate_descr_set_function(scope, code)
1094 self.generate_property_accessors(scope, code)
1095 self.generate_method_table(scope, code)
1096 self.generate_getset_table(scope, code)
1097 self.generate_typeobj_definition(full_module_name, entry, code)
1099 def generate_exttype_vtable(self, scope, code):
1103 code.putln("static struct %s %s;" % (
1107 def generate_self_cast(self, scope, code):
1109 code.putln(
1114 def generate_new_function(self, scope, code, cclass_entry):
1143 decls = code.globalstate['decls']
1146 code.putln("")
1148 code.putln("static %s[%d];" % (
1151 code.putln("static int %s = 0;" % freecount_name)
1152 code.putln("")
1153 code.putln(
1161 code.putln("%s;" % scope.parent_type.declaration_code("p"))
1166 code.putln("PyObject *o = %s(t, a, k);" % tp_new)
1168 code.putln("PyObject *o;")
1170 code.globalstate.use_utility_code(
1177 code.putln("if (CYTHON_COMPILING_IN_CPYTHON && likely((%s > 0) & (t->tp_basicsize == sizeof(%s))%s)) {" % (
1179 code.putln("o = (PyObject*)%s[--%s];" % (
1181 code.putln("memset(o, 0, sizeof(%s));" % obj_struct)
1182 code.putln("(void) PyObject_INIT(o, t);")
1184 code.putln("PyObject_GC_Track(o);")
1185 code.putln("} else {")
1187 code.putln("if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {")
1188 code.putln("o = (*t->tp_alloc)(t, 0);")
1190 code.putln("} else {")
1191 code.putln("o = (PyObject *) PyBaseObject_Type.tp_new(t, %s, 0);" % Naming.empty_tuple)
1192 code.putln("}")
1193 code.putln("if (unlikely(!o)) return 0;")
1195 code.putln('}')
1197 code.putln("p = %s;" % type.cast_code("o"))
1199 # self.generate_self_cast(scope, code)
1208 code.putln("p->%s = %s%s;" % (
1213 code.putln("new((void*)&(p->%s)) %s();" %
1217 code.put_init_var_to_py_none(entry, "p->%s", nanny=False)
1220 code.putln("p->%s.data = NULL;" % entry.cname)
1221 code.putln("p->%s.memview = NULL;" % entry.cname)
1224 code.putln("p->%s.obj = NULL;" % entry.cname)
1227 code.putln("p->from_slice.memview = NULL;")
1234 code.putln(
1237 code.put_decref_clear("o", py_object_type, nanny=False)
1238 code.putln(
1240 code.putln(
1242 code.putln(
1245 def generate_dealloc_function(self, scope, code):
1253 code.putln("")
1254 code.putln(
1269 self.generate_self_cast(scope, code)
1273 code.putln("#if PY_VERSION_HEX >= 0x030400a1")
1279 code.putln("if (unlikely(Py_TYPE(o)->tp_finalize) && %s) {" %
1282 code.putln("if (PyObject_CallFinalizerFromDealloc(o)) return;")
1283 code.putln("}")
1284 code.putln("#endif")
1290 code.putln("PyObject_GC_UnTrack(o);")
1293 self.generate_usr_dealloc_call(scope, code)
1296 code.putln("if (p->__weakref__) PyObject_ClearWeakRefs(o);")
1299 code.putln("__Pyx_call_destructor(&p->%s);" % entry.cname)
1302 code.put_xdecref_clear("p->%s" % entry.cname, entry.type, nanny=False,
1306 code.put_xdecref_memoryviewslice("p->%s" % entry.cname,
1314 code.putln("PyObject_GC_Track(o);")
1316 code.putln("#if CYTHON_COMPILING_IN_CPYTHON")
1317 code.putln("if (PyType_IS_GC(Py_TYPE(o)->tp_base))")
1318 code.putln("#endif")
1319 code.putln("PyObject_GC_Track(o);")
1323 code.putln("%s(o);" % tp_dealloc)
1325 code.putln("%s->tp_dealloc(o);" % base_type.typeptr_cname)
1332 code.putln("if (likely(%s)) %s->tp_dealloc(o); "
1335 code.globalstate.use_utility_code(
1350 code.putln("if (CYTHON_COMPILING_IN_CPYTHON && ((%s < %d) & (Py_TYPE(o)->tp_basicsize == sizeof(%s))%s)) {" % (
1353 code.putln("%s[%s++] = %s;" % (
1355 code.putln("} else {")
1356 code.putln("(*Py_TYPE(o)->tp_free)(o);")
1358 code.putln("}")
1359 code.putln(
1362 def generate_usr_dealloc_call(self, scope, code):
1367 code.putln("{")
1368 code.putln("PyObject *etype, *eval, *etb;")
1369 code.putln("PyErr_Fetch(&etype, &eval, &etb);")
1370 code.putln("++Py_REFCNT(o);")
1371 code.putln("%s(o);" % entry.func_cname)
1372 code.putln("--Py_REFCNT(o);")
1373 code.putln("PyErr_Restore(etype, eval, etb);")
1374 code.putln("}")
1376 def generate_traverse_function(self, scope, code, cclass_entry):
1382 code.putln("")
1383 code.putln(
1391 code.putln("int e;")
1394 self.generate_self_cast(scope, code)
1400 code.putln("e = %s(o, v, a); if (e) return e;" % static_call)
1403 code.putln("if (!%s->tp_traverse); else { e = %s->tp_traverse(o,v,a); if (e) return e; }" % (
1411 code.putln("e = ((likely(%s)) ? ((%s->tp_traverse) ? %s->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, %s)); if (e) return e;" % (
1413 code.globalstate.use_utility_code(
1418 code.putln(
1423 code.putln(
1426 code.putln(
1435 code.putln("if (p->%s) {" % cname)
1436 code.putln( "e = (*v)(p->%s, a); if (e) return e;" % cname)
1437 code.putln("}")
1439 code.putln(
1441 code.putln(
1444 def generate_clear_function(self, scope, code, cclass_entry):
1459 code.putln("")
1460 code.putln("static int %s(%sPyObject *o) {" % (slot_func, unused))
1463 code.putln("PyObject* tmp;")
1466 self.generate_self_cast(scope, code)
1472 code.putln("%s(o);" % static_call)
1475 code.putln("if (!%s->tp_clear); else %s->tp_clear(o);" % (
1483 code.putln("if (likely(%s)) { if (%s->tp_clear) %s->tp_clear(o); } else __Pyx_call_next_tp_clear(o, %s);" % (
1485 code.globalstate.use_utility_code(
1491 code.putln("tmp = ((PyObject*)%s);" % name)
1493 code.put_init_to_py_none(name, py_object_type, nanny=False)
1495 code.put_init_to_py_none(name, entry.type, nanny=False)
1496 code.putln("Py_XDECREF(tmp);")
1499 code.putln("Py_CLEAR(p->%s);" % entry.cname)
1503 code.putln("Py_CLEAR(p->%s.obj);" % entry.cname)
1506 code.putln("__PYX_XDEC_MEMVIEW(&p->from_slice, 1);")
1508 code.putln(
1510 code.putln(
1513 def generate_getitem_int_function(self, scope, code):
1517 code.putln(
1520 code.putln(
1522 code.putln(
1524 code.putln(
1526 code.putln(
1528 code.putln(
1530 code.putln(
1533 def generate_ass_subscript_function(self, scope, code):
1540 code.putln("")
1541 code.putln(
1544 code.putln(
1547 code.putln(
1552 base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code)
1553 code.putln(
1555 code.putln(
1557 code.putln(
1559 code.putln(
1561 code.putln(
1564 code.putln(
1569 base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code)
1570 code.putln(
1572 code.putln(
1574 code.putln(
1576 code.putln(
1578 code.putln(
1582 self, base_type, substructure, slot, args, code):
1586 code.putln(
1589 code.putln(
1593 code.putln(
1596 code.putln(
1600 def generate_ass_slice_function(self, scope, code):
1607 code.putln("")
1608 code.putln(
1611 code.putln(
1614 code.putln(
1619 base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)
1620 code.putln(
1622 code.putln(
1624 code.putln(
1626 code.putln(
1628 code.putln(
1631 code.putln(
1636 base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)
1637 code.putln(
1639 code.putln(
1641 code.putln(
1643 code.putln(
1645 code.putln(
1648 def generate_getattro_function(self, scope, code):
1667 code.putln("")
1668 code.putln(
1672 code.putln(
1676 code.putln(
1679 code.putln(
1681 code.putln(
1683 code.putln(
1686 code.putln(
1688 code.putln(
1690 code.putln(
1693 def generate_setattro_function(self, scope, code):
1700 code.putln("")
1701 code.putln(
1704 code.putln(
1707 code.putln(
1712 base_type, None, "tp_setattro", "o, n, v", code)
1713 code.putln(
1715 code.putln(
1717 code.putln(
1720 code.putln(
1725 base_type, None, "tp_setattro", "o, n, v", code)
1726 code.putln(
1728 code.putln(
1730 code.putln(
1733 def generate_descr_get_function(self, scope, code):
1739 code.putln("")
1740 code.putln(
1743 code.putln(
1745 code.putln(
1747 code.putln(
1749 #code.put_incref("i", py_object_type)
1750 #code.put_incref("c", py_object_type)
1751 code.putln(
1754 #code.put_decref("i", py_object_type)
1755 #code.put_decref("c", py_object_type)
1756 code.putln(
1758 code.putln(
1761 def generate_descr_set_function(self, scope, code):
1768 code.putln("")
1769 code.putln(
1772 code.putln(
1775 code.putln(
1780 base_type, None, "tp_descr_set", "o, i, v", code)
1781 code.putln(
1783 code.putln(
1785 code.putln(
1787 code.putln(
1790 code.putln(
1795 base_type, None, "tp_descr_set", "o, i, v", code)
1796 code.putln(
1798 code.putln(
1800 code.putln(
1802 code.putln(
1805 def generate_property_accessors(self, cclass_scope, code):
1809 self.generate_property_get_function(entry, code)
1811 self.generate_property_set_function(entry, code)
1813 def generate_property_get_function(self, property_entry, code):
1818 code.putln("")
1819 code.putln(
1822 code.putln(
1825 code.putln(
1828 def generate_property_set_function(self, property_entry, code):
1834 code.putln("")
1835 code.putln(
1838 code.putln(
1841 code.putln(
1845 code.putln(
1847 code.putln(
1849 code.putln(
1851 code.putln(
1854 code.putln(
1858 code.putln(
1860 code.putln(
1862 code.putln(
1864 code.putln(
1867 def generate_typeobj_definition(self, modname, entry, code):
1871 suite.generate_substructure(scope, code)
1872 code.putln("")
1877 #code.putln(header % scope.parent_type.typeobj_cname)
1878 code.putln(header % type.typeobj_cname)
1879 code.putln(
1881 code.putln(
1888 code.putln(
1891 code.putln(
1894 slot.generate(scope, code)
1895 code.putln(
1898 def generate_method_table(self, env, code):
1901 code.putln("")
1902 code.putln(
1907 code.put_pymethoddef(entry, ",")
1908 code.putln(
1910 code.putln(
1913 def generate_getset_table(self, env, code):
1915 code.putln("")
1916 code.putln(
1921 doc_code = "__Pyx_DOCSTR(%s)" % code.get_string_const(entry.doc)
1924 code.putln(
1930 code.putln(
1932 code.putln(
1935 def generate_import_star(self, env, code):
1937 code.putln()
1938 code.putln("static char* %s_type_names[] = {" % Naming.import_star)
1941 code.putln('"%s",' % name)
1942 code.putln("0")
1943 code.putln("};")
1944 code.putln()
1945 code.enter_cfunc_scope() # as we need labels
1946 code.putln("static int %s(PyObject *o, PyObject* py_name, char *name) {" % Naming.import_star_set)
1947 code.putln("char** type_name = %s_type_names;" % Naming.import_star)
1948 code.putln("while (*type_name) {")
1949 code.putln("if (__Pyx_StrEq(name, *type_name)) {")
1950 code.putln('PyErr_Format(PyExc_TypeError, "Cannot overwrite C type %s", name);')
1951 code.putln('goto bad;')
1952 code.putln("}")
1953 code.putln("type_name++;")
1954 code.putln("}")
1955 old_error_label = code.new_error_label()
1956 code.putln("if (0);") # so the first one can be "else if"
1959 code.putln('else if (__Pyx_StrEq(name, "%s")) {' % name)
1962 code.putln("if (!(%s)) %s;" % (
1964 code.error_goto(entry.pos)))
1965 code.putln("Py_INCREF(o);")
1966 code.put_decref(entry.cname, entry.type, nanny=False)
1967 code.putln("%s = %s;" % (
1974 code.putln("%s = %s; if (%s) %s;" % (
1978 code.error_goto(entry.pos)))
1980 code.putln('PyErr_Format(PyExc_TypeError, "Cannot convert Python object %s to %s");' % (name, entry.type))
1981 code.putln(code.error_goto(entry.pos))
1982 code.putln("}")
1983 code.putln("else {")
1984 code.putln("if (PyObject_SetAttr(%s, py_name, o) < 0) goto bad;" % Naming.module_cname)
1985 code.putln("}")
1986 code.putln("return 0;")
1987 if code.label_used(code.error_label):
1988 code.put_label(code.error_label)
1990 code.put_add_traceback(self.full_module_name)
1991 code.error_label = old_error_label
1992 code.putln("bad:")
1993 code.putln("return -1;")
1994 code.putln("}")
1995 code.putln(import_star_utility_code)
1996 code.exit_cfunc_scope() # done with labels
1998 def generate_module_init_func(self, imported_modules, env, code):
1999 code.enter_cfunc_scope()
2000 code.putln("")
2003 code.putln("#if PY_MAJOR_VERSION < 3")
2004 code.putln("%s; /*proto*/" % header2)
2005 code.putln(header2)
2006 code.putln("#else")
2007 code.putln("%s; /*proto*/" % header3)
2008 code.putln(header3)
2009 code.putln("#endif")
2010 code.putln("{")
2011 tempdecl_code = code.insertion_point()
2013 code.put_declare_refcount_context()
2014 code.putln("#if CYTHON_REFNANNY")
2015 code.putln("__Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"refnanny\");")
2016 code.putln("if (!__Pyx_RefNanny) {")
2017 code.putln(" PyErr_Clear();")
2018 code.putln(" __Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"Cython.Runtime.refnanny\");")
2019 code.putln(" if (!__Pyx_RefNanny)")
2020 code.putln(" Py_FatalError(\"failed to import 'refnanny' module\");")
2021 code.putln("}")
2022 code.putln("#endif")
2023 code.put_setup_refcount_context(header3)
2026 code.putln("if ( __Pyx_check_binary_version() < 0) %s" % code.error_goto(self.pos))
2028 code.putln("%s = PyTuple_New(0); %s" % (Naming.empty_tuple, code.error_goto_if_null(Naming.empty_tuple, self.pos)))
2029 code.putln("%s = PyBytes_FromStringAndSize(\"\", 0); %s" % (Naming.empty_bytes, code.error_goto_if_null(Naming.empty_bytes, self.pos)))
2031 code.putln("#ifdef __Pyx_CyFunction_USED")
2032 code.putln("if (__Pyx_CyFunction_init() < 0) %s" % code.error_goto(self.pos))
2033 code.putln("#endif")
2035 code.putln("#ifdef __Pyx_FusedFunction_USED")
2036 code.putln("if (__pyx_FusedFunction_init() < 0) %s" % code.error_goto(self.pos))
2037 code.putln("#endif")
2039 code.putln("#ifdef __Pyx_Generator_USED")
2040 code.putln("if (__pyx_Generator_init() < 0) %s" % code.error_goto(self.pos))
2041 code.putln("#endif")
2043 code.putln("/*--- Library function declarations ---*/")
2044 env.generate_library_function_declarations(code)
2046 code.putln("/*--- Threads initialization code ---*/")
2047 code.putln("#if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS")
2048 code.putln("#ifdef WITH_THREAD /* Python build with threading support? */")
2049 code.putln("PyEval_InitThreads();")
2050 code.putln("#endif")
2051 code.putln("#endif")
2053 code.putln("/*--- Module creation code ---*/")
2054 self.generate_module_creation_code(env, code)
2056 code.putln("/*--- Initialize various global constants etc. ---*/")
2057 code.putln(code.error_goto_if_neg("__Pyx_InitGlobals()", self.pos))
2059 code.putln("#if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)")
2060 code.putln("if (__Pyx_init_sys_getdefaultencoding_params() < 0) %s" % code.error_goto(self.pos))
2061 code.putln("#endif")
2063 __main__name = code.globalstate.get_py_string_const(
2065 code.putln("if (%s%s) {" % (Naming.module_is_main, self.full_module_name.replace('.', '__')))
2066 code.putln(
2070 code.error_goto(self.pos)))
2071 code.putln("}")
2074 self.generate_module_import_setup(env, code)
2077 code.putln("/*--- Builtin init code ---*/")
2078 code.putln(code.error_goto_if_neg("__Pyx_InitCachedBuiltins()", self.pos))
2080 code.putln("/*--- Constants init code ---*/")
2081 code.putln(code.error_goto_if_neg("__Pyx_InitCachedConstants()", self.pos))
2083 code.putln("/*--- Global init code ---*/")
2084 self.generate_global_init_code(env, code)
2086 code.putln("/*--- Variable export code ---*/")
2087 self.generate_c_variable_export_code(env, code)
2089 code.putln("/*--- Function export code ---*/")
2090 self.generate_c_function_export_code(env, code)
2092 code.putln("/*--- Type init code ---*/")
2093 self.generate_type_init_code(env, code)
2095 code.putln("/*--- Type import code ---*/")
2097 self.generate_type_import_code_for_module(module, env, code)
2099 code.putln("/*--- Variable import code ---*/")
2101 self.generate_c_variable_import_code_for_module(module, env, code)
2103 code.putln("/*--- Function import code ---*/")
2106 self.generate_c_function_import_code_for_module(module, env, code)
2108 code.putln("/*--- Execution code ---*/")
2109 code.mark_pos(None)
2111 self.body.generate_execution_code(code)
2114 code.globalstate.use_utility_code(
2116 code.putln("if (__Pyx_RegisterCleanup()) %s;" % code.error_goto(self.pos))
2118 code.put_goto(code.return_label)
2119 code.put_label(code.error_label)
2120 for cname, type in code.funcstate.all_managed_temps():
2121 code.put_xdecref(cname, type)
2122 code.putln('if (%s) {' % env.module_cname)
2123 code.put_add_traceback("init %s" % env.qualified_name)
2125 code.put_decref_clear(env.module_cname, py_object_type, nanny=False)
2126 code.putln('} else if (!PyErr_Occurred()) {')
2127 code.putln('PyErr_SetString(PyExc_ImportError, "init %s");' % env.qualified_name)
2128 code.putln('}')
2129 code.put_label(code.return_label)
2131 code.put_finish_refcount_context()
2133 code.putln("#if PY_MAJOR_VERSION < 3")
2134 code.putln("return;")
2135 code.putln("#else")
2136 code.putln("return %s;" % env.module_cname)
2137 code.putln("#endif")
2138 code.putln('}')
2140 tempdecl_code.put_temp_declarations(code.funcstate)
2142 code.exit_cfunc_scope()
2144 def generate_module_import_setup(self, env, code):
2150 code.putln('if (__Pyx_SetAttrString(%s, "__file__", %s) < 0) %s;' % (
2152 code.globalstate.get_py_string_const(
2154 code.error_goto(self.pos)))
2158 temp = code.funcstate.allocate_temp(py_object_type, True)
2159 code.putln('%s = Py_BuildValue("[O]", %s); %s' % (
2161 code.globalstate.get_py_string_const(
2164 code.error_goto_if_null(temp, self.pos)))
2165 code.put_gotref(temp)
2166 code.putln(
2168 env.module_cname, temp, code.error_goto(self.pos)))
2169 code.put_decref_clear(temp, py_object_type)
2170 code.funcstate.release_temp(temp)
2180 code.globalstate.use_utility_code(UtilityCode.load(
2182 code.putln(code.error_goto_if_neg(
2185 code.globalstate.get_py_string_const(
2193 code.putln("#if PY_MAJOR_VERSION >= 3")
2194 code.putln("{")
2195 code.putln("PyObject *modules = PyImport_GetModuleDict(); %s" %
2196 code.error_goto_if_null("modules", self.pos))
2197 code.putln('if (!PyDict_GetItemString(modules, "%s")) {' % fq_module_name)
2198 code.putln(code.error_goto_if_neg('PyDict_SetItemString(modules, "%s", %s)' % (
2200 code.putln("}")
2201 code.putln("}")
2202 code.putln("#endif")
2204 def generate_module_cleanup_func(self, env, code):
2208 code.putln('static void %s(CYTHON_UNUSED PyObject *self) {' %
2211 code.putln("/*--- Global cleanup code ---*/")
2217 code.put_xdecref_clear(
2221 code.putln("__Pyx_CleanupGlobals();")
2223 code.putln("/*--- Type import cleanup code ---*/")
2225 code.put_xdecref_clear(
2230 code.putln("/*--- Builtin cleanup code ---*/")
2232 code.put_xdecref_clear(
2236 code.putln("/*--- Intern cleanup code ---*/")
2237 code.put_decref_clear(Naming.empty_tuple,
2249 code.putln("while (%s > 0) {" % freecount_name)
2250 code.putln("PyObject* o = (PyObject*)%s[--%s];" % (
2252 code.putln("(*Py_TYPE(o)->tp_free)(o);")
2253 code.putln("}")
2255 # code.put_decref_clear(entry.cname,
2260 # code.put_decref_clear(entry.pystring_cname,
2265 # code.putln("Py_DECREF(%s); %s = 0;" % (
2266 # code.entry_as_pyobject(entry), entry.cname))
2267 code.putln('#if CYTHON_COMPILING_IN_PYPY')
2268 code.putln('Py_CLEAR(%s);' % Naming.builtins_cname)
2269 code.putln('#endif')
2270 code.put_decref_clear(env.module_dict_cname, py_object_type,
2273 def generate_main_method(self, env, code):
2279 code.globalstate.use_utility_code(
2286 def generate_pymoduledef_struct(self, env, code):
2288 doc = "__Pyx_DOCSTR(%s)" % code.get_string_const(env.doc)
2296 code.putln("")
2297 code.putln("#if PY_MAJOR_VERSION >= 3")
2298 code.putln("static struct PyModuleDef %s = {" % Naming.pymoduledef_cname)
2299 code.putln("#if PY_VERSION_HEX < 0x03020000")
2301 code.putln(" { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },")
2302 code.putln("#else")
2303 code.putln(" PyModuleDef_HEAD_INIT,")
2304 code.putln("#endif")
2305 code.putln(' __Pyx_NAMESTR("%s"),' % env.module_name)
2306 code.putln(" %s, /* m_doc */" % doc)
2307 code.putln(" -1, /* m_size */")
2308 code.putln(" %s /* m_methods */," % env.method_table_cname)
2309 code.putln(" NULL, /* m_reload */")
2310 code.putln(" NULL, /* m_traverse */")
2311 code.putln(" NULL, /* m_clear */")
2312 code.putln(" %s /* m_free */" % cleanup_func)
2313 code.putln("};")
2314 code.putln("#endif")
2316 def generate_module_creation_code(self, env, code):
2317 # Generate code to create the module object and
2320 doc = "__Pyx_DOCSTR(%s)" % code.get_string_const(env.doc)
2323 code.putln("#if PY_MAJOR_VERSION < 3")
2324 code.putln(
2331 code.putln("#else")
2332 code.putln(
2336 code.putln("#endif")
2337 code.putln(code.error_goto_if_null(env.module_cname, self.pos))
2338 code.putln(
2341 code.error_goto_if_null(env.module_dict_cname, self.pos)))
2342 code.put_incref(env.module_dict_cname, py_object_type, nanny=False)
2344 code.putln(
2347 code.error_goto_if_null(Naming.builtins_cname, self.pos)))
2348 code.putln('#if CYTHON_COMPILING_IN_PYPY')
2349 code.putln('Py_INCREF(%s);' % Naming.builtins_cname)
2350 code.putln('#endif')
2351 code.putln(
2355 code.error_goto(self.pos)))
2357 code.putln(
2361 code.error_goto_if_null(Naming.preimport_cname, self.pos)))
2363 def generate_global_init_code(self, env, code):
2364 # Generate code to initialise global PyObject *
2369 entry.type.global_init_code(entry, code)
2371 def generate_c_variable_export_code(self, env, code):
2372 # Generate code to create PyCFunction wrappers for exported C functions.
2383 name = code.intern_identifier(entry.name)
2384 code.putln('if (__Pyx_ExportVoidPtr(%s, (void *)&%s, "%s") < 0) %s' % (
2386 code.error_goto(self.pos)))
2388 def generate_c_function_export_code(self, env, code):
2389 # Generate code to create PyCFunction wrappers for exported C functions.
2401 code.putln('if (__Pyx_ExportFunction("%s", (void (*)(void))%s, "%s") < 0) %s' % (
2405 code.error_goto(self.pos)))
2407 def generate_type_import_code_for_module(self, module, env, code):
2408 # Generate type import code for all exported extension types in
2413 self.generate_type_import_code(env, entry.type, entry.pos, code)
2427 def generate_c_variable_import_code_for_module(self, module, env, code):
2428 # Generate import code for all exported C functions in a cimported module.
2438 temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
2439 code.putln(
2444 code.error_goto(self.pos)))
2451 code.putln(
2454 code.error_goto(self.pos)))
2455 code.putln("Py_DECREF(%s); %s = 0;" % (temp, temp))
2457 def generate_c_function_import_code_for_module(self, module, env, code):
2458 # Generate import code for all exported C functions in a cimported module.
2468 temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
2469 code.putln(
2474 code.error_goto(self.pos)))
2476 code.putln(
2482 code.error_goto(self.pos)))
2483 code.putln("Py_DECREF(%s); %s = 0;" % (temp, temp))
2485 def generate_type_init_code(self, env, code):
2486 # Generate type import code for extern extension types
2487 # and type ready code for non-extern ones.
2490 self.generate_type_import_code(env, entry.type, entry.pos, code)
2492 self.generate_base_type_import_code(env, entry, code)
2493 self.generate_exttype_vtable_init_code(entry, code)
2494 self.generate_type_ready_code(env, entry, code)
2495 self.generate_typeptr_assignment_code(entry, code)
2497 def generate_base_type_import_code(self, env, entry, code):
2501 self.generate_type_import_code(env, base_type, self.pos, code)
2503 def generate_type_import_code(self, env, type, pos, code):
2504 # If not already done, generate code to import the typeobject of an
2510 self.generate_type_import_call(type, code,
2511 code.error_goto_if_null(type.typeptr_cname, pos))
2513 code.globalstate.use_utility_code(
2515 code.putln("%s = (struct %s*)__Pyx_GetVtable(%s->tp_dict); %s" % (
2519 code.error_goto_if_null(type.vtabptr_cname, pos)))
2524 def generate_type_import_call(self, type, code, error_code):
2542 code.put('%s = __Pyx_ImportType(%s,' % (
2547 code.putln("") # start in new line
2548 code.putln("#if %s" % condition)
2549 code.putln('"%s",' % replacement)
2550 code.putln("#else")
2551 code.putln('"%s",' % type.name)
2552 code.putln("#endif")
2554 code.put(' "%s", ' % type.name)
2558 code.putln("") # start in new line
2559 code.putln("#if CYTHON_COMPILING_IN_PYPY")
2560 code.putln('sizeof(%s),' % objstruct)
2561 code.putln("#else")
2562 code.putln('sizeof(%s),' % sizeof_objstruct)
2563 code.putln("#endif")
2565 code.put('sizeof(%s), ' % objstruct)
2567 code.putln('%i); %s' % (
2571 def generate_type_ready_code(self, env, entry, code):
2580 slot.generate_dynamic_init_code(scope, code)
2581 code.putln(
2584 code.error_goto(entry.pos)))
2587 code.putln("%s.tp_print = 0;" % typeobj_cname)
2599 code.putln(preprocessor_guard)
2600 code.putln('#if CYTHON_COMPILING_IN_CPYTHON')
2601 code.putln("{")
2602 code.putln(
2606 code.error_goto_if_null('wrapper', entry.pos)))
2607 code.putln(
2609 code.putln(
2612 code.putln(
2614 code.putln(
2617 code.putln("}")
2618 code.putln("}")
2619 code.putln('#endif')
2621 code.putln('#endif')
2623 code.putln(
2627 code.error_goto(entry.pos)))
2628 code.globalstate.use_utility_code(
2634 code.putln(
2639 code.error_goto(entry.pos)))
2648 code.putln("if (%s == 0) %s = offsetof(%s, %s);" % (
2656 def generate_exttype_vtable_init_code(self, entry, code):
2657 # Generate code to initialise the C method table of an
2661 code.putln(
2666 code.putln(
2678 code.putln(
2685 def generate_typeptr_assignment_code(self, entry, code):
2686 # Generate code to initialise the typeptr of an extension
2690 code.putln(
2694 def generate_cfunction_declaration(entry, env, code, definition):
2719 modifiers = code.build_function_modifiers(entry.func_modifiers)
2720 code.putln("%s %s%s; /*proto*/" % (
2727 # Runtime support code