1 #

2 # Pyrex - Module parse tree node

3 #

4

5 import os, time

6 from PyrexTypes import CPtrType

7 import Future

8

9 try:

10 set

11 except NameError: # Python 2.3

12 from sets import Set as set

13

14 import Annotate

15 import Code

16 import Naming

17 import Nodes

18 import Options

19 import PyrexTypes

20 import TypeSlots

21 import Version

22 import DebugFlags

23

24 from Errors import error, warning

25 from PyrexTypes import py_object_type

26 from Cython.Utils import open_new_file, replace_suffix

27 from Code import UtilityCode

28 from StringEncoding import escape_byte_string, EncodedString

29

30

31 def check_c_declarations_pxd(module_node):

32 module_node.scope.check_c_classes_pxd()

33 return module_node

34

35 def check_c_declarations(module_node):

36 module_node.scope.check_c_classes()

37 module_node.scope.check_c_functions()

38 return module_node

39

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

41 # doc string or None

42 # body StatListNode

43 #

44 # referenced_modules [ModuleScope]

45 # full_module_name string

46 #

47 # scope The module scope.

48 # compilation_source A CompilationSource (see Main)

49 # directives Top-level compiler directives

50

51 child_attrs = ["body"]

52 directives = None

53

54 def analyse_declarations(self, env):

55 if Options.embed_pos_in_docstring:

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

57 if not self.doc is None:

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

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

60 else:

61 env.doc = self.doc

62 env.directives = self.directives

63 self.body.analyse_declarations(env)

64

65 def process_implementation(self, options, result):

66 env = self.scope

67 env.return_type = PyrexTypes.c_void_type

68 self.referenced_modules = []

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

70 if options.recursive:

71 self.generate_dep_file(env, result)

72 self.generate_c_code(env, options, result)

73 self.generate_h_code(env, options, result)

74 self.generate_api_code(env, result)

75

76 def has_imported_c_functions(self):

77 for module in self.referenced_modules:

78 for entry in module.cfunc_entries:

79 if entry.defined_in_pxd:

80 return 1

81 return 0

82

83 def generate_dep_file(self, env, result):

84 modules = self.referenced_modules

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

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

87 f = open(dep_file, "w")

88 try:

89 for module in modules:

90 if module is not env:

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

92 for path in module.included_files:

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

94 finally:

95 f.close()

96

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

98 def h_entries(entries, pxd = 0):

99 return [entry for entry in entries

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

101 h_types = h_entries(env.type_entries)

102 h_vars = h_entries(env.var_entries)

103 h_funcs = h_entries(env.cfunc_entries)

104 h_extension_types = h_entries(env.c_class_entries)

105 if h_types or h_vars or h_funcs or h_extension_types:

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

107 h_code = Code.CCodeWriter()

108 Code.GlobalState(h_code)

109 if options.generate_pxi:

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

111 i_code = Code.PyrexCodeWriter(result.i_file)

112 else:

113 i_code = None

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

115 h_code.put_h_guard(guard)

116 self.generate_extern_c_macro_definition(h_code)

117 self.generate_type_header_code(h_types, h_code)

118 h_code.putln("")

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

120 if h_vars:

121 h_code.putln("")

122 for entry in h_vars:

123 self.generate_public_declaration(entry, h_code, i_code)

124 if h_funcs:

125 h_code.putln("")

126 for entry in h_funcs:

127 self.generate_public_declaration(entry, h_code, i_code)

128 if h_extension_types:

129 h_code.putln("")

130 for entry in h_extension_types:

131 self.generate_cclass_header_code(entry.type, h_code)

132 if i_code:

133 self.generate_cclass_include_code(entry.type, i_code)

134 h_code.putln("")

135 h_code.putln("#endif")

136 h_code.putln("")

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

138 h_code.putln("")

139 h_code.putln("#endif")

140

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

142

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

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

145 Naming.extern_c_macro,

146 entry.type.declaration_code(

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

148 if i_code:

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

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

151

152 def api_name(self, env):

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

154

155 def generate_api_code(self, env, result):

156 api_funcs = []

157 public_extension_types = []

158 has_api_extension_types = 0

159 for entry in env.cfunc_entries:

160 if entry.api:

161 api_funcs.append(entry)

162 for entry in env.c_class_entries:

163 if entry.visibility == 'public':

164 public_extension_types.append(entry)

165 if entry.api:

166 has_api_extension_types = 1

167 if api_funcs or has_api_extension_types:

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

169 h_code = Code.CCodeWriter()

170 Code.GlobalState(h_code)

171 name = self.api_name(env)

172 guard = Naming.api_guard_prefix + name

173 h_code.put_h_guard(guard)

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

175 if result.h_file:

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

177 for entry in public_extension_types:

178 type = entry.type

179 h_code.putln("")

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

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

182 type.typeobj_cname, type.typeptr_cname))

183 if api_funcs:

184 h_code.putln("")

185 for entry in api_funcs:

186 type = CPtrType(entry.type)

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

188 h_code.putln("")

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

190 h_code.put(import_module_utility_code.impl)

191 h_code.putln("")

192 h_code.putln("#endif")

193 if api_funcs:

194 h_code.putln("")

195 h_code.put(function_import_utility_code.impl)

196 if public_extension_types:

197 h_code.putln("")

198 h_code.put(type_import_utility_code.impl)

199 h_code.putln("")

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

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

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

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

204 for entry in api_funcs:

205 sig = entry.type.signature_string()

206 h_code.putln(

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

208 entry.name,

209 entry.cname,

210 sig))

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

212 for entry in public_extension_types:

213 self.generate_type_import_call(

214 entry.type, h_code,

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

216 h_code.putln("return 0;")

217 h_code.putln("bad:")

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

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

220 h_code.putln("}")

221 h_code.putln("")

222 h_code.putln("#endif")

223

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

225

226 def generate_cclass_header_code(self, type, h_code):

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

228 Naming.extern_c_macro,

229 type.typeobj_cname))

230 #self.generate_obj_struct_definition(type, h_code)

231

232 def generate_cclass_include_code(self, type, i_code):

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

234 type.module_name, type.name))

235 i_code.indent()

236 var_entries = type.scope.var_entries

237 if var_entries:

238 for entry in var_entries:

239 i_code.putln("cdef %s" %

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

241 else:

242 i_code.putln("pass")

243 i_code.dedent()

244

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

246 modules = self.referenced_modules

247

248 if Options.annotate or options.annotate:

249 emit_linenums = False

250 rootwriter = Annotate.AnnotationCCodeWriter()

251 else:

252 emit_linenums = options.emit_linenums

253 rootwriter = Code.CCodeWriter(emit_linenums=emit_linenums)

254 globalstate = Code.GlobalState(rootwriter, emit_linenums)

255 globalstate.initialize_main_c_code()

256 h_code = globalstate['h_code']

257

258 self.generate_module_preamble(env, modules, h_code)

259

260 globalstate.module_pos = self.pos

261 globalstate.directives = self.directives

262

263 globalstate.use_utility_code(refnanny_utility_code)

264

265 code = globalstate['before_global_var']

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

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

268 code.putln("")

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

270

271 code = globalstate['all_the_rest']

272

273 self.generate_cached_builtins_decls(env, code)

274 self.body.generate_function_definitions(env, code)

275 code.mark_pos(None)

276 self.generate_typeobj_definitions(env, code)

277 self.generate_method_table(env, code)

278 self.generate_filename_init_prototype(code)

279 if env.has_import_star:

280 self.generate_import_star(env, code)

281 self.generate_pymoduledef_struct(env, code)

282

283 # init_globals is inserted before this

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

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

286 if Options.embed:

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

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

289

290 self.generate_declarations_for_modules(env, modules, globalstate)

291 h_code.write('\n')

292

293 for utilcode in env.utility_code_list:

294 globalstate.use_utility_code(utilcode)

295 globalstate.finalize_main_c_code()

296

297 f = open_new_file(result.c_file)

298 rootwriter.copyto(f)

299 f.close()

300 result.c_file_generated = 1

301 if Options.annotate or options.annotate:

302 self.annotate(rootwriter)

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

304

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

306 if env not in modules_seen:

307 modules_seen[env] = 1

308 for imported_module in env.cimported_modules:

309 self.find_referenced_modules(imported_module, module_list, modules_seen)

310 module_list.append(env)

311

312 def sort_types_by_inheritance(self, type_dict, getkey):

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

314 # its first child

315 type_items = type_dict.items()

316 type_list = []

317 for i, item in enumerate(type_items):

318 key, new_entry = item

319

320 # collect all base classes to check for children

321 hierarchy = set()

322 base = new_entry

323 while base:

324 base_type = base.type.base_type

325 if not base_type:

326 break

327 base_key = getkey(base_type)

328 hierarchy.add(base_key)

329 base = type_dict.get(base_key)

330 new_entry.base_keys = hierarchy

331

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

333 for j in range(i):

334 entry = type_list[j]

335 if key in entry.base_keys:

336 type_list.insert(j, new_entry)

337 break

338 else:

339 type_list.append(new_entry)

340 return type_list

341

342 def sort_type_hierarchy(self, module_list, env):

343 vtab_dict = {}

344 vtabslot_dict = {}

345 for module in module_list:

346 for entry in module.c_class_entries:

347 if not entry.in_cinclude:

348 type = entry.type

349 if type.vtabstruct_cname:

350 vtab_dict[type.vtabstruct_cname] = entry

351 all_defined_here = module is env

352 for entry in module.type_entries:

353 if all_defined_here or entry.defined_in_pxd:

354 type = entry.type

355 if type.is_extension_type and not entry.in_cinclude:

356 type = entry.type

357 vtabslot_dict[type.objstruct_cname] = entry

358

359 def vtabstruct_cname(entry_type):

360 return entry_type.vtabstruct_cname

361 vtab_list = self.sort_types_by_inheritance(

362 vtab_dict, vtabstruct_cname)

363

364 def objstruct_cname(entry_type):

365 return entry_type.objstruct_cname

366 vtabslot_list = self.sort_types_by_inheritance(

367 vtabslot_dict, objstruct_cname)

368

369 return (vtab_list, vtabslot_list)

370

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

372 vtabslot_entries = set(vtabslot_list)

373 for module in modules:

374 definition = module is env

375 if definition:

376 type_entries = module.type_entries

377 else:

378 type_entries = []

379 for entry in module.type_entries:

380 if entry.defined_in_pxd:

381 type_entries.append(entry)

382 for entry in type_entries:

383 if not entry.in_cinclude:

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

385 type = entry.type

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

387 self.generate_typedef(entry, code)

388 elif type.is_struct_or_union:

389 self.generate_struct_union_definition(entry, code)

390 elif type.is_enum:

391 self.generate_enum_definition(entry, code)

392 elif type.is_extension_type and entry not in vtabslot_entries:

393 self.generate_obj_struct_definition(type, code)

394 for entry in vtabslot_list:

395 self.generate_obj_struct_definition(entry.type, code)

396 for entry in vtab_list:

397 self.generate_typeobject_predeclaration(entry, code)

398 self.generate_exttype_vtable_struct(entry, code)

399 self.generate_exttype_vtabptr_declaration(entry, code)

400

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

402 typecode = globalstate['type_declarations']

403 typecode.putln("")

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

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

406 self.generate_type_definitions(

407 env, modules, vtab_list, vtabslot_list, typecode)

408 modulecode = globalstate['module_declarations']

409 for module in modules:

410 defined_here = module is env

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

412 module.qualified_name.encode("ASCII", "ignore"))

413 self.generate_global_declarations(module, modulecode, defined_here)

414 self.generate_cfunction_predeclarations(module, modulecode, defined_here)

415

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

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

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

419 code.putln("")

420 code.putln("#define PY_SSIZE_T_CLEAN")

421 for filename in env.python_include_files:

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

423 code.putln("#ifndef Py_PYTHON_H")

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

425 code.putln("#else")

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

427

428 code.put("""

429 #ifndef PY_LONG_LONG

430 #define PY_LONG_LONG LONG_LONG

431 #endif

432 #ifndef DL_EXPORT

433 #define DL_EXPORT(t) t

434 #endif

435 #if PY_VERSION_HEX < 0x02040000

436 #define METH_COEXIST 0

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

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

439 #endif

440

441 #if PY_VERSION_HEX < 0x02050000

442 typedef int Py_ssize_t;

443 #define PY_SSIZE_T_MAX INT_MAX

444 #define PY_SSIZE_T_MIN INT_MIN

445 #define PY_FORMAT_SIZE_T \"\"

446 #define PyInt_FromSsize_t(z) PyInt_FromLong(z)

447 #define PyInt_AsSsize_t(o) PyInt_AsLong(o)

448 #define PyNumber_Index(o) PyNumber_Int(o)

449 #define PyIndex_Check(o) PyNumber_Check(o)

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

451 #endif

452

453 #if PY_VERSION_HEX < 0x02060000

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

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

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

457 #define PyVarObject_HEAD_INIT(type, size) \\

458 PyObject_HEAD_INIT(type) size,

459 #define PyType_Modified(t)

460

461 typedef struct {

462 void *buf;

463 PyObject *obj;

464 Py_ssize_t len;

465 Py_ssize_t itemsize;

466 int readonly;

467 int ndim;

468 char *format;

469 Py_ssize_t *shape;

470 Py_ssize_t *strides;

471 Py_ssize_t *suboffsets;

472 void *internal;

473 } Py_buffer;

474

475 #define PyBUF_SIMPLE 0

476 #define PyBUF_WRITABLE 0x0001

477 #define PyBUF_FORMAT 0x0004

478 #define PyBUF_ND 0x0008

479 #define PyBUF_STRIDES (0x0010 | PyBUF_ND)

480 #define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)

481 #define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)

482 #define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)

483 #define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)

484

485 #endif

486

487 #if PY_MAJOR_VERSION < 3

488 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"

489 #else

490 #define __Pyx_BUILTIN_MODULE_NAME "builtins"

491 #endif

492

493 #if PY_MAJOR_VERSION >= 3

494 #define Py_TPFLAGS_CHECKTYPES 0

495 #define Py_TPFLAGS_HAVE_INDEX 0

496 #endif

497

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

499 #define Py_TPFLAGS_HAVE_NEWBUFFER 0

500 #endif

501

502 #if PY_MAJOR_VERSION >= 3

503 #define PyBaseString_Type PyUnicode_Type

504 #define PyString_Type PyUnicode_Type

505 #define PyString_CheckExact PyUnicode_CheckExact

506 #else

507 #define PyBytes_Type PyString_Type

508 #define PyBytes_CheckExact PyString_CheckExact

509 #endif

510

511 #if PY_MAJOR_VERSION >= 3

512 #define PyInt_Type PyLong_Type

513 #define PyInt_Check(op) PyLong_Check(op)

514 #define PyInt_CheckExact(op) PyLong_CheckExact(op)

515 #define PyInt_FromString PyLong_FromString

516 #define PyInt_FromUnicode PyLong_FromUnicode

517 #define PyInt_FromLong PyLong_FromLong

518 #define PyInt_FromSize_t PyLong_FromSize_t

519 #define PyInt_FromSsize_t PyLong_FromSsize_t

520 #define PyInt_AsLong PyLong_AsLong

521 #define PyInt_AS_LONG PyLong_AS_LONG

522 #define PyInt_AsSsize_t PyLong_AsSsize_t

523 #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask

524 #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask

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

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

527 #else

528 """)

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

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

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

532 else:

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

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

535 code.put("""

536 #endif

537

538 #if PY_MAJOR_VERSION >= 3

539 #define PyMethod_New(func, self, klass) PyInstanceMethod_New(func)

540 #endif

541

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

543 #ifndef __stdcall

544 #define __stdcall

545 #endif

546 #ifndef __cdecl

547 #define __cdecl

548 #endif

549 #ifndef __fastcall

550 #define __fastcall

551 #endif

552 #else

553 #define _USE_MATH_DEFINES

554 #endif

555

556 #if PY_VERSION_HEX < 0x02050000

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

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

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

560 #else

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

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

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

564 #endif

565

566 #if PY_VERSION_HEX < 0x02050000

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

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

569 #else

570 #define __Pyx_NAMESTR(n) (n)

571 #define __Pyx_DOCSTR(n) (n)

572 #endif

573 """)

574

575 self.generate_extern_c_macro_definition(code)

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

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

578 self.generate_includes(env, cimported_modules, code)

579 if env.directives['ccomplex']:

580 code.putln("")

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

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

583 code.putln("#endif")

584 code.putln("")

585 code.put(Nodes.utility_function_predeclarations)

586 code.put(PyrexTypes.type_conversion_predeclarations)

587 code.put(Nodes.branch_prediction_macros)

588 code.putln('')

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

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

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

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

593 if Options.pre_import is not None:

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

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

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

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

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

599 code.putln('static const char **%s;' % Naming.filetable_cname)

600

601 # XXX this is a mess

602 for utility_code in PyrexTypes.c_int_from_py_function.specialize_list:

603 env.use_utility_code(utility_code)

604 for utility_code in PyrexTypes.c_long_from_py_function.specialize_list:

605 env.use_utility_code(utility_code)

606

607 def generate_extern_c_macro_definition(self, code):

608 name = Naming.extern_c_macro

609 code.putln("#ifdef __cplusplus")

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

611 code.putln("#else")

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

613 code.putln("#endif")

614

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

616 includes = []

617 for filename in env.include_files:

618 # fake decoding of filenames to their original byte sequence

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

620

621 def generate_filename_table(self, code):

622 code.putln("")

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

624 if code.globalstate.filename_list:

625 for source_desc in code.globalstate.filename_list:

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

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

628 code.putln('"%s",' %

629 escaped_filename)

630 else:

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

632 code.putln("0")

633 code.putln("};")

634

635 def generate_type_predeclarations(self, env, code):

636 pass

637

638 def generate_type_header_code(self, type_entries, code):

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

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

641 #for entry in env.type_entries:

642 for entry in type_entries:

643 if not entry.in_cinclude:

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

645 type = entry.type

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

647 self.generate_typedef(entry, code)

648 elif type.is_struct_or_union:

649 self.generate_struct_union_definition(entry, code)

650 elif type.is_enum:

651 self.generate_enum_definition(entry, code)

652 elif type.is_extension_type:

653 self.generate_obj_struct_definition(type, code)

654

655 def generate_gcc33_hack(self, env, code):

656 # Workaround for spurious warning generation in gcc 3.3

657 code.putln("")

658 for entry in env.c_class_entries:

659 type = entry.type

660 if not type.typedef_flag:

661 name = type.objstruct_cname

662 if name.startswith("__pyx_"):

663 tail = name[6:]

664 else:

665 tail = name

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

667 name, tail))

668

669 def generate_typedef(self, entry, code):

670 base_type = entry.type.typedef_base_type

671 if base_type.is_numeric:

672 writer = code.globalstate['numeric_typedefs']

673 else:

674 writer = code

675 writer.putln("")

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

677

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

679 if type.typedef_flag:

680 header = "typedef %s {" % kind

681 footer = "} %s;" % name

682 else:

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

684 footer = "};"

685 return header, footer

686

687 def generate_struct_union_definition(self, entry, code):

688 code.mark_pos(entry.pos)

689 type = entry.type

690 scope = type.scope

691 if scope:

692 kind = type.kind

693 packed = type.is_struct and type.packed

694 if packed:

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

696 code.globalstate.use_utility_code(packed_struct_utility_code)

697 header, footer = \

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

699 code.putln("")

700 if packed:

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

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

703 code.putln("#endif")

704 code.putln(header)

705 var_entries = scope.var_entries

706 if not var_entries:

707 error(entry.pos,

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

709 " 'cdef extern from' block")

710 for attr in var_entries:

711 code.putln(

712 "%s;" %

713 attr.type.declaration_code(attr.cname))

714 code.putln(footer)

715 if packed:

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

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

718 code.putln("#endif")

719

720 def generate_enum_definition(self, entry, code):

721 code.mark_pos(entry.pos)

722 type = entry.type

723 name = entry.cname or entry.name or ""

724 header, footer = \

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

726 code.putln("")

727 code.putln(header)

728 enum_values = entry.enum_values

729 if not enum_values:

730 error(entry.pos,

731 "Empty enum definition not allowed outside a"

732 " 'cdef extern from' block")

733 else:

734 last_entry = enum_values[-1]

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

736 for value_entry in enum_values:

737 if value_entry.value_node is not None:

738 value_entry.value_node.generate_evaluation_code(code)

739

740 for value_entry in enum_values:

741 if value_entry.value_node is None:

742 value_code = value_entry.cname

743 else:

744 value_code = ("%s = %s" % (

745 value_entry.cname,

746 value_entry.value_node.result()))

747 if value_entry is not last_entry:

748 value_code += ","

749 code.putln(value_code)

750 code.putln(footer)

751

752 def generate_typeobject_predeclaration(self, entry, code):

753 code.putln("")

754 name = entry.type.typeobj_cname

755 if name:

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

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

758 Naming.extern_c_macro,

759 name))

760 elif entry.visibility == 'public':

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

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

763 Naming.extern_c_macro,

764 name))

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

766 #else:

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

768

769 def generate_exttype_vtable_struct(self, entry, code):

770 code.mark_pos(entry.pos)

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

772 type = entry.type

773 scope = type.scope

774 if type.vtabstruct_cname:

775 code.putln("")

776 code.putln(

777 "struct %s {" %

778 type.vtabstruct_cname)

779 if type.base_type and type.base_type.vtabstruct_cname:

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

781 type.base_type.vtabstruct_cname,

782 Naming.obj_base_cname))

783 for method_entry in scope.cfunc_entries:

784 if not method_entry.is_inherited:

785 code.putln(

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

787 code.putln(

788 "};")

789

790 def generate_exttype_vtabptr_declaration(self, entry, code):

791 code.mark_pos(entry.pos)

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

793 type = entry.type

794 if type.vtabptr_cname:

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

796 type.vtabstruct_cname,

797 type.vtabptr_cname))

798

799 def generate_obj_struct_definition(self, type, code):

800 code.mark_pos(type.pos)

801 # Generate object struct definition for an

802 # extension type.

803 if not type.scope:

804 return # Forward declared but never defined

805 header, footer = \

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

807 code.putln("")

808 code.putln(header)

809 base_type = type.base_type

810 if base_type:

811 code.putln(

812 "%s%s %s;" % (

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

814 base_type.objstruct_cname,

815 Naming.obj_base_cname))

816 else:

817 code.putln(

818 "PyObject_HEAD")

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

820 code.putln(

821 "struct %s *%s;" % (

822 type.vtabstruct_cname,

823 type.vtabslot_cname))

824 for attr in type.scope.var_entries:

825 code.putln(

826 "%s;" %

827 attr.type.declaration_code(attr.cname))

828 code.putln(footer)

829 if type.objtypedef_cname is not None:

830 # Only for exposing public typedef name.

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

832

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

834 code.putln("")

835 for entry in env.c_class_entries:

836 if definition or entry.defined_in_pxd:

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

838 entry.type.typeptr_cname)

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

840 dll_linkage = "DL_EXPORT", definition = definition)

841

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

843 for entry in env.cfunc_entries:

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

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

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

847 dll_linkage = "DL_EXPORT"

848 else:

849 dll_linkage = None

850 type = entry.type

851 if not definition and entry.defined_in_pxd:

852 type = CPtrType(type)

853 header = type.declaration_code(entry.cname,

854 dll_linkage = dll_linkage)

855 if entry.visibility == 'private':

856 storage_class = "static "

857 elif entry.visibility == 'public':

858 storage_class = ""

859 else:

860 storage_class = "%s " % Naming.extern_c_macro

861 if entry.func_modifiers:

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

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

864 else:

865 modifiers = ''

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

867 storage_class,

868 modifiers,

869 header))

870

871 def generate_typeobj_definitions(self, env, code):

872 full_module_name = env.qualified_name

873 for entry in env.c_class_entries:

874 #print "generate_typeobj_definitions:", entry.name

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

876 if entry.visibility != 'extern':

877 type = entry.type

878 scope = type.scope

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

880 self.generate_exttype_vtable(scope, code)

881 self.generate_new_function(scope, code)

882 self.generate_dealloc_function(scope, code)

883 if scope.needs_gc():

884 self.generate_traverse_function(scope, code)

885 self.generate_clear_function(scope, code)

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

887 self.generate_getitem_int_function(scope, code)

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

889 self.generate_ass_subscript_function(scope, code)

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

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

892 self.generate_ass_slice_function(scope, code)

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

894 self.generate_getattro_function(scope, code)

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

896 self.generate_setattro_function(scope, code)

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

898 self.generate_descr_get_function(scope, code)

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

900 self.generate_descr_set_function(scope, code)

901 self.generate_property_accessors(scope, code)

902 self.generate_method_table(scope, code)

903 self.generate_member_table(scope, code)

904 self.generate_getset_table(scope, code)

905 self.generate_typeobj_definition(full_module_name, entry, code)

906

907 def generate_exttype_vtable(self, scope, code):

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

909 type = scope.parent_type

910 if type.vtable_cname:

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

912 type.vtabstruct_cname,

913 type.vtable_cname))

914

915 def generate_self_cast(self, scope, code):

916 type = scope.parent_type

917 code.putln(

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

919 type.declaration_code("p"),

920 type.declaration_code("")))

921

922 def generate_new_function(self, scope, code):

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

924 slot_func = scope.mangle_internal("tp_new")

925 type = scope.parent_type

926 base_type = type.base_type

927 py_attrs = []

928 for entry in scope.var_entries:

929 if entry.type.is_pyobject:

930 py_attrs.append(entry)

931 need_self_cast = type.vtabslot_cname or py_attrs

932 code.putln("")

933 code.putln(

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

935 % scope.mangle_internal("tp_new"))

936 if need_self_cast:

937 code.putln(

938 "%s;"

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

940 if base_type:

941 tp_new = TypeSlots.get_base_slot_function(scope, tp_slot)

942 if tp_new is None:

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

944 code.putln(

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

946 else:

947 code.putln(

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

949 code.putln(

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

951 if need_self_cast:

952 code.putln(

953 "p = %s;"

954 % type.cast_code("o"))

955 #if need_self_cast:

956 # self.generate_self_cast(scope, code)

957 if type.vtabslot_cname:

958 vtab_base_type = type

959 while vtab_base_type.base_type and vtab_base_type.base_type.vtabstruct_cname:

960 vtab_base_type = vtab_base_type.base_type

961 if vtab_base_type is not type:

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

963 else:

964 struct_type_cast = ""

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

966 type.vtabslot_cname,

967 struct_type_cast, type.vtabptr_cname))

968 for entry in py_attrs:

969 if entry.name == "__weakref__":

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

971 else:

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

973 entry = scope.lookup_here("__new__")

974 if entry and entry.is_special:

975 if entry.trivial_signature:

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

977 else:

978 cinit_args = "o, a, k"

979 code.putln(

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

981 (entry.func_cname, cinit_args))

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

983 code.putln(

984 "}")

985 code.putln(

986 "return o;")

987 code.putln(

988 "}")

989

990 def generate_dealloc_function(self, scope, code):

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

992 slot_func = scope.mangle_internal("tp_dealloc")

993 base_type = scope.parent_type.base_type

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

995 return # never used

996 code.putln("")

997 code.putln(

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

999 % scope.mangle_internal("tp_dealloc"))

1000 py_attrs = []

1001 weakref_slot = scope.lookup_here("__weakref__")

1002 for entry in scope.var_entries:

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

1004 py_attrs.append(entry)

1005 if py_attrs or weakref_slot in scope.var_entries:

1006 self.generate_self_cast(scope, code)

1007 self.generate_usr_dealloc_call(scope, code)

1008 if weakref_slot in scope.var_entries:

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

1010 for entry in py_attrs:

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

1012 if base_type:

1013 tp_dealloc = TypeSlots.get_base_slot_function(scope, tp_slot)

1014 if tp_dealloc is None:

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

1016 code.putln(

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

1018 else:

1019 code.putln(

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

1021 code.putln(

1022 "}")

1023

1024 def generate_usr_dealloc_call(self, scope, code):

1025 entry = scope.lookup_here("__dealloc__")

1026 if entry:

1027 code.putln(

1028 "{")

1029 code.putln(

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

1031 code.putln(

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

1033 code.putln(

1034 "++Py_REFCNT(o);")

1035 code.putln(

1036 "%s(o);" %

1037 entry.func_cname)

1038 code.putln(

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

1040 code.putln(

1041 "--Py_REFCNT(o);")

1042 code.putln(

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

1044 code.putln(

1045 "}")

1046

1047 def generate_traverse_function(self, scope, code):

1048 tp_slot = TypeSlots.GCDependentSlot("tp_traverse")

1049 slot_func = scope.mangle_internal("tp_traverse")

1050 base_type = scope.parent_type.base_type

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

1052 return # never used

1053 code.putln("")

1054 code.putln(

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

1056 % slot_func)

1057 py_attrs = []

1058 for entry in scope.var_entries:

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

1060 py_attrs.append(entry)

1061 if base_type or py_attrs:

1062 code.putln("int e;")

1063 if py_attrs:

1064 self.generate_self_cast(scope, code)

1065 if base_type:

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

1067 static_call = TypeSlots.get_base_slot_function(scope, tp_slot)

1068 if static_call:

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

1070 else:

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

1072 code.putln(

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

1074 base_type.typeptr_cname)

1075 code.putln("}")

1076 for entry in py_attrs:

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

1078 code.putln(

1079 "if (%s) {"

1080 % var_code)

1081 if entry.type.is_extension_type:

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

1083 code.putln(

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

1085 % var_code)

1086 code.putln(

1087 "}")

1088 code.putln(

1089 "return 0;")

1090 code.putln(

1091 "}")

1092

1093 def generate_clear_function(self, scope, code):

1094 tp_slot = TypeSlots.GCDependentSlot("tp_clear")

1095 slot_func = scope.mangle_internal("tp_clear")

1096 base_type = scope.parent_type.base_type

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

1098 return # never used

1099 code.putln("")

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

1101 py_attrs = []

1102 for entry in scope.var_entries:

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

1104 py_attrs.append(entry)

1105 if py_attrs:

1106 self.generate_self_cast(scope, code)

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

1108 if base_type:

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

1110 static_call = TypeSlots.get_base_slot_function(scope, tp_slot)

1111 if static_call:

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

1113 else:

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

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

1116 code.putln("}")

1117 for entry in py_attrs:

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

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

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

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

1122 code.putln(

1123 "return 0;")

1124 code.putln(

1125 "}")

1126

1127 def generate_getitem_int_function(self, scope, code):

1128 # This function is put into the sq_item slot when

1129 # a __getitem__ method is present. It converts its

1130 # argument to a Python integer and calls mp_subscript.

1131 code.putln(

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

1133 scope.mangle_internal("sq_item"))

1134 code.putln(

1135 "PyObject *r;")

1136 code.putln(

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

1138 code.putln(

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

1140 code.putln(

1141 "Py_DECREF(x);")

1142 code.putln(

1143 "return r;")

1144 code.putln(

1145 "}")

1146

1147 def generate_ass_subscript_function(self, scope, code):

1148 # Setting and deleting an item are both done through

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

1150 # or __delitem__, or raise an exception.

1151 base_type = scope.parent_type.base_type

1152 set_entry = scope.lookup_here("__setitem__")

1153 del_entry = scope.lookup_here("__delitem__")

1154 code.putln("")

1155 code.putln(

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

1157 scope.mangle_internal("mp_ass_subscript"))

1158 code.putln(

1159 "if (v) {")

1160 if set_entry:

1161 code.putln(

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

1163 set_entry.func_cname)

1164 else:

1165 self.generate_guarded_basetype_call(

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

1167 code.putln(

1168 "PyErr_Format(PyExc_NotImplementedError,")

1169 code.putln(

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

1171 code.putln(

1172 "return -1;")

1173 code.putln(

1174 "}")

1175 code.putln(

1176 "else {")

1177 if del_entry:

1178 code.putln(

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

1180 del_entry.func_cname)

1181 else:

1182 self.generate_guarded_basetype_call(

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

1184 code.putln(

1185 "PyErr_Format(PyExc_NotImplementedError,")

1186 code.putln(

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

1188 code.putln(

1189 "return -1;")

1190 code.putln(

1191 "}")

1192 code.putln(

1193 "}")

1194

1195 def generate_guarded_basetype_call(

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

1197 if base_type:

1198 base_tpname = base_type.typeptr_cname

1199 if substructure:

1200 code.putln(

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

1202 base_tpname, substructure, base_tpname, substructure, slot))

1203 code.putln(

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

1205 base_tpname, substructure, slot, args))

1206 else:

1207 code.putln(

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

1209 base_tpname, slot))

1210 code.putln(

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

1212 base_tpname, slot, args))

1213

1214 def generate_ass_slice_function(self, scope, code):

1215 # Setting and deleting a slice are both done through

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

1217 # or __delslice__, or raise an exception.

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

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

1220 code.putln("#endif")

1221 base_type = scope.parent_type.base_type

1222 set_entry = scope.lookup_here("__setslice__")

1223 del_entry = scope.lookup_here("__delslice__")

1224 code.putln("")

1225 code.putln(

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

1227 scope.mangle_internal("sq_ass_slice"))

1228 code.putln(

1229 "if (v) {")

1230 if set_entry:

1231 code.putln(

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

1233 set_entry.func_cname)

1234 else:

1235 self.generate_guarded_basetype_call(

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

1237 code.putln(

1238 "PyErr_Format(PyExc_NotImplementedError,")

1239 code.putln(

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

1241 code.putln(

1242 "return -1;")

1243 code.putln(

1244 "}")

1245 code.putln(

1246 "else {")

1247 if del_entry:

1248 code.putln(

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

1250 del_entry.func_cname)

1251 else:

1252 self.generate_guarded_basetype_call(

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

1254 code.putln(

1255 "PyErr_Format(PyExc_NotImplementedError,")

1256 code.putln(

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

1258 code.putln(

1259 "return -1;")

1260 code.putln(

1261 "}")

1262 code.putln(

1263 "}")

1264

1265 def generate_getattro_function(self, scope, code):

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

1267 # PyObject_GenericGetAttr.

1268 #

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

1270 #

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

1272 def lookup_here_or_base(n,type=None):

1273 # Recursive lookup

1274 if type is None:

1275 type = scope.parent_type

1276 r = type.scope.lookup_here(n)

1277 if r is None and \

1278 type.base_type is not None:

1279 return lookup_here_or_base(n,type.base_type)

1280 else:

1281 return r

1282 getattr_entry = lookup_here_or_base("__getattr__")

1283 getattribute_entry = lookup_here_or_base("__getattribute__")

1284 code.putln("")

1285 code.putln(

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

1287 % scope.mangle_internal("tp_getattro"))

1288 if getattribute_entry is not None:

1289 code.putln(

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

1291 getattribute_entry.func_cname)

1292 else:

1293 code.putln(

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

1295 if getattr_entry is not None:

1296 code.putln(

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

1298 code.putln(

1299 "PyErr_Clear();")

1300 code.putln(

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

1302 getattr_entry.func_cname)

1303 code.putln(

1304 "}")

1305 code.putln(

1306 "return v;")

1307 code.putln(

1308 "}")

1309

1310 def generate_setattro_function(self, scope, code):

1311 # Setting and deleting an attribute are both done through

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

1313 # or __delattr__ or fall back on PyObject_GenericSetAttr.

1314 base_type = scope.parent_type.base_type

1315 set_entry = scope.lookup_here("__setattr__")

1316 del_entry = scope.lookup_here("__delattr__")

1317 code.putln("")

1318 code.putln(

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

1320 scope.mangle_internal("tp_setattro"))

1321 code.putln(

1322 "if (v) {")

1323 if set_entry:

1324 code.putln(

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

1326 set_entry.func_cname)

1327 else:

1328 self.generate_guarded_basetype_call(

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

1330 code.putln(

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

1332 code.putln(

1333 "}")

1334 code.putln(

1335 "else {")

1336 if del_entry:

1337 code.putln(

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

1339 del_entry.func_cname)

1340 else:

1341 self.generate_guarded_basetype_call(

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

1343 code.putln(

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

1345 code.putln(

1346 "}")

1347 code.putln(

1348 "}")

1349

1350 def generate_descr_get_function(self, scope, code):

1351 # The __get__ function of a descriptor object can be

1352 # called with NULL for the second or third arguments

1353 # under some circumstances, so we replace them with

1354 # None in that case.

1355 user_get_entry = scope.lookup_here("__get__")

1356 code.putln("")

1357 code.putln(

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

1359 scope.mangle_internal("tp_descr_get"))

1360 code.putln(

1361 "PyObject *r = 0;")

1362 code.putln(

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

1364 code.putln(

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

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

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

1368 code.putln(

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

1370 user_get_entry.func_cname)

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

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

1373 code.putln(

1374 "return r;")

1375 code.putln(

1376 "}")

1377

1378 def generate_descr_set_function(self, scope, code):

1379 # Setting and deleting are both done through the __set__

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

1381 # or __delete__ or raise an exception.

1382 base_type = scope.parent_type.base_type

1383 user_set_entry = scope.lookup_here("__set__")

1384 user_del_entry = scope.lookup_here("__delete__")

1385 code.putln("")

1386 code.putln(

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

1388 scope.mangle_internal("tp_descr_set"))

1389 code.putln(

1390 "if (v) {")

1391 if user_set_entry:

1392 code.putln(

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

1394 user_set_entry.func_cname)

1395 else:

1396 self.generate_guarded_basetype_call(

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

1398 code.putln(

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

1400 code.putln(

1401 "return -1;")

1402 code.putln(

1403 "}")

1404 code.putln(

1405 "else {")

1406 if user_del_entry:

1407 code.putln(

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

1409 user_del_entry.func_cname)

1410 else:

1411 self.generate_guarded_basetype_call(

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

1413 code.putln(

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

1415 code.putln(

1416 "return -1;")

1417 code.putln(

1418 "}")

1419 code.putln(

1420 "}")

1421

1422 def generate_property_accessors(self, cclass_scope, code):

1423 for entry in cclass_scope.property_entries:

1424 property_scope = entry.scope

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

1426 self.generate_property_get_function(entry, code)

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

1428 self.generate_property_set_function(entry, code)

1429

1430 def generate_property_get_function(self, property_entry, code):

1431 property_scope = property_entry.scope

1432 property_entry.getter_cname = property_scope.parent_scope.mangle(

1433 Naming.prop_get_prefix, property_entry.name)

1434 get_entry = property_scope.lookup_here("__get__")

1435 code.putln("")

1436 code.putln(

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

1438 property_entry.getter_cname)

1439 code.putln(

1440 "return %s(o);" %

1441 get_entry.func_cname)

1442 code.putln(

1443 "}")

1444

1445 def generate_property_set_function(self, property_entry, code):

1446 property_scope = property_entry.scope

1447 property_entry.setter_cname = property_scope.parent_scope.mangle(

1448 Naming.prop_set_prefix, property_entry.name)

1449 set_entry = property_scope.lookup_here("__set__")

1450 del_entry = property_scope.lookup_here("__del__")

1451 code.putln("")

1452 code.putln(

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

1454 property_entry.setter_cname)

1455 code.putln(

1456 "if (v) {")

1457 if set_entry:

1458 code.putln(

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

1460 set_entry.func_cname)

1461 else:

1462 code.putln(

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

1464 code.putln(

1465 "return -1;")

1466 code.putln(

1467 "}")

1468 code.putln(

1469 "else {")

1470 if del_entry:

1471 code.putln(

1472 "return %s(o);" %

1473 del_entry.func_cname)

1474 else:

1475 code.putln(

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

1477 code.putln(

1478 "return -1;")

1479 code.putln(

1480 "}")

1481 code.putln(

1482 "}")

1483

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

1485 type = entry.type

1486 scope = type.scope

1487 for suite in TypeSlots.substructures:

1488 suite.generate_substructure(scope, code)

1489 code.putln("")

1490 if entry.visibility == 'public':

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

1492 else:

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

1494 header = "PyTypeObject %s = {"

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

1496 code.putln(header % type.typeobj_cname)

1497 code.putln(

1498 "PyVarObject_HEAD_INIT(0, 0)")

1499 code.putln(

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

1501 self.full_module_name, scope.class_name))

1502 if type.typedef_flag:

1503 objstruct = type.objstruct_cname

1504 else:

1505 #objstruct = "struct %s" % scope.parent_type.objstruct_cname

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

1507 code.putln(

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

1509 objstruct)

1510 code.putln(

1511 "0, /*tp_itemsize*/")

1512 for slot in TypeSlots.slot_table:

1513 slot.generate(scope, code)

1514 code.putln(

1515 "};")

1516

1517 def generate_method_table(self, env, code):

1518 code.putln("")

1519 code.putln(

1520 "static struct PyMethodDef %s[] = {" %

1521 env.method_table_cname)

1522 for entry in env.pyfunc_entries:

1523 code.put_pymethoddef(entry, ",")

1524 code.putln(

1525 "{0, 0, 0, 0}")

1526 code.putln(

1527 "};")

1528

1529 def generate_member_table(self, env, code):

1530 #print "ModuleNode.generate_member_table: scope =", env ###

1531 if env.public_attr_entries:

1532 code.putln("")

1533 code.putln(

1534 "static struct PyMemberDef %s[] = {" %

1535 env.member_table_cname)

1536 type = env.parent_type

1537 if type.typedef_flag:

1538 objstruct = type.objstruct_cname

1539 else:

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

1541 for entry in env.public_attr_entries:

1542 type_code = entry.type.pymemberdef_typecode

1543 if entry.visibility == 'readonly':

1544 flags = "READONLY"

1545 else:

1546 flags = "0"

1547 code.putln('{(char *)"%s", %s, %s, %s, 0},' % (

1548 entry.name,

1549 type_code,

1550 "offsetof(%s, %s)" % (objstruct, entry.cname),

1551 flags))

1552 code.putln(

1553 "{0, 0, 0, 0, 0}")

1554 code.putln(

1555 "};")

1556

1557 def generate_getset_table(self, env, code):

1558 if env.property_entries:

1559 code.putln("")

1560 code.putln(

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

1562 env.getset_table_cname)

1563 for entry in env.property_entries:

1564 if entry.doc:

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

1566 else:

1567 doc_code = "0"

1568 code.putln(

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

1570 entry.name,

1571 entry.getter_cname or "0",

1572 entry.setter_cname or "0",

1573 doc_code))

1574 code.putln(

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

1576 code.putln(

1577 "};")

1578

1579 def generate_filename_init_prototype(self, code):

1580 code.putln("");

1581 code.putln("static void %s(void); /*proto*/" % Naming.fileinit_cname)

1582

1583 def generate_import_star(self, env, code):

1584 env.use_utility_code(streq_utility_code)

1585 code.putln()

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

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

1588 if entry.is_type:

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

1590 code.putln("0")

1591 code.putln("};")

1592 code.putln()

1593 code.enter_cfunc_scope() # as we need labels

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

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

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

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

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

1599 code.putln('goto bad;')

1600 code.putln("}")

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

1602 code.putln("}")

1603 old_error_label = code.new_error_label()

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

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

1606 if entry.is_cglobal and entry.used:

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

1608 if entry.type.is_pyobject:

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

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

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

1612 code.error_goto(entry.pos)))

1613 code.put_var_decref(entry)

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

1615 entry.cname,

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

1617 elif entry.type.from_py_function:

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

1619 if entry.type.is_enum:

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

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

1622 entry.cname,

1623 rhs,

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

1625 code.error_goto(entry.pos)))

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

1627 else:

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

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

1630 code.putln("}")

1631 code.putln("else {")

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

1633 code.putln("}")

1634 code.putln("return 0;")

1635 code.put_label(code.error_label)

1636 # This helps locate the offending name.

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

1638 code.error_label = old_error_label

1639 code.putln("bad:")

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

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

1642 code.putln("}")

1643 code.putln(import_star_utility_code)

1644 code.exit_cfunc_scope() # done with labels

1645

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

1647 code.enter_cfunc_scope()

1648 code.putln("")

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

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

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

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

1653 code.putln(header2)

1654 code.putln("#else")

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

1656 code.putln(header3)

1657 code.putln("#endif")

1658 code.putln("{")

1659 tempdecl_code = code.insertion_point()

1660

1661 code.putln("#if CYTHON_REFNANNY")

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

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

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

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

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

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

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

1669 code.putln("}")

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

1671 code.putln("#endif")

1672

1673 self.generate_filename_init_call(code)

1674

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

1676 code.putln("#if PY_MAJOR_VERSION < 3");

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

1678 code.putln("#else");

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

1680 code.putln("#endif");

1681

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

1683 env.generate_library_function_declarations(code)

1684

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

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

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

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

1689 code.putln("#endif")

1690 code.putln("#endif")

1691

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

1693 self.generate_module_creation_code(env, code)

1694

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

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

1697

1698 __main__name = code.globalstate.get_py_string_const(

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

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

1701 code.putln(

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

1703 env.module_cname,

1704 __main__name.cname,

1705 code.error_goto(self.pos)))

1706 code.putln("}")

1707

1708 if Options.cache_builtins:

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

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

1711 self.pos))

1712

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

1714 self.generate_global_init_code(env, code)

1715

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

1717 self.generate_c_function_export_code(env, code)

1718

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

1720 self.generate_type_init_code(env, code)

1721

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

1723 for module in imported_modules:

1724 self.generate_type_import_code_for_module(module, env, code)

1725

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

1727 for module in imported_modules:

1728 self.generate_c_function_import_code_for_module(module, env, code)

1729

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

1731 code.mark_pos(None)

1732

1733 self.body.generate_execution_code(code)

1734

1735 if Options.generate_cleanup_code:

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

1737 env.use_utility_code(import_module_utility_code)

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

1739

1740 code.put_goto(code.return_label)

1741 code.put_label(code.error_label)

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

1743 code.put_xdecref(cname, type)

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

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

1746 env.use_utility_code(Nodes.traceback_utility_code)

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

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

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

1750 code.putln('}')

1751 code.put_label(code.return_label)

1752

1753 code.put_finish_refcount_context()

1754

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

1756 code.putln("return;")

1757 code.putln("#else")

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

1759 code.putln("#endif")

1760 code.putln('}')

1761

1762 tempdecl_code.put_temp_declarations(code.funcstate)

1763

1764 code.exit_cfunc_scope()

1765

1766 def generate_module_cleanup_func(self, env, code):

1767 if not Options.generate_cleanup_code:

1768 return

1769 code.globalstate.use_utility_code(register_cleanup_utility_code)

1770 code.putln('static PyObject* %s(PyObject *self, PyObject *unused) {' % Naming.cleanup_cname)

1771 if Options.generate_cleanup_code >= 2:

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

1773 rev_entries = list(env.var_entries)

1774 rev_entries.reverse()

1775 for entry in rev_entries:

1776 if entry.visibility != 'extern':

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

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

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

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

1781 if Options.generate_cleanup_code >= 3:

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

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

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

1785 if Options.cache_builtins:

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

1787 for entry in env.cached_builtins:

1788 code.put_decref_clear(entry.cname,

1789 PyrexTypes.py_object_type,

1790 nanny=False)

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

1792 code.put_decref_clear(Naming.empty_tuple,

1793 PyrexTypes.py_object_type,

1794 nanny=False)

1795 # for entry in env.pynum_entries:

1796 # code.put_decref_clear(entry.cname,

1797 # PyrexTypes.py_object_type,

1798 # nanny=False)

1799 # for entry in env.all_pystring_entries:

1800 # if entry.is_interned:

1801 # code.put_decref_clear(entry.pystring_cname,

1802 # PyrexTypes.py_object_type,

1803 # nanny=False)

1804 # for entry in env.default_entries:

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

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

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

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

1809

1810 def generate_main_method(self, env, code):

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

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

1813

1814 def generate_filename_init_call(self, code):

1815 code.putln("%s();" % Naming.fileinit_cname)

1816

1817 def generate_pymoduledef_struct(self, env, code):

1818 if env.doc:

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

1820 else:

1821 doc = "0"

1822 code.putln("")

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

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

1825 code.putln(" PyModuleDef_HEAD_INIT,")

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

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

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

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

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

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

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

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

1834 code.putln("};")

1835 code.putln("#endif")

1836

1837 def generate_module_creation_code(self, env, code):

1838 # Generate code to create the module object and

1839 # install the builtins.

1840 if env.doc:

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

1842 else:

1843 doc = "0"

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

1845 code.putln(

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

1847 env.module_cname,

1848 env.module_name,

1849 env.method_table_cname,

1850 doc))

1851 code.putln("#else")

1852 code.putln(

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

1854 env.module_cname,

1855 Naming.pymoduledef_cname))

1856 code.putln("#endif")

1857 code.putln(

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

1859 env.module_cname,

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

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

1862 code.putln(

1863 "Py_INCREF(%s);" %

1864 env.module_cname)

1865 code.putln("#endif")

1866 code.putln(

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

1868 Naming.builtins_cname)

1869 code.putln(

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

1871 Naming.builtins_cname,

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

1873 code.putln(

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

1875 env.module_cname,

1876 Naming.builtins_cname,

1877 code.error_goto(self.pos)))

1878 if Options.pre_import is not None:

1879 code.putln(

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

1881 Naming.preimport_cname,

1882 Options.pre_import))

1883 code.putln(

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

1885 Naming.preimport_cname,

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

1887

1888 def generate_global_init_code(self, env, code):

1889 # Generate code to initialise global PyObject *

1890 # variables to None.

1891 for entry in env.var_entries:

1892 if entry.visibility != 'extern':

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

1894 code.put_init_var_to_py_none(entry, nanny=False)

1895

1896 def generate_c_function_export_code(self, env, code):

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

1898 for entry in env.cfunc_entries:

1899 if entry.api or entry.defined_in_pxd:

1900 env.use_utility_code(function_export_utility_code)

1901 signature = entry.type.signature_string()

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

1903 entry.name,

1904 entry.cname,

1905 signature,

1906 code.error_goto(self.pos)))

1907

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

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

1910 # an imported module.

1911 #if module.c_class_entries:

1912 for entry in module.c_class_entries:

1913 if entry.defined_in_pxd:

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

1915

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

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

1918 entries = []

1919 for entry in module.cfunc_entries:

1920 if entry.defined_in_pxd:

1921 entries.append(entry)

1922 if entries:

1923 env.use_utility_code(import_module_utility_code)

1924 env.use_utility_code(function_import_utility_code)

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

1926 code.putln(

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

1928 temp,

1929 module.qualified_name,

1930 temp,

1931 code.error_goto(self.pos)))

1932 for entry in entries:

1933 code.putln(

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

1935 temp,

1936 entry.name,

1937 entry.cname,

1938 entry.type.signature_string(),

1939 code.error_goto(self.pos)))

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

1941

1942 def generate_type_init_code(self, env, code):

1943 # Generate type import code for extern extension types

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

1945 for entry in env.c_class_entries:

1946 if entry.visibility == 'extern':

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

1948 else:

1949 self.generate_base_type_import_code(env, entry, code)

1950 self.generate_exttype_vtable_init_code(entry, code)

1951 self.generate_type_ready_code(env, entry, code)

1952 self.generate_typeptr_assignment_code(entry, code)

1953

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

1955 base_type = entry.type.base_type

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

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

1958

1959 def use_type_import_utility_code(self, env):

1960 env.use_utility_code(type_import_utility_code)

1961 env.use_utility_code(import_module_utility_code)

1962

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

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

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

1966 # table pointer if any.

1967 if type in env.types_imported:

1968 return

1969 if type.typedef_flag:

1970 objstruct = type.objstruct_cname

1971 else:

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

1973 self.generate_type_import_call(type, code,

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

1975 self.use_type_import_utility_code(env)

1976 if type.vtabptr_cname:

1977 code.putln(

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

1979 type.typeptr_cname,

1980 type.vtabptr_cname,

1981 code.error_goto(pos)))

1982 env.use_utility_code(Nodes.get_vtable_utility_code)

1983 env.types_imported[type] = 1

1984

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

1986

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

1988 if type.typedef_flag:

1989 objstruct = type.objstruct_cname

1990 else:

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

1992 module_name = type.module_name

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

1994 module_name = '"%s"' % module_name

1995 else:

1996 module_name = '__Pyx_BUILTIN_MODULE_NAME'

1997 if type.name in self.py3_type_name_map:

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

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

2000 type.typeptr_cname,

2001 module_name,

2002 self.py3_type_name_map[type.name],

2003 objstruct,

2004 error_code))

2005 code.putln("#else")

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

2007 type.typeptr_cname,

2008 module_name,

2009 type.name,

2010 objstruct,

2011 not type.is_external or type.is_subclassed,

2012 error_code))

2013 if type.name in self.py3_type_name_map:

2014 code.putln("#endif")

2015

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

2017 # Generate a call to PyType_Ready for an extension

2018 # type defined in this module.

2019 type = entry.type

2020 typeobj_cname = type.typeobj_cname

2021 scope = type.scope

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

2023 if entry.visibility != 'extern':

2024 for slot in TypeSlots.slot_table:

2025 slot.generate_dynamic_init_code(scope, code)

2026 code.putln(

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

2028 typeobj_cname,

2029 code.error_goto(entry.pos)))

2030 if type.vtable_cname:

2031 code.putln(

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

2033 typeobj_cname,

2034 type.vtabptr_cname,

2035 code.error_goto(entry.pos)))

2036 env.use_utility_code(Nodes.set_vtable_utility_code)

2037 code.putln(

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

2039 Naming.module_cname,

2040 scope.class_name,

2041 typeobj_cname,

2042 code.error_goto(entry.pos)))

2043 weakref_entry = scope.lookup_here("__weakref__")

2044 if weakref_entry:

2045 if weakref_entry.type is py_object_type:

2046 tp_weaklistoffset = "%s.tp_weaklistoffset" % typeobj_cname

2047 if type.typedef_flag:

2048 objstruct = type.objstruct_cname

2049 else:

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

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

2052 tp_weaklistoffset,

2053 tp_weaklistoffset,

2054 objstruct,

2055 weakref_entry.cname))

2056 else:

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

2058

2059 def generate_exttype_vtable_init_code(self, entry, code):

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

2061 # extension type.

2062 type = entry.type

2063 if type.vtable_cname:

2064 code.putln(

2065 "%s = &%s;" % (

2066 type.vtabptr_cname,

2067 type.vtable_cname))

2068 if type.base_type and type.base_type.vtabptr_cname:

2069 code.putln(

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

2071 type.vtable_cname,

2072 Naming.obj_base_cname,

2073 type.base_type.vtabptr_cname))

2074

2075 c_method_entries = [

2076 entry for entry in type.scope.cfunc_entries

2077 if entry.func_cname ]

2078 if c_method_entries:

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

2080 for meth_entry in c_method_entries:

2081 cast = meth_entry.type.signature_cast_string()

2082 code.putln(

2083 "%s.%s = %s%s;" % (

2084 type.vtable_cname,

2085 meth_entry.cname,

2086 cast,

2087 meth_entry.func_cname))

2088 code.putln('#else')

2089 for meth_entry in c_method_entries:

2090 code.putln(

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

2092 type.vtable_cname,

2093 meth_entry.cname,

2094 meth_entry.func_cname))

2095 code.putln('#endif')

2096

2097 def generate_typeptr_assignment_code(self, entry, code):

2098 # Generate code to initialise the typeptr of an extension

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

2100 type = entry.type

2101 if type.typeobj_cname:

2102 code.putln(

2103 "%s = &%s;" % (

2104 type.typeptr_cname, type.typeobj_cname))

2105

2106 #------------------------------------------------------------------------------------

2107 #

2108 # Runtime support code

2109 #

2110 #------------------------------------------------------------------------------------

2111

2112 streq_utility_code = UtilityCode(

2113 proto = """

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

2115 """,

2116 impl = """

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

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

2119 return *s1 == *s2;

2120 }

2121 """)

2122

2123 #------------------------------------------------------------------------------------

2124

2125 import_module_utility_code = UtilityCode(

2126 proto = """

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

2128 """,

2129 impl = """

2130 #ifndef __PYX_HAVE_RT_ImportModule

2131 #define __PYX_HAVE_RT_ImportModule

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

2133 PyObject *py_name = 0;

2134 PyObject *py_module = 0;

2135

2136 #if PY_MAJOR_VERSION < 3

2137 py_name = PyString_FromString(name);

2138 #else

2139 py_name = PyUnicode_FromString(name);

2140 #endif

2141 if (!py_name)

2142 goto bad;

2143 py_module = PyImport_Import(py_name);

2144 Py_DECREF(py_name);

2145 return py_module;

2146 bad:

2147 Py_XDECREF(py_name);

2148 return 0;

2149 }

2150 #endif

2151 """)

2152

2153 #------------------------------------------------------------------------------------

2154

2155 type_import_utility_code = UtilityCode(

2156 proto = """

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

2158 """,

2159 impl = """

2160 #ifndef __PYX_HAVE_RT_ImportType

2161 #define __PYX_HAVE_RT_ImportType

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

2163 long size, int strict)

2164 {

2165 PyObject *py_module = 0;

2166 PyObject *result = 0;

2167 PyObject *py_name = 0;

2168 char warning[200];

2169

2170 py_module = __Pyx_ImportModule(module_name);

2171 if (!py_module)

2172 goto bad;

2173 #if PY_MAJOR_VERSION < 3

2174 py_name = PyString_FromString(class_name);

2175 #else

2176 py_name = PyUnicode_FromString(class_name);

2177 #endif

2178 if (!py_name)

2179 goto bad;

2180 result = PyObject_GetAttr(py_module, py_name);

2181 Py_DECREF(py_name);

2182 py_name = 0;

2183 Py_DECREF(py_module);

2184 py_module = 0;

2185 if (!result)

2186 goto bad;

2187 if (!PyType_Check(result)) {

2188 PyErr_Format(PyExc_TypeError,

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

2190 module_name, class_name);

2191 goto bad;

2192 }

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

2194 PyOS_snprintf(warning, sizeof(warning),

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

2196 module_name, class_name);

2197 PyErr_WarnEx(NULL, warning, 0);

2198 }

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

2200 PyErr_Format(PyExc_ValueError,

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

2202 module_name, class_name);

2203 goto bad;

2204 }

2205 return (PyTypeObject *)result;

2206 bad:

2207 Py_XDECREF(py_module);

2208 Py_XDECREF(result);

2209 return 0;

2210 }

2211 #endif

2212 """)

2213

2214 #------------------------------------------------------------------------------------

2215

2216 function_export_utility_code = UtilityCode(

2217 proto = """

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

2219 """,

2220 impl = r"""

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

2222 PyObject *d = 0;

2223 PyObject *cobj = 0;

2224 union {

2225 void (*fp)(void);

2226 void *p;

2227 } tmp;

2228

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

2230 if (!d) {

2231 PyErr_Clear();

2232 d = PyDict_New();

2233 if (!d)

2234 goto bad;

2235 Py_INCREF(d);

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

2237 goto bad;

2238 }

2239 tmp.fp = f;

2240 #if PY_VERSION_HEX < 0x03010000

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

2242 #else

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

2244 #endif

2245 if (!cobj)

2246 goto bad;

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

2248 goto bad;

2249 Py_DECREF(cobj);

2250 Py_DECREF(d);

2251 return 0;

2252 bad:

2253 Py_XDECREF(cobj);

2254 Py_XDECREF(d);

2255 return -1;

2256 }

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

2258 )

2259

2260 function_import_utility_code = UtilityCode(

2261 proto = """

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

2263 """,

2264 impl = """

2265 #ifndef __PYX_HAVE_RT_ImportFunction

2266 #define __PYX_HAVE_RT_ImportFunction

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

2268 PyObject *d = 0;

2269 PyObject *cobj = 0;

2270 union {

2271 void (*fp)(void);

2272 void *p;

2273 } tmp;

2274 #if PY_VERSION_HEX < 0x03010000

2275 const char *desc, *s1, *s2;

2276 #endif

2277

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

2279 if (!d)

2280 goto bad;

2281 cobj = PyDict_GetItemString(d, funcname);

2282 if (!cobj) {

2283 PyErr_Format(PyExc_ImportError,

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

2285 PyModule_GetName(module), funcname);

2286 goto bad;

2287 }

2288 #if PY_VERSION_HEX < 0x03010000

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

2290 if (!desc)

2291 goto bad;

2292 s1 = desc; s2 = sig;

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

2294 if (*s1 != *s2) {

2295 PyErr_Format(PyExc_TypeError,

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

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

2298 goto bad;

2299 }

2300 tmp.p = PyCObject_AsVoidPtr(cobj);

2301 #else

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

2303 PyErr_Format(PyExc_TypeError,

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

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

2306 goto bad;

2307 }

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

2309 #endif

2310 *f = tmp.fp;

2311 if (!(*f))

2312 goto bad;

2313 Py_DECREF(d);

2314 return 0;

2315 bad:

2316 Py_XDECREF(d);

2317 return -1;

2318 }

2319 #endif

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

2321 )

2322

2323 #------------------------------------------------------------------------------------

2324

2325 register_cleanup_utility_code = UtilityCode(

2326 proto = """

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

2328 static PyObject* __pyx_module_cleanup(PyObject *self, PyObject *unused); /*proto*/

2329 static PyMethodDef cleanup_def = {__Pyx_NAMESTR("__cleanup"), (PyCFunction)&__pyx_module_cleanup, METH_NOARGS, 0};

2330 """,

2331 impl = """

2332 static int __Pyx_RegisterCleanup(void) {

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

2334 * and is called after python finalization.

2335 */

2336

2337 PyObject *cleanup_func = 0;

2338 PyObject *atexit = 0;

2339 PyObject *reg = 0;

2340 PyObject *args = 0;

2341 PyObject *res = 0;

2342 int ret = -1;

2343

2344 cleanup_func = PyCFunction_New(&cleanup_def, 0);

2345 args = PyTuple_New(1);

2346 if (!cleanup_func || !args)

2347 goto bad;

2348 PyTuple_SET_ITEM(args, 0, cleanup_func);

2349 cleanup_func = 0;

2350

2351 atexit = __Pyx_ImportModule("atexit");

2352 if (!atexit)

2353 goto bad;

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

2355 if (!reg)

2356 goto bad;

2357 res = PyObject_CallObject(reg, args);

2358 if (!res)

2359 goto bad;

2360 ret = 0;

2361 bad:

2362 Py_XDECREF(cleanup_func);

2363 Py_XDECREF(atexit);

2364 Py_XDECREF(reg);

2365 Py_XDECREF(args);

2366 Py_XDECREF(res);

2367 return ret;

2368 }

2369 """)

2370

2371 import_star_utility_code = """

2372

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

2374

2375 static int

2376 __Pyx_import_all_from(PyObject *locals, PyObject *v)

2377 {

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

2379 PyObject *dict, *name, *value;

2380 int skip_leading_underscores = 0;

2381 int pos, err;

2382

2383 if (all == NULL) {

2384 if (!PyErr_ExceptionMatches(PyExc_AttributeError))

2385 return -1; /* Unexpected error */

2386 PyErr_Clear();

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

2388 if (dict == NULL) {

2389 if (!PyErr_ExceptionMatches(PyExc_AttributeError))

2390 return -1;

2391 PyErr_SetString(PyExc_ImportError,

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

2393 return -1;

2394 }

2395 all = PyMapping_Keys(dict);

2396 Py_DECREF(dict);

2397 if (all == NULL)

2398 return -1;

2399 skip_leading_underscores = 1;

2400 }

2401

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

2403 name = PySequence_GetItem(all, pos);

2404 if (name == NULL) {

2405 if (!PyErr_ExceptionMatches(PyExc_IndexError))

2406 err = -1;

2407 else

2408 PyErr_Clear();

2409 break;

2410 }

2411 if (skip_leading_underscores &&

2412 #if PY_MAJOR_VERSION < 3

2413 PyString_Check(name) &&

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

2415 #else

2416 PyUnicode_Check(name) &&

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

2418 #endif

2419 {

2420 Py_DECREF(name);

2421 continue;

2422 }

2423 value = PyObject_GetAttr(v, name);

2424 if (value == NULL)

2425 err = -1;

2426 else if (PyDict_CheckExact(locals))

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

2428 else

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

2430 Py_DECREF(name);

2431 Py_XDECREF(value);

2432 if (err != 0)

2433 break;

2434 }

2435 Py_DECREF(all);

2436 return err;

2437 }

2438

2439

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

2441

2442 int i;

2443 int ret = -1;

2444 char* s;

2445 PyObject *locals = 0;

2446 PyObject *list = 0;

2447 PyObject *name;

2448 PyObject *item;

2449

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

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

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

2453

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

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

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

2457 #if PY_MAJOR_VERSION < 3

2458 s = PyString_AsString(name);

2459 #else

2460 s = PyUnicode_AsString(name);

2461 #endif

2462 if (!s) goto bad;

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

2464 }

2465 ret = 0;

2466

2467 bad:

2468 Py_XDECREF(locals);

2469 Py_XDECREF(list);

2470 return ret;

2471 }

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

2473 'IMPORT_STAR_SET' : Naming.import_star_set }

2474

2475 refnanny_utility_code = UtilityCode(proto="""

2476 #ifndef CYTHON_REFNANNY

2477 #define CYTHON_REFNANNY 0

2478 #endif

2479

2480 #if CYTHON_REFNANNY

2481 typedef struct {

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

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

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

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

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

2487 void (*FinishContext)(void**);

2488 } __Pyx_RefNannyAPIStruct;

2489 static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;

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

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

2492 void *r = NULL;

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

2494 if (!m) goto end;

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

2496 if (!p) goto end;

2497 r = PyLong_AsVoidPtr(p);

2498 end:

2499 Py_XDECREF(p);

2500 Py_XDECREF(m);

2501 return (__Pyx_RefNannyAPIStruct *)r;

2502 }

2503 #define __Pyx_RefNannySetupContext(name) \

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

2505 #define __Pyx_RefNannyFinishContext() \

2506 __Pyx_RefNanny->FinishContext(&__pyx_refnanny)

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

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

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

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

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

2512 #else

2513 #define __Pyx_RefNannySetupContext(name)

2514 #define __Pyx_RefNannyFinishContext()

2515 #define __Pyx_INCREF(r) Py_INCREF(r)

2516 #define __Pyx_DECREF(r) Py_DECREF(r)

2517 #define __Pyx_GOTREF(r)

2518 #define __Pyx_GIVEREF(r)

2519 #define __Pyx_XDECREF(r) Py_XDECREF(r)

2520 #endif /* CYTHON_REFNANNY */

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

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

2523 """)

2524

2525

2526 main_method = UtilityCode(

2527 impl = """

2528 #ifdef __FreeBSD__

2529 #include <floatingpoint.h>

2530 #endif

2531

2532 #if PY_MAJOR_VERSION < 3

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

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

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

2536 #else

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

2538 #endif

2539 int r = 0;

2540 PyObject* m = NULL;

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

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

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

2544 * exceptions by default. Here we disable them.

2545 */

2546 #ifdef __FreeBSD__

2547 fp_except_t m;

2548

2549 m = fpgetmask();

2550 fpsetmask(m & ~FP_X_OFL);

2551 #endif

2552 Py_SetProgramName(argv[0]);

2553 Py_Initialize();

2554 PySys_SetArgv(argc, argv);

2555 %(module_is_main)s = 1;

2556 #if PY_MAJOR_VERSION < 3

2557 init%(module_name)s();

2558 #else

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

2560 #endif

2561 if (PyErr_Occurred() != NULL) {

2562 r = 1;

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

2564 #if PY_MAJOR_VERSION < 3

2565 if (Py_FlushLine()) PyErr_Clear();

2566 #endif

2567 }

2568 Py_XDECREF(m);

2569 Py_Finalize();

2570 return r;

2571 }

2572

2573

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

2575 #include <locale.h>

2576

2577 static wchar_t*

2578 __Pyx_char2wchar(char* arg)

2579 {

2580 wchar_t *res;

2581 #ifdef HAVE_BROKEN_MBSTOWCS

2582 /* Some platforms have a broken implementation of

2583 * mbstowcs which does not count the characters that

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

2585 */

2586 size_t argsize = strlen(arg);

2587 #else

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

2589 #endif

2590 size_t count;

2591 unsigned char *in;

2592 wchar_t *out;

2593 #ifdef HAVE_MBRTOWC

2594 mbstate_t mbs;

2595 #endif

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

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

2598 if (!res)

2599 goto oom;

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

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

2602 wchar_t *tmp;

2603 /* Only use the result if it contains no

2604 surrogate characters. */

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

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

2607 ;

2608 if (*tmp == 0)

2609 return res;

2610 }

2611 free(res);

2612 }

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

2614 #ifdef HAVE_MBRTOWC

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

2616

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

2618 actual output could use less memory. */

2619 argsize = strlen(arg) + 1;

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

2621 if (!res) goto oom;

2622 in = (unsigned char*)arg;

2623 out = res;

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

2625 while (argsize) {

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

2627 if (converted == 0)

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

2629 break;

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

2631 /* Incomplete character. This should never happen,

2632 since we provide everything that we have -

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

2634 misunderstood how mbrtowc works. */

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

2636 return NULL;

2637 }

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

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

2640 in the initial shift state. */

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

2642 argsize--;

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

2644 continue;

2645 }

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

2647 /* Surrogate character. Escape the original

2648 byte sequence with surrogateescape. */

2649 argsize -= converted;

2650 while (converted--)

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

2652 continue;

2653 }

2654 /* successfully converted some bytes */

2655 in += converted;

2656 argsize -= converted;

2657 out++;

2658 }

2659 #else

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

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

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

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

2664 if (!res) goto oom;

2665 in = (unsigned char*)arg;

2666 out = res;

2667 while(*in)

2668 if(*in < 128)

2669 *out++ = *in++;

2670 else

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

2672 *out = 0;

2673 #endif

2674 return res;

2675 oom:

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

2677 return NULL;

2678 }

2679

2680 int

2681 main(int argc, char **argv)

2682 {

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

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

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

2686 int i, res;

2687 char *oldloc;

2688 if (!argv_copy || !argv_copy2) {

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

2690 return 1;

2691 }

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

2693 setlocale(LC_ALL, "");

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

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

2696 if (!argv_copy[i])

2697 return 1;

2698 }

2699 setlocale(LC_ALL, oldloc);

2700 free(oldloc);

2701 res = __Pyx_main(argc, argv_copy);

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

2703 free(argv_copy2[i]);

2704 }

2705 free(argv_copy);

2706 free(argv_copy2);

2707 return res;

2708 }

2709 #endif

2710 """)

2711

2712 packed_struct_utility_code = UtilityCode(proto="""

2713 #if defined(__GNUC__)

2714 #define __Pyx_PACKED __attribute__((__packed__))

2715 #else

2716 #define __Pyx_PACKED

2717 #endif

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