1 #

2 # Pyrex - Module parse tree node

3 #

4

5 import os, time

6 from PyrexTypes import CPtrType

7 import Future

8

9 try:

10 set

11 except NameError: # Python 2.3

12 from sets import Set as set

13

14 import Annotate

15 import Code

16 import Naming

17 import Nodes

18 import Options

19 import PyrexTypes

20 import TypeSlots

21 import Version

22 import DebugFlags

23

24 from Errors import error, warning

25 from PyrexTypes import py_object_type

26 from Cython.Utils import open_new_file, replace_suffix

27 from Code import UtilityCode

28 from StringEncoding import escape_byte_string, EncodedString

29

30

31 def check_c_declarations_pxd(module_node):

32 module_node.scope.check_c_classes_pxd()

33 return module_node

34

35 def check_c_declarations(module_node):

36 module_node.scope.check_c_classes()

37 module_node.scope.check_c_functions()

38 return module_node

39

40 class ModuleNode(Nodes.Node, Nodes.BlockNode):

41 # doc string or None

42 # body StatListNode

43 #

44 # referenced_modules [ModuleScope]

45 # full_module_name string

46 #

47 # scope The module scope.

48 # compilation_source A CompilationSource (see Main)

49 # directives Top-level compiler directives

50

51 child_attrs = ["body"]

52 directives = None

53

54 def analyse_declarations(self, env):

55 if Options.embed_pos_in_docstring:

56 env.doc = EncodedString(u'File: %s (starting at line %s)' % Nodes.relative_position(self.pos))

57 if not self.doc is None:

58 env.doc = EncodedString(env.doc + u'\n' + self.doc)

59 env.doc.encoding = self.doc.encoding

60 else:

61 env.doc = self.doc

62 env.directives = self.directives

63 self.body.analyse_declarations(env)

64

65 def process_implementation(self, options, result):

66 env = self.scope

67 env.return_type = PyrexTypes.c_void_type

68 self.referenced_modules = []

69 self.find_referenced_modules(env, self.referenced_modules, {})

70 if options.recursive:

71 self.generate_dep_file(env, result)

72 self.generate_c_code(env, options, result)

73 self.generate_h_code(env, options, result)

74 self.generate_api_code(env, result)

75

76 def has_imported_c_functions(self):

77 for module in self.referenced_modules:

78 for entry in module.cfunc_entries:

79 if entry.defined_in_pxd:

80 return 1

81 return 0

82

83 def generate_dep_file(self, env, result):

84 modules = self.referenced_modules

85 if len(modules) > 1 or env.included_files:

86 dep_file = replace_suffix(result.c_file, ".dep")

87 f = open(dep_file, "w")

88 try:

89 for module in modules:

90 if module is not env:

91 f.write("cimport %s\n" % module.qualified_name)

92 for path in module.included_files:

93 f.write("include %s\n" % path)

94 finally:

95 f.close()

96

97 def generate_h_code(self, env, options, result):

98 def h_entries(entries, pxd = 0):

99 return [entry for entry in entries

100 if entry.visibility == 'public' or pxd and entry.defined_in_pxd]

101 h_types = h_entries(env.type_entries)

102 h_vars = h_entries(env.var_entries)

103 h_funcs = h_entries(env.cfunc_entries)

104 h_extension_types = h_entries(env.c_class_entries)

105 if h_types or h_vars or h_funcs or h_extension_types:

106 result.h_file = replace_suffix(result.c_file, ".h")

107 h_code = Code.CCodeWriter()

108 Code.GlobalState(h_code)

109 if options.generate_pxi:

110 result.i_file = replace_suffix(result.c_file, ".pxi")

111 i_code = Code.PyrexCodeWriter(result.i_file)

112 else:

113 i_code = None

114 guard = Naming.h_guard_prefix + env.qualified_name.replace(".", "__")

115 h_code.put_h_guard(guard)

116 self.generate_extern_c_macro_definition(h_code)

117 self.generate_type_header_code(h_types, h_code)

118 h_code.putln("")

119 h_code.putln("#ifndef %s" % Naming.api_guard_prefix + self.api_name(env))

120 if h_vars:

121 h_code.putln("")

122 for entry in h_vars:

123 self.generate_public_declaration(entry, h_code, i_code)

124 if h_funcs:

125 h_code.putln("")

126 for entry in h_funcs:

127 self.generate_public_declaration(entry, h_code, i_code)

128 if h_extension_types:

129 h_code.putln("")

130 for entry in h_extension_types:

131 self.generate_cclass_header_code(entry.type, h_code)

132 if i_code:

133 self.generate_cclass_include_code(entry.type, i_code)

134 h_code.putln("")

135 h_code.putln("#endif")

136 h_code.putln("")

137 h_code.putln("PyMODINIT_FUNC init%s(void);" % env.module_name)

138 h_code.putln("")

139 h_code.putln("#endif")

140

141 h_code.copyto(open_new_file(result.h_file))

142

143 def generate_public_declaration(self, entry, h_code, i_code):

144 h_code.putln("%s %s;" % (

145 Naming.extern_c_macro,

146 entry.type.declaration_code(

147 entry.cname, dll_linkage = "DL_IMPORT")))

148 if i_code:

149 i_code.putln("cdef extern %s" %

150 entry.type.declaration_code(entry.cname, pyrex = 1))

151

152 def api_name(self, env):

153 return env.qualified_name.replace(".", "__")

154

155 def generate_api_code(self, env, result):

156 api_funcs = []

157 public_extension_types = []

158 has_api_extension_types = 0

159 for entry in env.cfunc_entries:

160 if entry.api:

161 api_funcs.append(entry)

162 for entry in env.c_class_entries:

163 if entry.visibility == 'public':

164 public_extension_types.append(entry)

165 if entry.api:

166 has_api_extension_types = 1

167 if api_funcs or has_api_extension_types:

168 result.api_file = replace_suffix(result.c_file, "_api.h")

169 h_code = Code.CCodeWriter()

170 Code.GlobalState(h_code)

171 name = self.api_name(env)

172 guard = Naming.api_guard_prefix + name

173 h_code.put_h_guard(guard)

174 h_code.putln('#include "Python.h"')

175 if result.h_file:

176 h_code.putln('#include "%s"' % os.path.basename(result.h_file))

177 for entry in public_extension_types:

178 type = entry.type

179 h_code.putln("")

180 h_code.putln("static PyTypeObject *%s;" % type.typeptr_cname)

181 h_code.putln("#define %s (*%s)" % (

182 type.typeobj_cname, type.typeptr_cname))

183 if api_funcs:

184 h_code.putln("")

185 for entry in api_funcs:

186 type = CPtrType(entry.type)

187 h_code.putln("static %s;" % type.declaration_code(entry.cname))

188 h_code.putln("")

189 h_code.put_h_guard(Naming.api_func_guard + "import_module")

190 h_code.put(import_module_utility_code.impl)

191 h_code.putln("")

192 h_code.putln("#endif")

193 if api_funcs:

194 h_code.putln("")

195 h_code.put(function_import_utility_code.impl)

196 if public_extension_types:

197 h_code.putln("")

198 h_code.put(type_import_utility_code.impl)

199 h_code.putln("")

200 h_code.putln("static int import_%s(void) {" % name)

201 h_code.putln("PyObject *module = 0;")

202 h_code.putln('module = __Pyx_ImportModule("%s");' % env.qualified_name)

203 h_code.putln("if (!module) goto bad;")

204 for entry in api_funcs:

205 sig = entry.type.signature_string()

206 h_code.putln(

207 'if (__Pyx_ImportFunction(module, "%s", (void (**)(void))&%s, "%s") < 0) goto bad;' % (

208 entry.name,

209 entry.cname,

210 sig))

211 h_code.putln("Py_DECREF(module); module = 0;")

212 for entry in public_extension_types:

213 self.generate_type_import_call(

214 entry.type, h_code,

215 "if (!%s) goto bad;" % entry.type.typeptr_cname)

216 h_code.putln("return 0;")

217 h_code.putln("bad:")

218 h_code.putln("Py_XDECREF(module);")

219 h_code.putln("return -1;")

220 h_code.putln("}")

221 h_code.putln("")

222 h_code.putln("#endif")

223

224 h_code.copyto(open_new_file(result.api_file))

225

226 def generate_cclass_header_code(self, type, h_code):

227 h_code.putln("%s DL_IMPORT(PyTypeObject) %s;" % (

228 Naming.extern_c_macro,

229 type.typeobj_cname))

230

231 def generate_cclass_include_code(self, type, i_code):

232 i_code.putln("cdef extern class %s.%s:" % (

233 type.module_name, type.name))

234 i_code.indent()

235 var_entries = type.scope.var_entries

236 if var_entries:

237 for entry in var_entries:

238 i_code.putln("cdef %s" %

239 entry.type.declaration_code(entry.cname, pyrex = 1))

240 else:

241 i_code.putln("pass")

242 i_code.dedent()

243

244 def generate_c_code(self, env, options, result):

245 modules = self.referenced_modules

246

247 if Options.annotate or options.annotate:

248 emit_linenums = False

249 rootwriter = Annotate.AnnotationCCodeWriter()

250 else:

251 emit_linenums = options.emit_linenums

252 rootwriter = Code.CCodeWriter(emit_linenums=emit_linenums)

253 globalstate = Code.GlobalState(rootwriter, emit_linenums)

254 globalstate.initialize_main_c_code()

255 h_code = globalstate['h_code']

256

257 self.generate_module_preamble(env, modules, h_code)

258

259 globalstate.module_pos = self.pos

260 globalstate.directives = self.directives

261

262 globalstate.use_utility_code(refnanny_utility_code)

263

264 code = globalstate['before_global_var']

265 code.putln('#define __Pyx_MODULE_NAME "%s"' % self.full_module_name)

266 code.putln("int %s%s = 0;" % (Naming.module_is_main, self.full_module_name.replace('.', '__')))

267 code.putln("")

268 code.putln("/* Implementation of %s */" % env.qualified_name)

269

270 code = globalstate['all_the_rest']

271

272 self.generate_cached_builtins_decls(env, code)

273 # generate lambda function definitions

274 for node in env.lambda_defs:

275 node.generate_function_definitions(env, code)

276 # generate normal function definitions

277 self.body.generate_function_definitions(env, code)

278 code.mark_pos(None)

279 self.generate_typeobj_definitions(env, code)

280 self.generate_method_table(env, code)

281 if env.has_import_star:

282 self.generate_import_star(env, code)

283 self.generate_pymoduledef_struct(env, code)

284

285 # init_globals is inserted before this

286 self.generate_module_init_func(modules[:-1], env, globalstate['init_module'])

287 self.generate_module_cleanup_func(env, globalstate['cleanup_module'])

288 if Options.embed:

289 self.generate_main_method(env, globalstate['main_method'])

290 self.generate_filename_table(globalstate['filename_table'])

291

292 self.generate_declarations_for_modules(env, modules, globalstate)

293 h_code.write('\n')

294

295 for utilcode in env.utility_code_list:

296 globalstate.use_utility_code(utilcode)

297 globalstate.finalize_main_c_code()

298

299 f = open_new_file(result.c_file)

300 rootwriter.copyto(f)

301 f.close()

302 result.c_file_generated = 1

303 if Options.annotate or options.annotate:

304 self.annotate(rootwriter)

305 rootwriter.save_annotation(result.main_source_file, result.c_file)

306

307 def find_referenced_modules(self, env, module_list, modules_seen):

308 if env not in modules_seen:

309 modules_seen[env] = 1

310 for imported_module in env.cimported_modules:

311 self.find_referenced_modules(imported_module, module_list, modules_seen)

312 module_list.append(env)

313

314 def sort_types_by_inheritance(self, type_dict, getkey):

315 # copy the types into a list moving each parent type before

316 # its first child

317 type_items = type_dict.items()

318 type_list = []

319 for i, item in enumerate(type_items):

320 key, new_entry = item

321

322 # collect all base classes to check for children

323 hierarchy = set()

324 base = new_entry

325 while base:

326 base_type = base.type.base_type

327 if not base_type:

328 break

329 base_key = getkey(base_type)

330 hierarchy.add(base_key)

331 base = type_dict.get(base_key)

332 new_entry.base_keys = hierarchy

333

334 # find the first (sub-)subclass and insert before that

335 for j in range(i):

336 entry = type_list[j]

337 if key in entry.base_keys:

338 type_list.insert(j, new_entry)

339 break

340 else:

341 type_list.append(new_entry)

342 return type_list

343

344 def sort_type_hierarchy(self, module_list, env):

345 vtab_dict = {}

346 vtabslot_dict = {}

347 for module in module_list:

348 for entry in module.c_class_entries:

349 if not entry.in_cinclude:

350 type = entry.type

351 if type.vtabstruct_cname:

352 vtab_dict[type.vtabstruct_cname] = entry

353 all_defined_here = module is env

354 for entry in module.type_entries:

355 if all_defined_here or entry.defined_in_pxd:

356 type = entry.type

357 if type.is_extension_type and not entry.in_cinclude:

358 type = entry.type

359 vtabslot_dict[type.objstruct_cname] = entry

360

361 def vtabstruct_cname(entry_type):

362 return entry_type.vtabstruct_cname

363 vtab_list = self.sort_types_by_inheritance(

364 vtab_dict, vtabstruct_cname)

365

366 def objstruct_cname(entry_type):

367 return entry_type.objstruct_cname

368 vtabslot_list = self.sort_types_by_inheritance(

369 vtabslot_dict, objstruct_cname)

370

371 return (vtab_list, vtabslot_list)

372

373 def generate_type_definitions(self, env, modules, vtab_list, vtabslot_list, code):

374 vtabslot_entries = set(vtabslot_list)

375 for module in modules:

376 definition = module is env

377 if definition:

378 type_entries = module.type_entries

379 else:

380 type_entries = []

381 for entry in module.type_entries:

382 if entry.defined_in_pxd:

383 type_entries.append(entry)

384 for entry in type_entries:

385 if not entry.in_cinclude:

386 #print "generate_type_header_code:", entry.name, repr(entry.type) ###

387 type = entry.type

388 if type.is_typedef: # Must test this first!

389 self.generate_typedef(entry, code)

390 elif type.is_struct_or_union:

391 self.generate_struct_union_definition(entry, code)

392 elif type.is_enum:

393 self.generate_enum_definition(entry, code)

394 elif type.is_extension_type and entry not in vtabslot_entries:

395 self.generate_objstruct_definition(type, code)

396 for entry in vtabslot_list:

397 self.generate_objstruct_definition(entry.type, code)

398 for entry in vtab_list:

399 self.generate_typeobject_predeclaration(entry, code)

400 self.generate_exttype_vtable_struct(entry, code)

401 self.generate_exttype_vtabptr_declaration(entry, code)

402

403 def generate_declarations_for_modules(self, env, modules, globalstate):

404 typecode = globalstate['type_declarations']

405 typecode.putln("")

406 typecode.putln("/* Type declarations */")

407 vtab_list, vtabslot_list = self.sort_type_hierarchy(modules, env)

408 self.generate_type_definitions(

409 env, modules, vtab_list, vtabslot_list, typecode)

410 modulecode = globalstate['module_declarations']

411 for module in modules:

412 defined_here = module is env

413 modulecode.putln("/* Module declarations from %s */" %

414 module.qualified_name)

415 self.generate_global_declarations(module, modulecode, defined_here)

416 self.generate_cfunction_predeclarations(module, modulecode, defined_here)

417

418 def generate_module_preamble(self, env, cimported_modules, code):

419 code.putln("/* Generated by Cython %s on %s */" % (

420 Version.version, time.asctime()))

421 code.putln("")

422 code.putln("#define PY_SSIZE_T_CLEAN")

423 for filename in env.python_include_files:

424 code.putln('#include "%s"' % filename)

425 code.putln("#ifndef Py_PYTHON_H")

426 code.putln(" #error Python headers needed to compile C extensions, please install development version of Python.")

427 code.putln("#else")

428 code.globalstate["end"].putln("#endif /* Py_PYTHON_H */")

429

430 code.put("""

431 #include <stddef.h> /* For offsetof */

432 #ifndef offsetof

433 #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )

434 #endif

435

436 #if !defined(WIN32) && !defined(MS_WINDOWS)

437 #ifndef __stdcall

438 #define __stdcall

439 #endif

440 #ifndef __cdecl

441 #define __cdecl

442 #endif

443 #ifndef __fastcall

444 #define __fastcall

445 #endif

446 #endif

447

448 #ifndef DL_IMPORT

449 #define DL_IMPORT(t) t

450 #endif

451 #ifndef DL_EXPORT

452 #define DL_EXPORT(t) t

453 #endif

454

455 #ifndef PY_LONG_LONG

456 #define PY_LONG_LONG LONG_LONG

457 #endif

458

459 #if PY_VERSION_HEX < 0x02040000

460 #define METH_COEXIST 0

461 #define PyDict_CheckExact(op) (Py_TYPE(op) == &PyDict_Type)

462 #define PyDict_Contains(d,o) PySequence_Contains(d,o)

463 #endif

464

465 #if PY_VERSION_HEX < 0x02050000

466 typedef int Py_ssize_t;

467 #define PY_SSIZE_T_MAX INT_MAX

468 #define PY_SSIZE_T_MIN INT_MIN

469 #define PY_FORMAT_SIZE_T \"\"

470 #define PyInt_FromSsize_t(z) PyInt_FromLong(z)

471 #define PyInt_AsSsize_t(o) PyInt_AsLong(o)

472 #define PyNumber_Index(o) PyNumber_Int(o)

473 #define PyIndex_Check(o) PyNumber_Check(o)

474 #define PyErr_WarnEx(category, message, stacklevel) PyErr_Warn(category, message)

475 #endif

476

477 #if PY_VERSION_HEX < 0x02060000

478 #define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)

479 #define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)

480 #define Py_SIZE(ob) (((PyVarObject*)(ob))->ob_size)

481 #define PyVarObject_HEAD_INIT(type, size) \\

482 PyObject_HEAD_INIT(type) size,

483 #define PyType_Modified(t)

484

485 typedef struct {

486 void *buf;

487 PyObject *obj;

488 Py_ssize_t len;

489 Py_ssize_t itemsize;

490 int readonly;

491 int ndim;

492 char *format;

493 Py_ssize_t *shape;

494 Py_ssize_t *strides;

495 Py_ssize_t *suboffsets;

496 void *internal;

497 } Py_buffer;

498

499 #define PyBUF_SIMPLE 0

500 #define PyBUF_WRITABLE 0x0001

501 #define PyBUF_FORMAT 0x0004

502 #define PyBUF_ND 0x0008

503 #define PyBUF_STRIDES (0x0010 | PyBUF_ND)

504 #define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)

505 #define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)

506 #define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)

507 #define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)

508

509 #endif

510

511 #if PY_MAJOR_VERSION < 3

512 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"

513 #else

514 #define __Pyx_BUILTIN_MODULE_NAME "builtins"

515 #endif

516

517 #if PY_MAJOR_VERSION >= 3

518 #define Py_TPFLAGS_CHECKTYPES 0

519 #define Py_TPFLAGS_HAVE_INDEX 0

520 #endif

521

522 #if (PY_VERSION_HEX < 0x02060000) || (PY_MAJOR_VERSION >= 3)

523 #define Py_TPFLAGS_HAVE_NEWBUFFER 0

524 #endif

525

526 #if PY_MAJOR_VERSION >= 3

527 #define PyBaseString_Type PyUnicode_Type

528 #define PyStringObject PyUnicodeObject

529 #define PyString_Type PyUnicode_Type

530 #define PyString_Check PyUnicode_Check

531 #define PyString_CheckExact PyUnicode_CheckExact

532 #endif

533

534 #if PY_VERSION_HEX < 0x02060000

535 #define PyBytesObject PyStringObject

536 #define PyBytes_Type PyString_Type

537 #define PyBytes_Check PyString_Check

538 #define PyBytes_CheckExact PyString_CheckExact

539 #define PyBytes_FromString PyString_FromString

540 #define PyBytes_FromStringAndSize PyString_FromStringAndSize

541 #define PyBytes_FromFormat PyString_FromFormat

542 #define PyBytes_DecodeEscape PyString_DecodeEscape

543 #define PyBytes_AsString PyString_AsString

544 #define PyBytes_AsStringAndSize PyString_AsStringAndSize

545 #define PyBytes_Size PyString_Size

546 #define PyBytes_AS_STRING PyString_AS_STRING

547 #define PyBytes_GET_SIZE PyString_GET_SIZE

548 #define PyBytes_Repr PyString_Repr

549 #define PyBytes_Concat PyString_Concat

550 #define PyBytes_ConcatAndDel PyString_ConcatAndDel

551 #define PySet_Check(obj) PyObject_TypeCheck(obj, &PySet_Type)

552 #define PyFrozenSet_Check(obj) PyObject_TypeCheck(obj, &PyFrozenSet_Type)

553 #endif

554

555 #ifndef PySet_CheckExact

556 # define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type)

557 #endif

558

559 #if PY_MAJOR_VERSION >= 3

560 #define PyInt_Type PyLong_Type

561 #define PyInt_Check(op) PyLong_Check(op)

562 #define PyInt_CheckExact(op) PyLong_CheckExact(op)

563 #define PyInt_FromString PyLong_FromString

564 #define PyInt_FromUnicode PyLong_FromUnicode

565 #define PyInt_FromLong PyLong_FromLong

566 #define PyInt_FromSize_t PyLong_FromSize_t

567 #define PyInt_FromSsize_t PyLong_FromSsize_t

568 #define PyInt_AsLong PyLong_AsLong

569 #define PyInt_AS_LONG PyLong_AS_LONG

570 #define PyInt_AsSsize_t PyLong_AsSsize_t

571 #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask

572 #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask

573 #endif

574

575 #if PY_MAJOR_VERSION >= 3

576 #define PyBoolObject PyLongObject

577 #endif

578

579 """)

580

581 code.put("""

582 #if PY_MAJOR_VERSION >= 3

583 #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)

584 #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)

585 #else

586 """)

587 if Future.division in env.context.future_directives:

588 code.putln(" #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)")

589 code.putln(" #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)")

590 else:

591 code.putln(" #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y)")

592 code.putln(" #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y)")

593 code.putln("#endif")

594

595 code.put("""

596 #if PY_MAJOR_VERSION >= 3

597 #define PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))

598 #endif

599

600 #if PY_VERSION_HEX < 0x02050000

601 #define __Pyx_GetAttrString(o,n) PyObject_GetAttrString((o),((char *)(n)))

602 #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),((char *)(n)),(a))

603 #define __Pyx_DelAttrString(o,n) PyObject_DelAttrString((o),((char *)(n)))

604 #else

605 #define __Pyx_GetAttrString(o,n) PyObject_GetAttrString((o),(n))

606 #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),(n),(a))

607 #define __Pyx_DelAttrString(o,n) PyObject_DelAttrString((o),(n))

608 #endif

609

610 #if PY_VERSION_HEX < 0x02050000

611 #define __Pyx_NAMESTR(n) ((char *)(n))

612 #define __Pyx_DOCSTR(n) ((char *)(n))

613 #else

614 #define __Pyx_NAMESTR(n) (n)

615 #define __Pyx_DOCSTR(n) (n)

616 #endif

617 """)

618

619 code.putln("")

620 self.generate_extern_c_macro_definition(code)

621 code.putln("")

622 code.putln("#if defined(WIN32) || defined(MS_WINDOWS)")

623 code.putln("#define _USE_MATH_DEFINES")

624 code.putln("#endif")

625 code.putln("#include <math.h>")

626 code.putln("#define %s" % Naming.api_guard_prefix + self.api_name(env))

627 self.generate_includes(env, cimported_modules, code)

628 if env.directives['ccomplex']:

629 code.putln("")

630 code.putln("#if !defined(CYTHON_CCOMPLEX)")

631 code.putln("#define CYTHON_CCOMPLEX 1")

632 code.putln("#endif")

633 code.putln("")

634 code.put(Nodes.utility_function_predeclarations)

635 code.put(PyrexTypes.type_conversion_predeclarations)

636 code.put(Nodes.branch_prediction_macros)

637 code.putln('')

638 code.putln('static PyObject *%s;' % env.module_cname)

639 code.putln('static PyObject *%s;' % Naming.builtins_cname)

640 code.putln('static PyObject *%s;' % Naming.empty_tuple)

641 code.putln('static PyObject *%s;' % Naming.empty_bytes)

642 if Options.pre_import is not None:

643 code.putln('static PyObject *%s;' % Naming.preimport_cname)

644 code.putln('static int %s;' % Naming.lineno_cname)

645 code.putln('static int %s = 0;' % Naming.clineno_cname)

646 code.putln('static const char * %s= %s;' % (Naming.cfilenm_cname, Naming.file_c_macro))

647 code.putln('static const char *%s;' % Naming.filename_cname)

648

649 # XXX this is a mess

650 for utility_code in PyrexTypes.c_int_from_py_function.specialize_list:

651 env.use_utility_code(utility_code)

652 for utility_code in PyrexTypes.c_long_from_py_function.specialize_list:

653 env.use_utility_code(utility_code)

654

655 def generate_extern_c_macro_definition(self, code):

656 name = Naming.extern_c_macro

657 code.putln("#ifdef __cplusplus")

658 code.putln('#define %s extern "C"' % name)

659 code.putln("#else")

660 code.putln("#define %s extern" % name)

661 code.putln("#endif")

662

663 def generate_includes(self, env, cimported_modules, code):

664 includes = []

665 for filename in env.include_files:

666 byte_decoded_filenname = str(filename)

667 if byte_decoded_filenname[0] == '<' and byte_decoded_filenname[-1] == '>':

668 code.putln('#include %s' % byte_decoded_filenname)

669 else:

670 code.putln('#include "%s"' % byte_decoded_filenname)

671

672 def generate_filename_table(self, code):

673 code.putln("")

674 code.putln("static const char *%s[] = {" % Naming.filetable_cname)

675 if code.globalstate.filename_list:

676 for source_desc in code.globalstate.filename_list:

677 filename = os.path.basename(source_desc.get_filenametable_entry())

678 escaped_filename = filename.replace("\\", "\\\\").replace('"', r'\"')

679 code.putln('"%s",' % escaped_filename)

680 else:

681 # Some C compilers don't like an empty array

682 code.putln("0")

683 code.putln("};")

684

685 def generate_type_predeclarations(self, env, code):

686 pass

687

688 def generate_type_header_code(self, type_entries, code):

689 # Generate definitions of structs/unions/enums/typedefs/objstructs.

690 #self.generate_gcc33_hack(env, code) # Is this still needed?

691 #for entry in env.type_entries:

692 for entry in type_entries:

693 if not entry.in_cinclude:

694 #print "generate_type_header_code:", entry.name, repr(entry.type) ###

695 type = entry.type

696 if type.is_typedef: # Must test this first!

697 self.generate_typedef(entry, code)

698 elif type.is_struct_or_union:

699 self.generate_struct_union_definition(entry, code)

700 elif type.is_enum:

701 self.generate_enum_definition(entry, code)

702 elif type.is_extension_type:

703 self.generate_objstruct_definition(type, code)

704

705 def generate_gcc33_hack(self, env, code):

706 # Workaround for spurious warning generation in gcc 3.3

707 code.putln("")

708 for entry in env.c_class_entries:

709 type = entry.type

710 if not type.typedef_flag:

711 name = type.objstruct_cname

712 if name.startswith("__pyx_"):

713 tail = name[6:]

714 else:

715 tail = name

716 code.putln("typedef struct %s __pyx_gcc33_%s;" % (

717 name, tail))

718

719 def generate_typedef(self, entry, code):

720 base_type = entry.type.typedef_base_type

721 if base_type.is_numeric:

722 writer = code.globalstate['numeric_typedefs']

723 else:

724 writer = code

725 writer.putln("")

726 writer.putln("typedef %s;" % base_type.declaration_code(entry.cname))

727

728 def sue_header_footer(self, type, kind, name):

729 if type.typedef_flag:

730 header = "typedef %s {" % kind

731 footer = "} %s;" % name

732 else:

733 header = "%s %s {" % (kind, name)

734 footer = "};"

735 return header, footer

736

737 def generate_struct_union_definition(self, entry, code):

738 code.mark_pos(entry.pos)

739 type = entry.type

740 scope = type.scope

741 if scope:

742 kind = type.kind

743 packed = type.is_struct and type.packed

744 if packed:

745 kind = "%s %s" % (type.kind, "__Pyx_PACKED")

746 code.globalstate.use_utility_code(packed_struct_utility_code)

747 header, footer = \

748 self.sue_header_footer(type, kind, type.cname)

749 code.putln("")

750 if packed:

751 code.putln("#if !defined(__GNUC__)")

752 code.putln("#pragma pack(push, 1)")

753 code.putln("#endif")

754 code.putln(header)

755 var_entries = scope.var_entries

756 if not var_entries:

757 error(entry.pos,

758 "Empty struct or union definition not allowed outside a"

759 " 'cdef extern from' block")

760 for attr in var_entries:

761 code.putln(

762 "%s;" %

763 attr.type.declaration_code(attr.cname))

764 code.putln(footer)

765 if packed:

766 code.putln("#if !defined(__GNUC__)")

767 code.putln("#pragma pack(pop)")

768 code.putln("#endif")

769

770 def generate_enum_definition(self, entry, code):

771 code.mark_pos(entry.pos)

772 type = entry.type

773 name = entry.cname or entry.name or ""

774 header, footer = \

775 self.sue_header_footer(type, "enum", name)

776 code.putln("")

777 code.putln(header)

778 enum_values = entry.enum_values

779 if not enum_values:

780 error(entry.pos,

781 "Empty enum definition not allowed outside a"

782 " 'cdef extern from' block")

783 else:

784 last_entry = enum_values[-1]

785 # this does not really generate code, just builds the result value

786 for value_entry in enum_values:

787 if value_entry.value_node is not None:

788 value_entry.value_node.generate_evaluation_code(code)

789

790 for value_entry in enum_values:

791 if value_entry.value_node is None:

792 value_code = value_entry.cname

793 else:

794 value_code = ("%s = %s" % (

795 value_entry.cname,

796 value_entry.value_node.result()))

797 if value_entry is not last_entry:

798 value_code += ","

799 code.putln(value_code)

800 code.putln(footer)

801

802 def generate_typeobject_predeclaration(self, entry, code):

803 code.putln("")

804 name = entry.type.typeobj_cname

805 if name:

806 if entry.visibility == 'extern' and not entry.in_cinclude:

807 code.putln("%s DL_IMPORT(PyTypeObject) %s;" % (

808 Naming.extern_c_macro,

809 name))

810 elif entry.visibility == 'public':

811 #code.putln("DL_EXPORT(PyTypeObject) %s;" % name)

812 code.putln("%s DL_EXPORT(PyTypeObject) %s;" % (

813 Naming.extern_c_macro,

814 name))

815 # ??? Do we really need the rest of this? ???

816 #else:

817 # code.putln("staticforward PyTypeObject %s;" % name)

818

819 def generate_exttype_vtable_struct(self, entry, code):

820 code.mark_pos(entry.pos)

821 # Generate struct declaration for an extension type's vtable.

822 type = entry.type

823 scope = type.scope

824 if type.vtabstruct_cname:

825 code.putln("")

826 code.putln(

827 "struct %s {" %

828 type.vtabstruct_cname)

829 if type.base_type and type.base_type.vtabstruct_cname:

830 code.putln("struct %s %s;" % (

831 type.base_type.vtabstruct_cname,

832 Naming.obj_base_cname))

833 for method_entry in scope.cfunc_entries:

834 if not method_entry.is_inherited:

835 code.putln(

836 "%s;" % method_entry.type.declaration_code("(*%s)" % method_entry.name))

837 code.putln(

838 "};")

839

840 def generate_exttype_vtabptr_declaration(self, entry, code):

841 code.mark_pos(entry.pos)

842 # Generate declaration of pointer to an extension type's vtable.

843 type = entry.type

844 if type.vtabptr_cname:

845 code.putln("static struct %s *%s;" % (

846 type.vtabstruct_cname,

847 type.vtabptr_cname))

848

849 def generate_objstruct_definition(self, type, code):

850 code.mark_pos(type.pos)

851 # Generate object struct definition for an

852 # extension type.

853 if not type.scope:

854 return # Forward declared but never defined

855 header, footer = \

856 self.sue_header_footer(type, "struct", type.objstruct_cname)

857 code.putln("")

858 code.putln(header)

859 base_type = type.base_type

860 if base_type:

861 code.putln(

862 "%s%s %s;" % (

863 ("struct ", "")[base_type.typedef_flag],

864 base_type.objstruct_cname,

865 Naming.obj_base_cname))

866 else:

867 code.putln(

868 "PyObject_HEAD")

869 if type.vtabslot_cname and not (type.base_type and type.base_type.vtabslot_cname):

870 code.putln(

871 "struct %s *%s;" % (

872 type.vtabstruct_cname,

873 type.vtabslot_cname))

874 for attr in type.scope.var_entries:

875 code.putln(

876 "%s;" %

877 attr.type.declaration_code(attr.cname))

878 code.putln(footer)

879 if type.objtypedef_cname is not None:

880 # Only for exposing public typedef name.

881 code.putln("typedef struct %s %s;" % (type.objstruct_cname, type.objtypedef_cname))

882

883 def generate_global_declarations(self, env, code, definition):

884 code.putln("")

885 for entry in env.c_class_entries:

886 if definition or entry.defined_in_pxd:

887 code.putln("static PyTypeObject *%s = 0;" %

888 entry.type.typeptr_cname)

889 code.put_var_declarations(env.var_entries, static = 1,

890 dll_linkage = "DL_EXPORT", definition = definition)

891

892 def generate_cfunction_predeclarations(self, env, code, definition):

893 for entry in env.cfunc_entries:

894 if entry.inline_func_in_pxd or (not entry.in_cinclude and (definition

895 or entry.defined_in_pxd or entry.visibility == 'extern')):

896 if entry.visibility in ('public', 'extern'):

897 dll_linkage = "DL_EXPORT"

898 else:

899 dll_linkage = None

900 type = entry.type

901 if not definition and entry.defined_in_pxd:

902 type = CPtrType(type)

903 header = type.declaration_code(entry.cname,

904 dll_linkage = dll_linkage)

905 if entry.visibility == 'private':

906 storage_class = "static "

907 elif entry.visibility == 'public':

908 storage_class = ""

909 else:

910 storage_class = "%s " % Naming.extern_c_macro

911 if entry.func_modifiers:

912 modifiers = '%s ' % ' '.join([

913 modifier.upper() for modifier in entry.func_modifiers])

914 else:

915 modifiers = ''

916 code.putln("%s%s%s; /*proto*/" % (

917 storage_class,

918 modifiers,

919 header))

920

921 def generate_typeobj_definitions(self, env, code):

922 full_module_name = env.qualified_name

923 for entry in env.c_class_entries:

924 #print "generate_typeobj_definitions:", entry.name

925 #print "...visibility =", entry.visibility

926 if entry.visibility != 'extern':

927 type = entry.type

928 scope = type.scope

929 if scope: # could be None if there was an error

930 self.generate_exttype_vtable(scope, code)

931 self.generate_new_function(scope, code)

932 self.generate_dealloc_function(scope, code)

933 if scope.needs_gc():

934 self.generate_traverse_function(scope, code)

935 self.generate_clear_function(scope, code)

936 if scope.defines_any(["__getitem__"]):

937 self.generate_getitem_int_function(scope, code)

938 if scope.defines_any(["__setitem__", "__delitem__"]):

939 self.generate_ass_subscript_function(scope, code)

940 if scope.defines_any(["__getslice__", "__setslice__", "__delslice__"]):

941 warning(self.pos, "__getslice__, __setslice__, and __delslice__ are not supported by Python 3, use __getitem__, __setitem__, and __delitem__ instead", 1)

942 code.putln("#if PY_MAJOR_VERSION >= 3")

943 code.putln("#error __getslice__, __setslice__, and __delslice__ not supported in Python 3.")

944 code.putln("#endif")

945 if scope.defines_any(["__setslice__", "__delslice__"]):

946 self.generate_ass_slice_function(scope, code)

947 if scope.defines_any(["__getattr__","__getattribute__"]):

948 self.generate_getattro_function(scope, code)

949 if scope.defines_any(["__setattr__", "__delattr__"]):

950 self.generate_setattro_function(scope, code)

951 if scope.defines_any(["__get__"]):

952 self.generate_descr_get_function(scope, code)

953 if scope.defines_any(["__set__", "__delete__"]):

954 self.generate_descr_set_function(scope, code)

955 self.generate_property_accessors(scope, code)

956 self.generate_method_table(scope, code)

957 self.generate_getset_table(scope, code)

958 self.generate_typeobj_definition(full_module_name, entry, code)

959

960 def generate_exttype_vtable(self, scope, code):

961 # Generate the definition of an extension type's vtable.

962 type = scope.parent_type

963 if type.vtable_cname:

964 code.putln("static struct %s %s;" % (

965 type.vtabstruct_cname,

966 type.vtable_cname))

967

968 def generate_self_cast(self, scope, code):

969 type = scope.parent_type

970 code.putln(

971 "%s = (%s)o;" % (

972 type.declaration_code("p"),

973 type.declaration_code("")))

974

975 def generate_new_function(self, scope, code):

976 tp_slot = TypeSlots.ConstructorSlot("tp_new", '__new__')

977 slot_func = scope.mangle_internal("tp_new")

978 type = scope.parent_type

979 base_type = type.base_type

980 py_attrs = []

981 for entry in scope.var_entries:

982 if entry.type.is_pyobject:

983 py_attrs.append(entry)

984 need_self_cast = type.vtabslot_cname or py_attrs

985 code.putln("")

986 code.putln(

987 "static PyObject *%s(PyTypeObject *t, PyObject *a, PyObject *k) {"

988 % scope.mangle_internal("tp_new"))

989 if need_self_cast:

990 code.putln(

991 "%s;"

992 % scope.parent_type.declaration_code("p"))

993 if base_type:

994 tp_new = TypeSlots.get_base_slot_function(scope, tp_slot)

995 if tp_new is None:

996 tp_new = "%s->tp_new" % base_type.typeptr_cname

997 code.putln(

998 "PyObject *o = %s(t, a, k);" % tp_new)

999 else:

1000 code.putln(

1001 "PyObject *o = (*t->tp_alloc)(t, 0);")

1002 code.putln(

1003 "if (!o) return 0;")

1004 if need_self_cast:

1005 code.putln(

1006 "p = %s;"

1007 % type.cast_code("o"))

1008 #if need_self_cast:

1009 # self.generate_self_cast(scope, code)

1010 if type.vtabslot_cname:

1011 vtab_base_type = type

1012 while vtab_base_type.base_type and vtab_base_type.base_type.vtabstruct_cname:

1013 vtab_base_type = vtab_base_type.base_type

1014 if vtab_base_type is not type:

1015 struct_type_cast = "(struct %s*)" % vtab_base_type.vtabstruct_cname

1016 else:

1017 struct_type_cast = ""

1018 code.putln("p->%s = %s%s;" % (

1019 type.vtabslot_cname,

1020 struct_type_cast, type.vtabptr_cname))

1021 for entry in py_attrs:

1022 if scope.is_internal or entry.name == "__weakref__":

1023 # internal classes do not need None inits

1024 code.putln("p->%s = 0;" % entry.cname)

1025 else:

1026 code.put_init_var_to_py_none(entry, "p->%s", nanny=False)

1027 entry = scope.lookup_here("__new__")

1028 if entry and entry.is_special:

1029 if entry.trivial_signature:

1030 cinit_args = "o, %s, NULL" % Naming.empty_tuple

1031 else:

1032 cinit_args = "o, a, k"

1033 code.putln(

1034 "if (%s(%s) < 0) {" %

1035 (entry.func_cname, cinit_args))

1036 code.put_decref_clear("o", py_object_type, nanny=False);

1037 code.putln(

1038 "}")

1039 code.putln(

1040 "return o;")

1041 code.putln(

1042 "}")

1043

1044 def generate_dealloc_function(self, scope, code):

1045 tp_slot = TypeSlots.ConstructorSlot("tp_dealloc", '__dealloc__')

1046 slot_func = scope.mangle_internal("tp_dealloc")

1047 base_type = scope.parent_type.base_type

1048 if tp_slot.slot_code(scope) != slot_func:

1049 return # never used

1050 code.putln("")

1051 code.putln(

1052 "static void %s(PyObject *o) {"

1053 % scope.mangle_internal("tp_dealloc"))

1054 py_attrs = []

1055 weakref_slot = scope.lookup_here("__weakref__")

1056 for entry in scope.var_entries:

1057 if entry.type.is_pyobject and entry is not weakref_slot:

1058 py_attrs.append(entry)

1059 if py_attrs or weakref_slot in scope.var_entries:

1060 self.generate_self_cast(scope, code)

1061 self.generate_usr_dealloc_call(scope, code)

1062 if weakref_slot in scope.var_entries:

1063 code.putln("if (p->__weakref__) PyObject_ClearWeakRefs(o);")

1064 for entry in py_attrs:

1065 code.put_xdecref("p->%s" % entry.cname, entry.type, nanny=False)

1066 if base_type:

1067 tp_dealloc = TypeSlots.get_base_slot_function(scope, tp_slot)

1068 if tp_dealloc is None:

1069 tp_dealloc = "%s->tp_dealloc" % base_type.typeptr_cname

1070 code.putln(

1071 "%s(o);" % tp_dealloc)

1072 else:

1073 code.putln(

1074 "(*Py_TYPE(o)->tp_free)(o);")

1075 code.putln(

1076 "}")

1077

1078 def generate_usr_dealloc_call(self, scope, code):

1079 entry = scope.lookup_here("__dealloc__")

1080 if entry:

1081 code.putln(

1082 "{")

1083 code.putln(

1084 "PyObject *etype, *eval, *etb;")

1085 code.putln(

1086 "PyErr_Fetch(&etype, &eval, &etb);")

1087 code.putln(

1088 "++Py_REFCNT(o);")

1089 code.putln(

1090 "%s(o);" %

1091 entry.func_cname)

1092 code.putln(

1093 "if (PyErr_Occurred()) PyErr_WriteUnraisable(o);")

1094 code.putln(

1095 "--Py_REFCNT(o);")

1096 code.putln(

1097 "PyErr_Restore(etype, eval, etb);")

1098 code.putln(

1099 "}")

1100

1101 def generate_traverse_function(self, scope, code):

1102 tp_slot = TypeSlots.GCDependentSlot("tp_traverse")

1103 slot_func = scope.mangle_internal("tp_traverse")

1104 base_type = scope.parent_type.base_type

1105 if tp_slot.slot_code(scope) != slot_func:

1106 return # never used

1107 code.putln("")

1108 code.putln(

1109 "static int %s(PyObject *o, visitproc v, void *a) {"

1110 % slot_func)

1111 py_attrs = []

1112 for entry in scope.var_entries:

1113 if entry.type.is_pyobject and entry.name != "__weakref__":

1114 py_attrs.append(entry)

1115 if base_type or py_attrs:

1116 code.putln("int e;")

1117 if py_attrs:

1118 self.generate_self_cast(scope, code)

1119 if base_type:

1120 # want to call it explicitly if possible so inlining can be performed

1121 static_call = TypeSlots.get_base_slot_function(scope, tp_slot)

1122 if static_call:

1123 code.putln("e = %s(o, v, a); if (e) return e;" % static_call)

1124 else:

1125 code.putln("if (%s->tp_traverse) {" % base_type.typeptr_cname)

1126 code.putln(

1127 "e = %s->tp_traverse(o, v, a); if (e) return e;" %

1128 base_type.typeptr_cname)

1129 code.putln("}")

1130 for entry in py_attrs:

1131 var_code = "p->%s" % entry.cname

1132 code.putln(

1133 "if (%s) {"

1134 % var_code)

1135 if entry.type.is_extension_type:

1136 var_code = "((PyObject*)%s)" % var_code

1137 code.putln(

1138 "e = (*v)(%s, a); if (e) return e;"

1139 % var_code)

1140 code.putln(

1141 "}")

1142 code.putln(

1143 "return 0;")

1144 code.putln(

1145 "}")

1146

1147 def generate_clear_function(self, scope, code):

1148 tp_slot = TypeSlots.GCDependentSlot("tp_clear")

1149 slot_func = scope.mangle_internal("tp_clear")

1150 base_type = scope.parent_type.base_type

1151 if tp_slot.slot_code(scope) != slot_func:

1152 return # never used

1153 code.putln("")

1154 code.putln("static int %s(PyObject *o) {" % slot_func)

1155 py_attrs = []

1156 for entry in scope.var_entries:

1157 if entry.type.is_pyobject and entry.name != "__weakref__":

1158 py_attrs.append(entry)

1159 if py_attrs:

1160 self.generate_self_cast(scope, code)

1161 code.putln("PyObject* tmp;")

1162 if base_type:

1163 # want to call it explicitly if possible so inlining can be performed

1164 static_call = TypeSlots.get_base_slot_function(scope, tp_slot)

1165 if static_call:

1166 code.putln("%s(o);" % static_call)

1167 else:

1168 code.putln("if (%s->tp_clear) {" % base_type.typeptr_cname)

1169 code.putln("%s->tp_clear(o);" % base_type.typeptr_cname)

1170 code.putln("}")

1171 for entry in py_attrs:

1172 name = "p->%s" % entry.cname

1173 code.putln("tmp = ((PyObject*)%s);" % name)

1174 code.put_init_to_py_none(name, entry.type, nanny=False)

1175 code.putln("Py_XDECREF(tmp);")

1176 code.putln(

1177 "return 0;")

1178 code.putln(

1179 "}")

1180

1181 def generate_getitem_int_function(self, scope, code):

1182 # This function is put into the sq_item slot when

1183 # a __getitem__ method is present. It converts its

1184 # argument to a Python integer and calls mp_subscript.

1185 code.putln(

1186 "static PyObject *%s(PyObject *o, Py_ssize_t i) {" %

1187 scope.mangle_internal("sq_item"))

1188 code.putln(

1189 "PyObject *r;")

1190 code.putln(

1191 "PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;")

1192 code.putln(

1193 "r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);")

1194 code.putln(

1195 "Py_DECREF(x);")

1196 code.putln(

1197 "return r;")

1198 code.putln(

1199 "}")

1200

1201 def generate_ass_subscript_function(self, scope, code):

1202 # Setting and deleting an item are both done through

1203 # the ass_subscript method, so we dispatch to user's __setitem__

1204 # or __delitem__, or raise an exception.

1205 base_type = scope.parent_type.base_type

1206 set_entry = scope.lookup_here("__setitem__")

1207 del_entry = scope.lookup_here("__delitem__")

1208 code.putln("")

1209 code.putln(

1210 "static int %s(PyObject *o, PyObject *i, PyObject *v) {" %

1211 scope.mangle_internal("mp_ass_subscript"))

1212 code.putln(

1213 "if (v) {")

1214 if set_entry:

1215 code.putln(

1216 "return %s(o, i, v);" %

1217 set_entry.func_cname)

1218 else:

1219 self.generate_guarded_basetype_call(

1220 base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code)

1221 code.putln(

1222 "PyErr_Format(PyExc_NotImplementedError,")

1223 code.putln(

1224 ' "Subscript assignment not supported by %s", Py_TYPE(o)->tp_name);')

1225 code.putln(

1226 "return -1;")

1227 code.putln(

1228 "}")

1229 code.putln(

1230 "else {")

1231 if del_entry:

1232 code.putln(

1233 "return %s(o, i);" %

1234 del_entry.func_cname)

1235 else:

1236 self.generate_guarded_basetype_call(

1237 base_type, "tp_as_mapping", "mp_ass_subscript", "o, i, v", code)

1238 code.putln(

1239 "PyErr_Format(PyExc_NotImplementedError,")

1240 code.putln(

1241 ' "Subscript deletion not supported by %s", Py_TYPE(o)->tp_name);')

1242 code.putln(

1243 "return -1;")

1244 code.putln(

1245 "}")

1246 code.putln(

1247 "}")

1248

1249 def generate_guarded_basetype_call(

1250 self, base_type, substructure, slot, args, code):

1251 if base_type:

1252 base_tpname = base_type.typeptr_cname

1253 if substructure:

1254 code.putln(

1255 "if (%s->%s && %s->%s->%s)" % (

1256 base_tpname, substructure, base_tpname, substructure, slot))

1257 code.putln(

1258 " return %s->%s->%s(%s);" % (

1259 base_tpname, substructure, slot, args))

1260 else:

1261 code.putln(

1262 "if (%s->%s)" % (

1263 base_tpname, slot))

1264 code.putln(

1265 " return %s->%s(%s);" % (

1266 base_tpname, slot, args))

1267

1268 def generate_ass_slice_function(self, scope, code):

1269 # Setting and deleting a slice are both done through

1270 # the ass_slice method, so we dispatch to user's __setslice__

1271 # or __delslice__, or raise an exception.

1272 base_type = scope.parent_type.base_type

1273 set_entry = scope.lookup_here("__setslice__")

1274 del_entry = scope.lookup_here("__delslice__")

1275 code.putln("")

1276 code.putln(

1277 "static int %s(PyObject *o, Py_ssize_t i, Py_ssize_t j, PyObject *v) {" %

1278 scope.mangle_internal("sq_ass_slice"))

1279 code.putln(

1280 "if (v) {")

1281 if set_entry:

1282 code.putln(

1283 "return %s(o, i, j, v);" %

1284 set_entry.func_cname)

1285 else:

1286 self.generate_guarded_basetype_call(

1287 base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)

1288 code.putln(

1289 "PyErr_Format(PyExc_NotImplementedError,")

1290 code.putln(

1291 ' "2-element slice assignment not supported by %s", Py_TYPE(o)->tp_name);')

1292 code.putln(

1293 "return -1;")

1294 code.putln(

1295 "}")

1296 code.putln(

1297 "else {")

1298 if del_entry:

1299 code.putln(

1300 "return %s(o, i, j);" %

1301 del_entry.func_cname)

1302 else:

1303 self.generate_guarded_basetype_call(

1304 base_type, "tp_as_sequence", "sq_ass_slice", "o, i, j, v", code)

1305 code.putln(

1306 "PyErr_Format(PyExc_NotImplementedError,")

1307 code.putln(

1308 ' "2-element slice deletion not supported by %s", Py_TYPE(o)->tp_name);')

1309 code.putln(

1310 "return -1;")

1311 code.putln(

1312 "}")

1313 code.putln(

1314 "}")

1315

1316 def generate_getattro_function(self, scope, code):

1317 # First try to get the attribute using __getattribute__, if defined, or

1318 # PyObject_GenericGetAttr.

1319 #

1320 # If that raises an AttributeError, call the __getattr__ if defined.

1321 #

1322 # In both cases, defined can be in this class, or any base class.

1323 def lookup_here_or_base(n,type=None):

1324 # Recursive lookup

1325 if type is None:

1326 type = scope.parent_type

1327 r = type.scope.lookup_here(n)

1328 if r is None and \

1329 type.base_type is not None:

1330 return lookup_here_or_base(n,type.base_type)

1331 else:

1332 return r

1333 getattr_entry = lookup_here_or_base("__getattr__")

1334 getattribute_entry = lookup_here_or_base("__getattribute__")

1335 code.putln("")

1336 code.putln(

1337 "static PyObject *%s(PyObject *o, PyObject *n) {"

1338 % scope.mangle_internal("tp_getattro"))

1339 if getattribute_entry is not None:

1340 code.putln(

1341 "PyObject *v = %s(o, n);" %

1342 getattribute_entry.func_cname)

1343 else:

1344 code.putln(

1345 "PyObject *v = PyObject_GenericGetAttr(o, n);")

1346 if getattr_entry is not None:

1347 code.putln(

1348 "if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) {")

1349 code.putln(

1350 "PyErr_Clear();")

1351 code.putln(

1352 "v = %s(o, n);" %

1353 getattr_entry.func_cname)

1354 code.putln(

1355 "}")

1356 code.putln(

1357 "return v;")

1358 code.putln(

1359 "}")

1360

1361 def generate_setattro_function(self, scope, code):

1362 # Setting and deleting an attribute are both done through

1363 # the setattro method, so we dispatch to user's __setattr__

1364 # or __delattr__ or fall back on PyObject_GenericSetAttr.

1365 base_type = scope.parent_type.base_type

1366 set_entry = scope.lookup_here("__setattr__")

1367 del_entry = scope.lookup_here("__delattr__")

1368 code.putln("")

1369 code.putln(

1370 "static int %s(PyObject *o, PyObject *n, PyObject *v) {" %

1371 scope.mangle_internal("tp_setattro"))

1372 code.putln(

1373 "if (v) {")

1374 if set_entry:

1375 code.putln(

1376 "return %s(o, n, v);" %

1377 set_entry.func_cname)

1378 else:

1379 self.generate_guarded_basetype_call(

1380 base_type, None, "tp_setattro", "o, n, v", code)

1381 code.putln(

1382 "return PyObject_GenericSetAttr(o, n, v);")

1383 code.putln(

1384 "}")

1385 code.putln(

1386 "else {")

1387 if del_entry:

1388 code.putln(

1389 "return %s(o, n);" %

1390 del_entry.func_cname)

1391 else:

1392 self.generate_guarded_basetype_call(

1393 base_type, None, "tp_setattro", "o, n, v", code)

1394 code.putln(

1395 "return PyObject_GenericSetAttr(o, n, 0);")

1396 code.putln(

1397 "}")

1398 code.putln(

1399 "}")

1400

1401 def generate_descr_get_function(self, scope, code):

1402 # The __get__ function of a descriptor object can be

1403 # called with NULL for the second or third arguments

1404 # under some circumstances, so we replace them with

1405 # None in that case.

1406 user_get_entry = scope.lookup_here("__get__")

1407 code.putln("")

1408 code.putln(

1409 "static PyObject *%s(PyObject *o, PyObject *i, PyObject *c) {" %

1410 scope.mangle_internal("tp_descr_get"))

1411 code.putln(

1412 "PyObject *r = 0;")

1413 code.putln(

1414 "if (!i) i = Py_None;")

1415 code.putln(

1416 "if (!c) c = Py_None;")

1417 #code.put_incref("i", py_object_type)

1418 #code.put_incref("c", py_object_type)

1419 code.putln(

1420 "r = %s(o, i, c);" %

1421 user_get_entry.func_cname)

1422 #code.put_decref("i", py_object_type)

1423 #code.put_decref("c", py_object_type)

1424 code.putln(

1425 "return r;")

1426 code.putln(

1427 "}")

1428

1429 def generate_descr_set_function(self, scope, code):

1430 # Setting and deleting are both done through the __set__

1431 # method of a descriptor, so we dispatch to user's __set__

1432 # or __delete__ or raise an exception.

1433 base_type = scope.parent_type.base_type

1434 user_set_entry = scope.lookup_here("__set__")

1435 user_del_entry = scope.lookup_here("__delete__")

1436 code.putln("")

1437 code.putln(

1438 "static int %s(PyObject *o, PyObject *i, PyObject *v) {" %

1439 scope.mangle_internal("tp_descr_set"))

1440 code.putln(

1441 "if (v) {")

1442 if user_set_entry:

1443 code.putln(

1444 "return %s(o, i, v);" %

1445 user_set_entry.func_cname)

1446 else:

1447 self.generate_guarded_basetype_call(

1448 base_type, None, "tp_descr_set", "o, i, v", code)

1449 code.putln(

1450 'PyErr_SetString(PyExc_NotImplementedError, "__set__");')

1451 code.putln(

1452 "return -1;")

1453 code.putln(

1454 "}")

1455 code.putln(

1456 "else {")

1457 if user_del_entry:

1458 code.putln(

1459 "return %s(o, i);" %

1460 user_del_entry.func_cname)

1461 else:

1462 self.generate_guarded_basetype_call(

1463 base_type, None, "tp_descr_set", "o, i, v", code)

1464 code.putln(

1465 'PyErr_SetString(PyExc_NotImplementedError, "__delete__");')

1466 code.putln(

1467 "return -1;")

1468 code.putln(

1469 "}")

1470 code.putln(

1471 "}")

1472

1473 def generate_property_accessors(self, cclass_scope, code):

1474 for entry in cclass_scope.property_entries:

1475 property_scope = entry.scope

1476 if property_scope.defines_any(["__get__"]):

1477 self.generate_property_get_function(entry, code)

1478 if property_scope.defines_any(["__set__", "__del__"]):

1479 self.generate_property_set_function(entry, code)

1480

1481 def generate_property_get_function(self, property_entry, code):

1482 property_scope = property_entry.scope

1483 property_entry.getter_cname = property_scope.parent_scope.mangle(

1484 Naming.prop_get_prefix, property_entry.name)

1485 get_entry = property_scope.lookup_here("__get__")

1486 code.putln("")

1487 code.putln(

1488 "static PyObject *%s(PyObject *o, void *x) {" %

1489 property_entry.getter_cname)

1490 code.putln(

1491 "return %s(o);" %

1492 get_entry.func_cname)

1493 code.putln(

1494 "}")

1495

1496 def generate_property_set_function(self, property_entry, code):

1497 property_scope = property_entry.scope

1498 property_entry.setter_cname = property_scope.parent_scope.mangle(

1499 Naming.prop_set_prefix, property_entry.name)

1500 set_entry = property_scope.lookup_here("__set__")

1501 del_entry = property_scope.lookup_here("__del__")

1502 code.putln("")

1503 code.putln(

1504 "static int %s(PyObject *o, PyObject *v, void *x) {" %

1505 property_entry.setter_cname)

1506 code.putln(

1507 "if (v) {")

1508 if set_entry:

1509 code.putln(

1510 "return %s(o, v);" %

1511 set_entry.func_cname)

1512 else:

1513 code.putln(

1514 'PyErr_SetString(PyExc_NotImplementedError, "__set__");')

1515 code.putln(

1516 "return -1;")

1517 code.putln(

1518 "}")

1519 code.putln(

1520 "else {")

1521 if del_entry:

1522 code.putln(

1523 "return %s(o);" %

1524 del_entry.func_cname)

1525 else:

1526 code.putln(

1527 'PyErr_SetString(PyExc_NotImplementedError, "__del__");')

1528 code.putln(

1529 "return -1;")

1530 code.putln(

1531 "}")

1532 code.putln(

1533 "}")

1534

1535 def generate_typeobj_definition(self, modname, entry, code):

1536 type = entry.type

1537 scope = type.scope

1538 for suite in TypeSlots.substructures:

1539 suite.generate_substructure(scope, code)

1540 code.putln("")

1541 if entry.visibility == 'public':

1542 header = "DL_EXPORT(PyTypeObject) %s = {"

1543 else:

1544 #header = "statichere PyTypeObject %s = {"

1545 header = "PyTypeObject %s = {"

1546 #code.putln(header % scope.parent_type.typeobj_cname)

1547 code.putln(header % type.typeobj_cname)

1548 code.putln(

1549 "PyVarObject_HEAD_INIT(0, 0)")

1550 code.putln(

1551 '__Pyx_NAMESTR("%s.%s"), /*tp_name*/' % (

1552 self.full_module_name, scope.class_name))

1553 if type.typedef_flag:

1554 objstruct = type.objstruct_cname

1555 else:

1556 objstruct = "struct %s" % type.objstruct_cname

1557 code.putln(

1558 "sizeof(%s), /*tp_basicsize*/" %

1559 objstruct)

1560 code.putln(

1561 "0, /*tp_itemsize*/")

1562 for slot in TypeSlots.slot_table:

1563 slot.generate(scope, code)

1564 code.putln(

1565 "};")

1566

1567 def generate_method_table(self, env, code):

1568 code.putln("")

1569 code.putln(

1570 "static PyMethodDef %s[] = {" %

1571 env.method_table_cname)

1572 for entry in env.pyfunc_entries:

1573 code.put_pymethoddef(entry, ",")

1574 code.putln(

1575 "{0, 0, 0, 0}")

1576 code.putln(

1577 "};")

1578

1579 def generate_getset_table(self, env, code):

1580 if env.property_entries:

1581 code.putln("")

1582 code.putln(

1583 "static struct PyGetSetDef %s[] = {" %

1584 env.getset_table_cname)

1585 for entry in env.property_entries:

1586 if entry.doc:

1587 doc_code = "__Pyx_DOCSTR(%s)" % code.get_string_const(entry.doc)

1588 else:

1589 doc_code = "0"

1590 code.putln(

1591 '{(char *)"%s", %s, %s, %s, 0},' % (

1592 entry.name,

1593 entry.getter_cname or "0",

1594 entry.setter_cname or "0",

1595 doc_code))

1596 code.putln(

1597 "{0, 0, 0, 0, 0}")

1598 code.putln(

1599 "};")

1600

1601 def generate_import_star(self, env, code):

1602 env.use_utility_code(streq_utility_code)

1603 code.putln()

1604 code.putln("char* %s_type_names[] = {" % Naming.import_star)

1605 for name, entry in env.entries.items():

1606 if entry.is_type:

1607 code.putln('"%s",' % name)

1608 code.putln("0")

1609 code.putln("};")

1610 code.putln()

1611 code.enter_cfunc_scope() # as we need labels

1612 code.putln("static int %s(PyObject *o, PyObject* py_name, char *name) {" % Naming.import_star_set)

1613 code.putln("char** type_name = %s_type_names;" % Naming.import_star)

1614 code.putln("while (*type_name) {")

1615 code.putln("if (__Pyx_StrEq(name, *type_name)) {")

1616 code.putln('PyErr_Format(PyExc_TypeError, "Cannot overwrite C type %s", name);')

1617 code.putln('goto bad;')

1618 code.putln("}")

1619 code.putln("type_name++;")

1620 code.putln("}")

1621 old_error_label = code.new_error_label()

1622 code.putln("if (0);") # so the first one can be "else if"

1623 for name, entry in env.entries.items():

1624 if entry.is_cglobal and entry.used:

1625 code.putln('else if (__Pyx_StrEq(name, "%s")) {' % name)

1626 if entry.type.is_pyobject:

1627 if entry.type.is_extension_type or entry.type.is_builtin_type:

1628 code.putln("if (!(%s)) %s;" % (

1629 entry.type.type_test_code("o"),

1630 code.error_goto(entry.pos)))

1631 code.put_var_decref(entry)

1632 code.putln("%s = %s;" % (

1633 entry.cname,

1634 PyrexTypes.typecast(entry.type, py_object_type, "o")))

1635 elif entry.type.from_py_function:

1636 rhs = "%s(o)" % entry.type.from_py_function

1637 if entry.type.is_enum:

1638 rhs = typecast(entry.type, c_long_type, rhs)

1639 code.putln("%s = %s; if (%s) %s;" % (

1640 entry.cname,

1641 rhs,

1642 entry.type.error_condition(entry.cname),

1643 code.error_goto(entry.pos)))

1644 code.putln("Py_DECREF(o);")

1645 else:

1646 code.putln('PyErr_Format(PyExc_TypeError, "Cannot convert Python object %s to %s");' % (name, entry.type))

1647 code.putln(code.error_goto(entry.pos))

1648 code.putln("}")

1649 code.putln("else {")

1650 code.putln("if (PyObject_SetAttr(%s, py_name, o) < 0) goto bad;" % Naming.module_cname)

1651 code.putln("}")

1652 code.putln("return 0;")

1653 code.put_label(code.error_label)

1654 # This helps locate the offending name.

1655 code.putln('__Pyx_AddTraceback("%s");' % self.full_module_name);

1656 code.error_label = old_error_label

1657 code.putln("bad:")

1658 code.putln("Py_DECREF(o);")

1659 code.putln("return -1;")

1660 code.putln("}")

1661 code.putln(import_star_utility_code)

1662 code.exit_cfunc_scope() # done with labels

1663

1664 def generate_module_init_func(self, imported_modules, env, code):

1665 code.enter_cfunc_scope()

1666 code.putln("")

1667 header2 = "PyMODINIT_FUNC init%s(void)" % env.module_name

1668 header3 = "PyMODINIT_FUNC PyInit_%s(void)" % env.module_name

1669 code.putln("#if PY_MAJOR_VERSION < 3")

1670 code.putln("%s; /*proto*/" % header2)

1671 code.putln(header2)

1672 code.putln("#else")

1673 code.putln("%s; /*proto*/" % header3)

1674 code.putln(header3)

1675 code.putln("#endif")

1676 code.putln("{")

1677 tempdecl_code = code.insertion_point()

1678

1679 code.putln("#if CYTHON_REFNANNY")

1680 code.putln("void* __pyx_refnanny = NULL;")

1681 code.putln("__Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"refnanny\");")

1682 code.putln("if (!__Pyx_RefNanny) {")

1683 code.putln(" PyErr_Clear();")

1684 code.putln(" __Pyx_RefNanny = __Pyx_RefNannyImportAPI(\"Cython.Runtime.refnanny\");")

1685 code.putln(" if (!__Pyx_RefNanny)")

1686 code.putln(" Py_FatalError(\"failed to import 'refnanny' module\");")

1687 code.putln("}")

1688 code.putln("__pyx_refnanny = __Pyx_RefNanny->SetupContext(\"%s\", __LINE__, __FILE__);"% header3)

1689 code.putln("#endif")

1690

1691 code.putln("%s = PyTuple_New(0); %s" % (Naming.empty_tuple, code.error_goto_if_null(Naming.empty_tuple, self.pos)));

1692 code.putln("%s = PyBytes_FromStringAndSize(\"\", 0); %s" % (Naming.empty_bytes, code.error_goto_if_null(Naming.empty_bytes, self.pos)));

1693

1694 code.putln("#ifdef %s_USED" % Naming.binding_cfunc)

1695 code.putln("if (%s_init() < 0) %s" % (Naming.binding_cfunc, code.error_goto(self.pos)))

1696 code.putln("#endif")

1697

1698 code.putln("/*--- Library function declarations ---*/")

1699 env.generate_library_function_declarations(code)

1700

1701 code.putln("/*--- Threads initialization code ---*/")

1702 code.putln("#if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS")

1703 code.putln("#ifdef WITH_THREAD /* Python build with threading support? */")

1704 code.putln("PyEval_InitThreads();")

1705 code.putln("#endif")

1706 code.putln("#endif")

1707

1708 code.putln("/*--- Module creation code ---*/")

1709 self.generate_module_creation_code(env, code)

1710

1711 code.putln("/*--- Initialize various global constants etc. ---*/")

1712 code.putln(code.error_goto_if_neg("__Pyx_InitGlobals()", self.pos))

1713

1714 __main__name = code.globalstate.get_py_string_const(

1715 EncodedString("__main__"), identifier=True)

1716 code.putln("if (%s%s) {" % (Naming.module_is_main, self.full_module_name.replace('.', '__')))

1717 code.putln(

1718 'if (__Pyx_SetAttrString(%s, "__name__", %s) < 0) %s;' % (

1719 env.module_cname,

1720 __main__name.cname,

1721 code.error_goto(self.pos)))

1722 code.putln("}")

1723

1724 if Options.cache_builtins:

1725 code.putln("/*--- Builtin init code ---*/")

1726 code.putln(code.error_goto_if_neg("__Pyx_InitCachedBuiltins()",

1727 self.pos))

1728

1729 code.putln("/*--- Global init code ---*/")

1730 self.generate_global_init_code(env, code)

1731

1732 code.putln("/*--- Function export code ---*/")

1733 self.generate_c_function_export_code(env, code)

1734

1735 code.putln("/*--- Type init code ---*/")

1736 self.generate_type_init_code(env, code)

1737

1738 code.putln("/*--- Type import code ---*/")

1739 for module in imported_modules:

1740 self.generate_type_import_code_for_module(module, env, code)

1741

1742 code.putln("/*--- Function import code ---*/")

1743 for module in imported_modules:

1744 self.generate_c_function_import_code_for_module(module, env, code)

1745

1746 code.putln("/*--- Execution code ---*/")

1747 code.mark_pos(None)

1748

1749 self.body.generate_execution_code(code)

1750

1751 if Options.generate_cleanup_code:

1752 # this should be replaced by the module's tp_clear in Py3

1753 env.use_utility_code(import_module_utility_code)

1754 code.putln("if (__Pyx_RegisterCleanup()) %s;" % code.error_goto(self.pos))

1755

1756 code.put_goto(code.return_label)

1757 code.put_label(code.error_label)

1758 for cname, type in code.funcstate.all_managed_temps():

1759 code.put_xdecref(cname, type)

1760 code.putln('if (%s) {' % env.module_cname)

1761 code.putln('__Pyx_AddTraceback("init %s");' % env.qualified_name)

1762 env.use_utility_code(Nodes.traceback_utility_code)

1763 code.put_decref_clear(env.module_cname, py_object_type, nanny=False)

1764 code.putln('} else if (!PyErr_Occurred()) {')

1765 code.putln('PyErr_SetString(PyExc_ImportError, "init %s");' % env.qualified_name)

1766 code.putln('}')

1767 code.put_label(code.return_label)

1768

1769 code.put_finish_refcount_context()

1770

1771 code.putln("#if PY_MAJOR_VERSION < 3")

1772 code.putln("return;")

1773 code.putln("#else")

1774 code.putln("return %s;" % env.module_cname)

1775 code.putln("#endif")

1776 code.putln('}')

1777

1778 tempdecl_code.put_temp_declarations(code.funcstate)

1779

1780 code.exit_cfunc_scope()

1781

1782 def generate_module_cleanup_func(self, env, code):

1783 if not Options.generate_cleanup_code:

1784 return

1785 code.globalstate.use_utility_code(register_cleanup_utility_code)

1786 code.putln('static PyObject *%s(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *unused) {' %

1787 Naming.cleanup_cname)

1788 if Options.generate_cleanup_code >= 2:

1789 code.putln("/*--- Global cleanup code ---*/")

1790 rev_entries = list(env.var_entries)

1791 rev_entries.reverse()

1792 for entry in rev_entries:

1793 if entry.visibility != 'extern':

1794 if entry.type.is_pyobject and entry.used:

1795 code.putln("Py_DECREF(%s); %s = 0;" % (

1796 code.entry_as_pyobject(entry), entry.cname))

1797 code.putln("__Pyx_CleanupGlobals();")

1798 if Options.generate_cleanup_code >= 3:

1799 code.putln("/*--- Type import cleanup code ---*/")

1800 for type, _ in env.types_imported.items():

1801 code.putln("Py_DECREF((PyObject *)%s);" % type.typeptr_cname)

1802 if Options.cache_builtins:

1803 code.putln("/*--- Builtin cleanup code ---*/")

1804 for entry in env.cached_builtins:

1805 code.put_decref_clear(entry.cname,

1806 PyrexTypes.py_object_type,

1807 nanny=False)

1808 code.putln("/*--- Intern cleanup code ---*/")

1809 code.put_decref_clear(Naming.empty_tuple,

1810 PyrexTypes.py_object_type,

1811 nanny=False)

1812 # for entry in env.pynum_entries:

1813 # code.put_decref_clear(entry.cname,

1814 # PyrexTypes.py_object_type,

1815 # nanny=False)

1816 # for entry in env.all_pystring_entries:

1817 # if entry.is_interned:

1818 # code.put_decref_clear(entry.pystring_cname,

1819 # PyrexTypes.py_object_type,

1820 # nanny=False)

1821 # for entry in env.default_entries:

1822 # if entry.type.is_pyobject and entry.used:

1823 # code.putln("Py_DECREF(%s); %s = 0;" % (

1824 # code.entry_as_pyobject(entry), entry.cname))

1825 code.putln("Py_INCREF(Py_None); return Py_None;")

1826

1827 def generate_main_method(self, env, code):

1828 module_is_main = "%s%s" % (Naming.module_is_main, self.full_module_name.replace('.', '__'))

1829 code.globalstate.use_utility_code(main_method.specialize(module_name=env.module_name, module_is_main=module_is_main))

1830

1831 def generate_pymoduledef_struct(self, env, code):

1832 if env.doc:

1833 doc = "__Pyx_DOCSTR(%s)" % code.get_string_const(env.doc)

1834 else:

1835 doc = "0"

1836 code.putln("")

1837 code.putln("#if PY_MAJOR_VERSION >= 3")

1838 code.putln("static struct PyModuleDef %s = {" % Naming.pymoduledef_cname)

1839 code.putln(" PyModuleDef_HEAD_INIT,")

1840 code.putln(' __Pyx_NAMESTR("%s"),' % env.module_name)

1841 code.putln(" %s, /* m_doc */" % doc)

1842 code.putln(" -1, /* m_size */")

1843 code.putln(" %s /* m_methods */," % env.method_table_cname)

1844 code.putln(" NULL, /* m_reload */")

1845 code.putln(" NULL, /* m_traverse */")

1846 code.putln(" NULL, /* m_clear */")

1847 code.putln(" NULL /* m_free */")

1848 code.putln("};")

1849 code.putln("#endif")

1850

1851 def generate_module_creation_code(self, env, code):

1852 # Generate code to create the module object and

1853 # install the builtins.

1854 if env.doc:

1855 doc = "__Pyx_DOCSTR(%s)" % code.get_string_const(env.doc)

1856 else:

1857 doc = "0"

1858 code.putln("#if PY_MAJOR_VERSION < 3")

1859 code.putln(

1860 '%s = Py_InitModule4(__Pyx_NAMESTR("%s"), %s, %s, 0, PYTHON_API_VERSION);' % (

1861 env.module_cname,

1862 env.module_name,

1863 env.method_table_cname,

1864 doc))

1865 code.putln("#else")

1866 code.putln(

1867 "%s = PyModule_Create(&%s);" % (

1868 env.module_cname,

1869 Naming.pymoduledef_cname))

1870 code.putln("#endif")

1871 code.putln(

1872 "if (!%s) %s;" % (

1873 env.module_cname,

1874 code.error_goto(self.pos)));

1875 code.putln("#if PY_MAJOR_VERSION < 3")

1876 code.putln(

1877 "Py_INCREF(%s);" %

1878 env.module_cname)

1879 code.putln("#endif")

1880 code.putln(

1881 '%s = PyImport_AddModule(__Pyx_NAMESTR(__Pyx_BUILTIN_MODULE_NAME));' %

1882 Naming.builtins_cname)

1883 code.putln(

1884 "if (!%s) %s;" % (

1885 Naming.builtins_cname,

1886 code.error_goto(self.pos)));

1887 code.putln(

1888 'if (__Pyx_SetAttrString(%s, "__builtins__", %s) < 0) %s;' % (

1889 env.module_cname,

1890 Naming.builtins_cname,

1891 code.error_goto(self.pos)))

1892 if Options.pre_import is not None:

1893 code.putln(

1894 '%s = PyImport_AddModule(__Pyx_NAMESTR("%s"));' % (

1895 Naming.preimport_cname,

1896 Options.pre_import))

1897 code.putln(

1898 "if (!%s) %s;" % (

1899 Naming.preimport_cname,

1900 code.error_goto(self.pos)));

1901

1902 def generate_global_init_code(self, env, code):

1903 # Generate code to initialise global PyObject *

1904 # variables to None.

1905 for entry in env.var_entries:

1906 if entry.visibility != 'extern':

1907 if entry.type.is_pyobject and entry.used:

1908 code.put_init_var_to_py_none(entry, nanny=False)

1909

1910 def generate_c_function_export_code(self, env, code):

1911 # Generate code to create PyCFunction wrappers for exported C functions.

1912 for entry in env.cfunc_entries:

1913 if entry.api or entry.defined_in_pxd:

1914 env.use_utility_code(function_export_utility_code)

1915 signature = entry.type.signature_string()

1916 code.putln('if (__Pyx_ExportFunction("%s", (void (*)(void))%s, "%s") < 0) %s' % (

1917 entry.name,

1918 entry.cname,

1919 signature,

1920 code.error_goto(self.pos)))

1921

1922 def generate_type_import_code_for_module(self, module, env, code):

1923 # Generate type import code for all exported extension types in

1924 # an imported module.

1925 #if module.c_class_entries:

1926 for entry in module.c_class_entries:

1927 if entry.defined_in_pxd:

1928 self.generate_type_import_code(env, entry.type, entry.pos, code)

1929

1930 def generate_c_function_import_code_for_module(self, module, env, code):

1931 # Generate import code for all exported C functions in a cimported module.

1932 entries = []

1933 for entry in module.cfunc_entries:

1934 if entry.defined_in_pxd:

1935 entries.append(entry)

1936 if entries:

1937 env.use_utility_code(import_module_utility_code)

1938 env.use_utility_code(function_import_utility_code)

1939 temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)

1940 code.putln(

1941 '%s = __Pyx_ImportModule("%s"); if (!%s) %s' % (

1942 temp,

1943 module.qualified_name,

1944 temp,

1945 code.error_goto(self.pos)))

1946 for entry in entries:

1947 code.putln(

1948 'if (__Pyx_ImportFunction(%s, "%s", (void (**)(void))&%s, "%s") < 0) %s' % (

1949 temp,

1950 entry.name,

1951 entry.cname,

1952 entry.type.signature_string(),

1953 code.error_goto(self.pos)))

1954 code.putln("Py_DECREF(%s); %s = 0;" % (temp, temp))

1955

1956 def generate_type_init_code(self, env, code):

1957 # Generate type import code for extern extension types

1958 # and type ready code for non-extern ones.

1959 for entry in env.c_class_entries:

1960 if entry.visibility == 'extern':

1961 self.generate_type_import_code(env, entry.type, entry.pos, code)

1962 else:

1963 self.generate_base_type_import_code(env, entry, code)

1964 self.generate_exttype_vtable_init_code(entry, code)

1965 self.generate_type_ready_code(env, entry, code)

1966 self.generate_typeptr_assignment_code(entry, code)

1967

1968 def generate_base_type_import_code(self, env, entry, code):

1969 base_type = entry.type.base_type

1970 if base_type and base_type.module_name != env.qualified_name:

1971 self.generate_type_import_code(env, base_type, self.pos, code)

1972

1973 def use_type_import_utility_code(self, env):

1974 env.use_utility_code(type_import_utility_code)

1975 env.use_utility_code(import_module_utility_code)

1976

1977 def generate_type_import_code(self, env, type, pos, code):

1978 # If not already done, generate code to import the typeobject of an

1979 # extension type defined in another module, and extract its C method

1980 # table pointer if any.

1981 if type in env.types_imported:

1982 return

1983 if type.typedef_flag:

1984 objstruct = type.objstruct_cname

1985 else:

1986 objstruct = "struct %s" % type.objstruct_cname

1987 self.generate_type_import_call(type, code,

1988 code.error_goto_if_null(type.typeptr_cname, pos))

1989 self.use_type_import_utility_code(env)

1990 if type.vtabptr_cname:

1991 code.putln(

1992 "if (__Pyx_GetVtable(%s->tp_dict, &%s) < 0) %s" % (

1993 type.typeptr_cname,

1994 type.vtabptr_cname,

1995 code.error_goto(pos)))

1996 env.use_utility_code(Nodes.get_vtable_utility_code)

1997 env.types_imported[type] = 1

1998

1999 py3_type_name_map = {'str' : 'bytes', 'unicode' : 'str'}

2000

2001 def generate_type_import_call(self, type, code, error_code):

2002 if type.typedef_flag:

2003 objstruct = type.objstruct_cname

2004 else:

2005 objstruct = "struct %s" % type.objstruct_cname

2006 module_name = type.module_name

2007 if module_name not in ('__builtin__', 'builtins'):

2008 module_name = '"%s"' % module_name

2009 else:

2010 module_name = '__Pyx_BUILTIN_MODULE_NAME'

2011 if type.name in self.py3_type_name_map:

2012 code.putln("#if PY_MAJOR_VERSION >= 3")

2013 code.putln('%s = __Pyx_ImportType(%s, "%s", sizeof(%s), 1); %s' % (

2014 type.typeptr_cname,

2015 module_name,

2016 self.py3_type_name_map[type.name],

2017 objstruct,

2018 error_code))

2019 code.putln("#else")

2020 code.putln('%s = __Pyx_ImportType(%s, "%s", sizeof(%s), %i); %s' % (

2021 type.typeptr_cname,

2022 module_name,

2023 type.name,

2024 objstruct,

2025 not type.is_external or type.is_subclassed,

2026 error_code))

2027 if type.name in self.py3_type_name_map:

2028 code.putln("#endif")

2029

2030 def generate_type_ready_code(self, env, entry, code):

2031 # Generate a call to PyType_Ready for an extension

2032 # type defined in this module.

2033 type = entry.type

2034 typeobj_cname = type.typeobj_cname

2035 scope = type.scope

2036 if scope: # could be None if there was an error

2037 if entry.visibility != 'extern':

2038 for slot in TypeSlots.slot_table:

2039 slot.generate_dynamic_init_code(scope, code)

2040 code.putln(

2041 "if (PyType_Ready(&%s) < 0) %s" % (

2042 typeobj_cname,

2043 code.error_goto(entry.pos)))

2044 # Fix special method docstrings. This is a bit of a hack, but

2045 # unless we let PyType_Ready create the slot wrappers we have

2046 # a significant performance hit. (See trac #561.)

2047 for func in entry.type.scope.pyfunc_entries:

2048 if func.is_special and func.doc:

2049 code.putln("{");

2050 code.putln(

2051 'PyObject *wrapper = PyObject_GetAttrString((PyObject *)&%s, "%s"); %s' % (

2052 typeobj_cname,

2053 func.name,

2054 code.error_goto_if_null('wrapper', entry.pos)));

2055 code.putln(

2056 "if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {");

2057 code.putln(

2058 "%s = *((PyWrapperDescrObject *)wrapper)->d_base;" % (

2059 func.wrapperbase_cname));

2060 code.putln(

2061 "%s.doc = %s;" % (func.wrapperbase_cname, func.doc_cname));

2062 code.putln(

2063 "((PyWrapperDescrObject *)wrapper)->d_base = &%s;" % (

2064 func.wrapperbase_cname));

2065 code.putln("}");

2066 code.putln("}");

2067 if type.vtable_cname:

2068 code.putln(

2069 "if (__Pyx_SetVtable(%s.tp_dict, %s) < 0) %s" % (

2070 typeobj_cname,

2071 type.vtabptr_cname,

2072 code.error_goto(entry.pos)))

2073 env.use_utility_code(Nodes.set_vtable_utility_code)

2074 code.putln(

2075 'if (__Pyx_SetAttrString(%s, "%s", (PyObject *)&%s) < 0) %s' % (

2076 Naming.module_cname,

2077 scope.class_name,

2078 typeobj_cname,

2079 code.error_goto(entry.pos)))

2080 weakref_entry = scope.lookup_here("__weakref__")

2081 if weakref_entry:

2082 if weakref_entry.type is py_object_type:

2083 tp_weaklistoffset = "%s.tp_weaklistoffset" % typeobj_cname

2084 if type.typedef_flag:

2085 objstruct = type.objstruct_cname

2086 else:

2087 objstruct = "struct %s" % type.objstruct_cname

2088 code.putln("if (%s == 0) %s = offsetof(%s, %s);" % (

2089 tp_weaklistoffset,

2090 tp_weaklistoffset,

2091 objstruct,

2092 weakref_entry.cname))

2093 else:

2094 error(weakref_entry.pos, "__weakref__ slot must be of type 'object'")

2095

2096 def generate_exttype_vtable_init_code(self, entry, code):

2097 # Generate code to initialise the C method table of an

2098 # extension type.

2099 type = entry.type

2100 if type.vtable_cname:

2101 code.putln(

2102 "%s = &%s;" % (

2103 type.vtabptr_cname,

2104 type.vtable_cname))

2105 if type.base_type and type.base_type.vtabptr_cname:

2106 code.putln(

2107 "%s.%s = *%s;" % (

2108 type.vtable_cname,

2109 Naming.obj_base_cname,

2110 type.base_type.vtabptr_cname))

2111

2112 c_method_entries = [

2113 entry for entry in type.scope.cfunc_entries

2114 if entry.func_cname ]

2115 if c_method_entries:

2116 code.putln('#if PY_MAJOR_VERSION >= 3')

2117 for meth_entry in c_method_entries:

2118 cast = meth_entry.type.signature_cast_string()

2119 code.putln(

2120 "%s.%s = %s%s;" % (

2121 type.vtable_cname,

2122 meth_entry.cname,

2123 cast,

2124 meth_entry.func_cname))

2125 code.putln('#else')

2126 for meth_entry in c_method_entries:

2127 code.putln(

2128 "*(void(**)(void))&%s.%s = (void(*)(void))%s;" % (

2129 type.vtable_cname,

2130 meth_entry.cname,

2131 meth_entry.func_cname))

2132 code.putln('#endif')

2133

2134 def generate_typeptr_assignment_code(self, entry, code):

2135 # Generate code to initialise the typeptr of an extension

2136 # type defined in this module to point to its type object.

2137 type = entry.type

2138 if type.typeobj_cname:

2139 code.putln(

2140 "%s = &%s;" % (

2141 type.typeptr_cname, type.typeobj_cname))

2142

2143 #------------------------------------------------------------------------------------

2144 #

2145 # Runtime support code

2146 #

2147 #------------------------------------------------------------------------------------

2148

2149 streq_utility_code = UtilityCode(

2150 proto = """

2151 static CYTHON_INLINE int __Pyx_StrEq(const char *, const char *); /*proto*/

2152 """,

2153 impl = """

2154 static CYTHON_INLINE int __Pyx_StrEq(const char *s1, const char *s2) {

2155 while (*s1 != '\\0' && *s1 == *s2) { s1++; s2++; }

2156 return *s1 == *s2;

2157 }

2158 """)

2159

2160 #------------------------------------------------------------------------------------

2161

2162 import_module_utility_code = UtilityCode(

2163 proto = """

2164 static PyObject *__Pyx_ImportModule(const char *name); /*proto*/

2165 """,

2166 impl = """

2167 #ifndef __PYX_HAVE_RT_ImportModule

2168 #define __PYX_HAVE_RT_ImportModule

2169 static PyObject *__Pyx_ImportModule(const char *name) {

2170 PyObject *py_name = 0;

2171 PyObject *py_module = 0;

2172

2173 #if PY_MAJOR_VERSION < 3

2174 py_name = PyString_FromString(name);

2175 #else

2176 py_name = PyUnicode_FromString(name);

2177 #endif

2178 if (!py_name)

2179 goto bad;

2180 py_module = PyImport_Import(py_name);

2181 Py_DECREF(py_name);

2182 return py_module;

2183 bad:

2184 Py_XDECREF(py_name);

2185 return 0;

2186 }

2187 #endif

2188 """)

2189

2190 #------------------------------------------------------------------------------------

2191

2192 type_import_utility_code = UtilityCode(

2193 proto = """

2194 static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, long size, int strict); /*proto*/

2195 """,

2196 impl = """

2197 #ifndef __PYX_HAVE_RT_ImportType

2198 #define __PYX_HAVE_RT_ImportType

2199 static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,

2200 long size, int strict)

2201 {

2202 PyObject *py_module = 0;

2203 PyObject *result = 0;

2204 PyObject *py_name = 0;

2205 char warning[200];

2206

2207 py_module = __Pyx_ImportModule(module_name);

2208 if (!py_module)

2209 goto bad;

2210 #if PY_MAJOR_VERSION < 3

2211 py_name = PyString_FromString(class_name);

2212 #else

2213 py_name = PyUnicode_FromString(class_name);

2214 #endif

2215 if (!py_name)

2216 goto bad;

2217 result = PyObject_GetAttr(py_module, py_name);

2218 Py_DECREF(py_name);

2219 py_name = 0;

2220 Py_DECREF(py_module);

2221 py_module = 0;

2222 if (!result)

2223 goto bad;

2224 if (!PyType_Check(result)) {

2225 PyErr_Format(PyExc_TypeError,

2226 "%s.%s is not a type object",

2227 module_name, class_name);

2228 goto bad;

2229 }

2230 if (!strict && ((PyTypeObject *)result)->tp_basicsize > size) {

2231 PyOS_snprintf(warning, sizeof(warning),

2232 "%s.%s size changed, may indicate binary incompatibility",

2233 module_name, class_name);

2234 #if PY_VERSION_HEX < 0x02050000

2235 PyErr_Warn(NULL, warning);

2236 #else

2237 PyErr_WarnEx(NULL, warning, 0);

2238 #endif

2239 }

2240 else if (((PyTypeObject *)result)->tp_basicsize != size) {

2241 PyErr_Format(PyExc_ValueError,

2242 "%s.%s has the wrong size, try recompiling",

2243 module_name, class_name);

2244 goto bad;

2245 }

2246 return (PyTypeObject *)result;

2247 bad:

2248 Py_XDECREF(py_module);

2249 Py_XDECREF(result);

2250 return 0;

2251 }

2252 #endif

2253 """)

2254

2255 #------------------------------------------------------------------------------------

2256

2257 function_export_utility_code = UtilityCode(

2258 proto = """

2259 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); /*proto*/

2260 """,

2261 impl = r"""

2262 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) {

2263 PyObject *d = 0;

2264 PyObject *cobj = 0;

2265 union {

2266 void (*fp)(void);

2267 void *p;

2268 } tmp;

2269

2270 d = PyObject_GetAttrString(%(MODULE)s, (char *)"%(API)s");

2271 if (!d) {

2272 PyErr_Clear();

2273 d = PyDict_New();

2274 if (!d)

2275 goto bad;

2276 Py_INCREF(d);

2277 if (PyModule_AddObject(%(MODULE)s, (char *)"%(API)s", d) < 0)

2278 goto bad;

2279 }

2280 tmp.fp = f;

2281 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)

2282 cobj = PyCapsule_New(tmp.p, sig, 0);

2283 #else

2284 cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);

2285 #endif

2286 if (!cobj)

2287 goto bad;

2288 if (PyDict_SetItemString(d, name, cobj) < 0)

2289 goto bad;

2290 Py_DECREF(cobj);

2291 Py_DECREF(d);

2292 return 0;

2293 bad:

2294 Py_XDECREF(cobj);

2295 Py_XDECREF(d);

2296 return -1;

2297 }

2298 """ % {'MODULE': Naming.module_cname, 'API': Naming.api_name}

2299 )

2300

2301 function_import_utility_code = UtilityCode(

2302 proto = """

2303 static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /*proto*/

2304 """,

2305 impl = """

2306 #ifndef __PYX_HAVE_RT_ImportFunction

2307 #define __PYX_HAVE_RT_ImportFunction

2308 static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {

2309 PyObject *d = 0;

2310 PyObject *cobj = 0;

2311 union {

2312 void (*fp)(void);

2313 void *p;

2314 } tmp;

2315

2316 d = PyObject_GetAttrString(module, (char *)"%(API)s");

2317 if (!d)

2318 goto bad;

2319 cobj = PyDict_GetItemString(d, funcname);

2320 if (!cobj) {

2321 PyErr_Format(PyExc_ImportError,

2322 "%%s does not export expected C function %%s",

2323 PyModule_GetName(module), funcname);

2324 goto bad;

2325 }

2326 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)

2327 if (!PyCapsule_IsValid(cobj, sig)) {

2328 PyErr_Format(PyExc_TypeError,

2329 "C function %%s.%%s has wrong signature (expected %%s, got %%s)",

2330 PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));

2331 goto bad;

2332 }

2333 tmp.p = PyCapsule_GetPointer(cobj, sig);

2334 #else

2335 {const char *desc, *s1, *s2;

2336 desc = (const char *)PyCObject_GetDesc(cobj);

2337 if (!desc)

2338 goto bad;

2339 s1 = desc; s2 = sig;

2340 while (*s1 != '\\0' && *s1 == *s2) { s1++; s2++; }

2341 if (*s1 != *s2) {

2342 PyErr_Format(PyExc_TypeError,

2343 "C function %%s.%%s has wrong signature (expected %%s, got %%s)",

2344 PyModule_GetName(module), funcname, sig, desc);

2345 goto bad;

2346 }

2347 tmp.p = PyCObject_AsVoidPtr(cobj);}

2348 #endif

2349 *f = tmp.fp;

2350 if (!(*f))

2351 goto bad;

2352 Py_DECREF(d);

2353 return 0;

2354 bad:

2355 Py_XDECREF(d);

2356 return -1;

2357 }

2358 #endif

2359 """ % dict(API = Naming.api_name)

2360 )

2361

2362 #------------------------------------------------------------------------------------

2363

2364 register_cleanup_utility_code = UtilityCode(

2365 proto = """

2366 static int __Pyx_RegisterCleanup(void); /*proto*/

2367 static PyObject* %(module_cleanup)s(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *unused); /*proto*/

2368 static PyMethodDef cleanup_def = {__Pyx_NAMESTR("__cleanup"), (PyCFunction)&%(module_cleanup)s, METH_NOARGS, 0};

2369 """ % {'module_cleanup': Naming.cleanup_cname},

2370 impl = """

2371 static int __Pyx_RegisterCleanup(void) {

2372 /* Don't use Py_AtExit because that has a 32-call limit

2373 * and is called after python finalization.

2374 */

2375

2376 PyObject *cleanup_func = 0;

2377 PyObject *atexit = 0;

2378 PyObject *reg = 0;

2379 PyObject *args = 0;

2380 PyObject *res = 0;

2381 int ret = -1;

2382

2383 cleanup_func = PyCFunction_New(&cleanup_def, 0);

2384 args = PyTuple_New(1);

2385 if (!cleanup_func || !args)

2386 goto bad;

2387 PyTuple_SET_ITEM(args, 0, cleanup_func);

2388 cleanup_func = 0;

2389

2390 atexit = __Pyx_ImportModule("atexit");

2391 if (!atexit)

2392 goto bad;

2393 reg = __Pyx_GetAttrString(atexit, "register");

2394 if (!reg)

2395 goto bad;

2396 res = PyObject_CallObject(reg, args);

2397 if (!res)

2398 goto bad;

2399 ret = 0;

2400 bad:

2401 Py_XDECREF(cleanup_func);

2402 Py_XDECREF(atexit);

2403 Py_XDECREF(reg);

2404 Py_XDECREF(args);

2405 Py_XDECREF(res);

2406 return ret;

2407 }

2408 """)

2409

2410 import_star_utility_code = """

2411

2412 /* import_all_from is an unexposed function from ceval.c */

2413

2414 static int

2415 __Pyx_import_all_from(PyObject *locals, PyObject *v)

2416 {

2417 PyObject *all = __Pyx_GetAttrString(v, "__all__");

2418 PyObject *dict, *name, *value;

2419 int skip_leading_underscores = 0;

2420 int pos, err;

2421

2422 if (all == NULL) {

2423 if (!PyErr_ExceptionMatches(PyExc_AttributeError))

2424 return -1; /* Unexpected error */

2425 PyErr_Clear();

2426 dict = __Pyx_GetAttrString(v, "__dict__");

2427 if (dict == NULL) {

2428 if (!PyErr_ExceptionMatches(PyExc_AttributeError))

2429 return -1;

2430 PyErr_SetString(PyExc_ImportError,

2431 "from-import-* object has no __dict__ and no __all__");

2432 return -1;

2433 }

2434 all = PyMapping_Keys(dict);

2435 Py_DECREF(dict);

2436 if (all == NULL)

2437 return -1;

2438 skip_leading_underscores = 1;

2439 }

2440

2441 for (pos = 0, err = 0; ; pos++) {

2442 name = PySequence_GetItem(all, pos);

2443 if (name == NULL) {

2444 if (!PyErr_ExceptionMatches(PyExc_IndexError))

2445 err = -1;

2446 else

2447 PyErr_Clear();

2448 break;

2449 }

2450 if (skip_leading_underscores &&

2451 #if PY_MAJOR_VERSION < 3

2452 PyString_Check(name) &&

2453 PyString_AS_STRING(name)[0] == '_')

2454 #else

2455 PyUnicode_Check(name) &&

2456 PyUnicode_AS_UNICODE(name)[0] == '_')

2457 #endif

2458 {

2459 Py_DECREF(name);

2460 continue;

2461 }

2462 value = PyObject_GetAttr(v, name);

2463 if (value == NULL)

2464 err = -1;

2465 else if (PyDict_CheckExact(locals))

2466 err = PyDict_SetItem(locals, name, value);

2467 else

2468 err = PyObject_SetItem(locals, name, value);

2469 Py_DECREF(name);

2470 Py_XDECREF(value);

2471 if (err != 0)

2472 break;

2473 }

2474 Py_DECREF(all);

2475 return err;

2476 }

2477

2478

2479 static int %(IMPORT_STAR)s(PyObject* m) {

2480

2481 int i;

2482 int ret = -1;

2483 char* s;

2484 PyObject *locals = 0;

2485 PyObject *list = 0;

2486 #if PY_MAJOR_VERSION >= 3

2487 PyObject *utf8_name = 0;

2488 #endif

2489 PyObject *name;

2490 PyObject *item;

2491

2492 locals = PyDict_New(); if (!locals) goto bad;

2493 if (__Pyx_import_all_from(locals, m) < 0) goto bad;

2494 list = PyDict_Items(locals); if (!list) goto bad;

2495

2496 for(i=0; i<PyList_GET_SIZE(list); i++) {

2497 name = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 0);

2498 item = PyTuple_GET_ITEM(PyList_GET_ITEM(list, i), 1);

2499 #if PY_MAJOR_VERSION >= 3

2500 utf8_name = PyUnicode_AsUTF8String(name);

2501 if (!utf8_name) goto bad;

2502 s = PyBytes_AS_STRING(utf8_name);

2503 if (%(IMPORT_STAR_SET)s(item, name, s) < 0) goto bad;

2504 Py_DECREF(utf8_name); utf8_name = 0;

2505 #else

2506 s = PyString_AsString(name);

2507 if (!s) goto bad;

2508 if (%(IMPORT_STAR_SET)s(item, name, s) < 0) goto bad;

2509 #endif

2510 }

2511 ret = 0;

2512

2513 bad:

2514 Py_XDECREF(locals);

2515 Py_XDECREF(list);

2516 #if PY_MAJOR_VERSION >= 3

2517 Py_XDECREF(utf8_name);

2518 #endif

2519 return ret;

2520 }

2521 """ % {'IMPORT_STAR' : Naming.import_star,

2522 'IMPORT_STAR_SET' : Naming.import_star_set }

2523

2524 refnanny_utility_code = UtilityCode(proto="""

2525 #ifndef CYTHON_REFNANNY

2526 #define CYTHON_REFNANNY 0

2527 #endif

2528

2529 #if CYTHON_REFNANNY

2530 typedef struct {

2531 void (*INCREF)(void*, PyObject*, int);

2532 void (*DECREF)(void*, PyObject*, int);

2533 void (*GOTREF)(void*, PyObject*, int);

2534 void (*GIVEREF)(void*, PyObject*, int);

2535 void* (*SetupContext)(const char*, int, const char*);

2536 void (*FinishContext)(void**);

2537 } __Pyx_RefNannyAPIStruct;

2538 static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;

2539 static __Pyx_RefNannyAPIStruct * __Pyx_RefNannyImportAPI(const char *modname) {

2540 PyObject *m = NULL, *p = NULL;

2541 void *r = NULL;

2542 m = PyImport_ImportModule((char *)modname);

2543 if (!m) goto end;

2544 p = PyObject_GetAttrString(m, (char *)\"RefNannyAPI\");

2545 if (!p) goto end;

2546 r = PyLong_AsVoidPtr(p);

2547 end:

2548 Py_XDECREF(p);

2549 Py_XDECREF(m);

2550 return (__Pyx_RefNannyAPIStruct *)r;

2551 }

2552 #define __Pyx_RefNannySetupContext(name) \

2553 void *__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)

2554 #define __Pyx_RefNannyFinishContext() \

2555 __Pyx_RefNanny->FinishContext(&__pyx_refnanny)

2556 #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

2557 #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

2558 #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

2559 #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)

2560 #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r);} } while(0)

2561 #else

2562 #define __Pyx_RefNannySetupContext(name)

2563 #define __Pyx_RefNannyFinishContext()

2564 #define __Pyx_INCREF(r) Py_INCREF(r)

2565 #define __Pyx_DECREF(r) Py_DECREF(r)

2566 #define __Pyx_GOTREF(r)

2567 #define __Pyx_GIVEREF(r)

2568 #define __Pyx_XDECREF(r) Py_XDECREF(r)

2569 #endif /* CYTHON_REFNANNY */

2570 #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);} } while(0)

2571 #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r);} } while(0)

2572 """)

2573

2574

2575 main_method = UtilityCode(

2576 impl = """

2577 #ifdef __FreeBSD__

2578 #include <floatingpoint.h>

2579 #endif

2580

2581 #if PY_MAJOR_VERSION < 3

2582 int main(int argc, char** argv) {

2583 #elif defined(WIN32) || defined(MS_WINDOWS)

2584 int wmain(int argc, wchar_t **argv) {

2585 #else

2586 static int __Pyx_main(int argc, wchar_t **argv) {

2587 #endif

2588 int r = 0;

2589 PyObject* m = NULL;

2590 /* 754 requires that FP exceptions run in "no stop" mode by default,

2591 * and until C vendors implement C99's ways to control FP exceptions,

2592 * Python requires non-stop mode. Alas, some platforms enable FP

2593 * exceptions by default. Here we disable them.

2594 */

2595 #ifdef __FreeBSD__

2596 fp_except_t m;

2597

2598 m = fpgetmask();

2599 fpsetmask(m & ~FP_X_OFL);

2600 #endif

2601 Py_SetProgramName(argv[0]);

2602 Py_Initialize();

2603 PySys_SetArgv(argc, argv);

2604 %(module_is_main)s = 1;

2605 #if PY_MAJOR_VERSION < 3

2606 init%(module_name)s();

2607 #else

2608 m = PyInit_%(module_name)s();

2609 #endif

2610 if (PyErr_Occurred() != NULL) {

2611 r = 1;

2612 PyErr_Print(); /* This exits with the right code if SystemExit. */

2613 #if PY_MAJOR_VERSION < 3

2614 if (Py_FlushLine()) PyErr_Clear();

2615 #endif

2616 }

2617 Py_XDECREF(m);

2618 Py_Finalize();

2619 return r;

2620 }

2621

2622

2623 #if PY_MAJOR_VERSION >= 3 && !defined(WIN32) && !defined(MS_WINDOWS)

2624 #include <locale.h>

2625

2626 static wchar_t*

2627 __Pyx_char2wchar(char* arg)

2628 {

2629 wchar_t *res;

2630 #ifdef HAVE_BROKEN_MBSTOWCS

2631 /* Some platforms have a broken implementation of

2632 * mbstowcs which does not count the characters that

2633 * would result from conversion. Use an upper bound.

2634 */

2635 size_t argsize = strlen(arg);

2636 #else

2637 size_t argsize = mbstowcs(NULL, arg, 0);

2638 #endif

2639 size_t count;

2640 unsigned char *in;

2641 wchar_t *out;

2642 #ifdef HAVE_MBRTOWC

2643 mbstate_t mbs;

2644 #endif

2645 if (argsize != (size_t)-1) {

2646 res = (wchar_t *)malloc((argsize+1)*sizeof(wchar_t));

2647 if (!res)

2648 goto oom;

2649 count = mbstowcs(res, arg, argsize+1);

2650 if (count != (size_t)-1) {

2651 wchar_t *tmp;

2652 /* Only use the result if it contains no

2653 surrogate characters. */

2654 for (tmp = res; *tmp != 0 &&

2655 (*tmp < 0xd800 || *tmp > 0xdfff); tmp++)

2656 ;

2657 if (*tmp == 0)

2658 return res;

2659 }

2660 free(res);

2661 }

2662 /* Conversion failed. Fall back to escaping with surrogateescape. */

2663 #ifdef HAVE_MBRTOWC

2664 /* Try conversion with mbrtwoc (C99), and escape non-decodable bytes. */

2665

2666 /* Overallocate; as multi-byte characters are in the argument, the

2667 actual output could use less memory. */

2668 argsize = strlen(arg) + 1;

2669 res = malloc(argsize*sizeof(wchar_t));

2670 if (!res) goto oom;

2671 in = (unsigned char*)arg;

2672 out = res;

2673 memset(&mbs, 0, sizeof mbs);

2674 while (argsize) {

2675 size_t converted = mbrtowc(out, (char*)in, argsize, &mbs);

2676 if (converted == 0)

2677 /* Reached end of string; null char stored. */

2678 break;

2679 if (converted == (size_t)-2) {

2680 /* Incomplete character. This should never happen,

2681 since we provide everything that we have -

2682 unless there is a bug in the C library, or I

2683 misunderstood how mbrtowc works. */

2684 fprintf(stderr, "unexpected mbrtowc result -2\\n");

2685 return NULL;

2686 }

2687 if (converted == (size_t)-1) {

2688 /* Conversion error. Escape as UTF-8b, and start over

2689 in the initial shift state. */

2690 *out++ = 0xdc00 + *in++;

2691 argsize--;

2692 memset(&mbs, 0, sizeof mbs);

2693 continue;

2694 }

2695 if (*out >= 0xd800 && *out <= 0xdfff) {

2696 /* Surrogate character. Escape the original

2697 byte sequence with surrogateescape. */

2698 argsize -= converted;

2699 while (converted--)

2700 *out++ = 0xdc00 + *in++;

2701 continue;

2702 }

2703 /* successfully converted some bytes */

2704 in += converted;

2705 argsize -= converted;

2706 out++;

2707 }

2708 #else

2709 /* Cannot use C locale for escaping; manually escape as if charset

2710 is ASCII (i.e. escape all bytes > 128. This will still roundtrip

2711 correctly in the locale's charset, which must be an ASCII superset. */

2712 res = malloc((strlen(arg)+1)*sizeof(wchar_t));

2713 if (!res) goto oom;

2714 in = (unsigned char*)arg;

2715 out = res;

2716 while(*in)

2717 if(*in < 128)

2718 *out++ = *in++;

2719 else

2720 *out++ = 0xdc00 + *in++;

2721 *out = 0;

2722 #endif

2723 return res;

2724 oom:

2725 fprintf(stderr, "out of memory\\n");

2726 return NULL;

2727 }

2728

2729 int

2730 main(int argc, char **argv)

2731 {

2732 wchar_t **argv_copy = (wchar_t **)malloc(sizeof(wchar_t*)*argc);

2733 /* We need a second copies, as Python might modify the first one. */

2734 wchar_t **argv_copy2 = (wchar_t **)malloc(sizeof(wchar_t*)*argc);

2735 int i, res;

2736 char *oldloc;

2737 if (!argv_copy || !argv_copy2) {

2738 fprintf(stderr, "out of memory\\n");

2739 return 1;

2740 }

2741 oldloc = strdup(setlocale(LC_ALL, NULL));

2742 setlocale(LC_ALL, "");

2743 for (i = 0; i < argc; i++) {

2744 argv_copy2[i] = argv_copy[i] = __Pyx_char2wchar(argv[i]);

2745 if (!argv_copy[i])

2746 return 1;

2747 }

2748 setlocale(LC_ALL, oldloc);

2749 free(oldloc);

2750 res = __Pyx_main(argc, argv_copy);

2751 for (i = 0; i < argc; i++) {

2752 free(argv_copy2[i]);

2753 }

2754 free(argv_copy);

2755 free(argv_copy2);

2756 return res;

2757 }

2758 #endif

2759 """)

2760

2761 packed_struct_utility_code = UtilityCode(proto="""

2762 #if defined(__GNUC__)

2763 #define __Pyx_PACKED __attribute__((__packed__))

2764 #else

2765 #define __Pyx_PACKED

2766 #endif

2767 """, impl="", proto_block='utility_code_proto_before_types')