1 #

2 # Pyrex - Builtin Definitions

3 #

4

5 from Symtab import BuiltinScope, StructOrUnionScope

6 from Code import UtilityCode

7 from TypeSlots import Signature

8 import PyrexTypes

9 import Naming

10

11 builtin_function_table = [

12 # name, args, return, C API func, py equiv = "*"

13 ('abs', "O", "O", "PyNumber_Absolute"),

14 #('chr', "", "", ""),

15 #('cmp', "", "", "", ""), # int PyObject_Cmp(PyObject *o1, PyObject *o2, int *result)

16 #('compile', "", "", ""), # PyObject* Py_CompileString( char *str, char *filename, int start)

17 ('delattr', "OO", "r", "PyObject_DelAttr"),

18 ('dir', "O", "O", "PyObject_Dir"),

19 ('divmod', "OO", "O", "PyNumber_Divmod"),

20 ('exec', "OOO", "O", "__Pyx_PyRun"),

21 #('eval', "", "", ""),

22 #('execfile', "", "", ""),

23 #('filter', "", "", ""),

24 #('getattr', "OO", "O", "PyObject_GetAttr"), # optimised later on

25 ('getattr3', "OOO", "O", "__Pyx_GetAttr3", "getattr"),

26 ('hasattr', "OO", "b", "PyObject_HasAttr"),

27 ('hash', "O", "l", "PyObject_Hash"),

28 #('hex', "", "", ""),

29 #('id', "", "", ""),

30 #('input', "", "", ""),

31 ('intern', "O", "O", "__Pyx_Intern"),

32 ('isinstance', "OO", "b", "PyObject_IsInstance"),

33 ('issubclass', "OO", "b", "PyObject_IsSubclass"),

34 ('iter', "O", "O", "PyObject_GetIter"),

35 ('len', "O", "Z", "PyObject_Length"),

36 ('locals', "", "O", "__pyx_locals"),

37 #('map', "", "", ""),

38 #('max', "", "", ""),

39 #('min', "", "", ""),

40 #('oct', "", "", ""),

41 # Not worth doing open, when second argument would become mandatory

42 #('open', "ss", "O", "PyFile_FromString"),

43 #('ord', "", "", ""),

44 ('pow', "OOO", "O", "PyNumber_Power"),

45 #('range', "", "", ""),

46 #('raw_input', "", "", ""),

47 #('reduce', "", "", ""),

48 ('reload', "O", "O", "PyImport_ReloadModule"),

49 ('repr', "O", "O", "PyObject_Repr"),

50 #('round', "", "", ""),

51 ('setattr', "OOO", "r", "PyObject_SetAttr"),

52 #('sum', "", "", ""),

53 #('type', "O", "O", "PyObject_Type"),

54 #('unichr', "", "", ""),

55 #('unicode', "", "", ""),

56 #('vars', "", "", ""),

57 #('zip', "", "", ""),

58 # Can't do these easily until we have builtin type entries.

59 #('typecheck', "OO", "i", "PyObject_TypeCheck", False),

60 #('issubtype', "OO", "i", "PyType_IsSubtype", False),

61

62 # Put in namespace append optimization.

63 ('__Pyx_PyObject_Append', "OO", "O", "__Pyx_PyObject_Append"),

64 ]

65

66 # Builtin types

67 # bool

68 # buffer

69 # classmethod

70 # dict

71 # enumerate

72 # file

73 # float

74 # int

75 # list

76 # long

77 # object

78 # property

79 # slice

80 # staticmethod

81 # super

82 # str

83 # tuple

84 # type

85 # xrange

86

87 builtin_types_table = [

88

89 ("type", "PyType_Type", []),

90

91 ("bool", "PyBool_Type", []),

92 ("int", "PyInt_Type", []),

93 ("long", "PyLong_Type", []),

94 ("float", "PyFloat_Type", []),

95

96 # Until we have a way to access attributes of a type,

97 # we don't want to make this one builtin.

98 # ("complex", "PyComplex_Type", []),

99

100 ("bytes", "PyBytes_Type", []),

101 ("str", "PyString_Type", []),

102 ("unicode", "PyUnicode_Type", []),

103

104 ("tuple", "PyTuple_Type", []),

105

106 ("list", "PyList_Type", [("insert", "OZO", "i", "PyList_Insert")]),

107

108 ("dict", "PyDict_Type", [("items", "O", "O", "PyDict_Items"),

109 ("keys", "O", "O", "PyDict_Keys"),

110 ("values","O", "O", "PyDict_Values"),

111 ("copy", "O", "O", "PyDict_Copy")]),

112

113 ("slice", "PySlice_Type", []),

114 ("file", "PyFile_Type", []),

115

116 ("set", "PySet_Type", [("clear", "O", "i", "PySet_Clear"),

117 ("discard", "OO", "i", "PySet_Discard"),

118 ("add", "OO", "i", "PySet_Add"),

119 ("pop", "O", "O", "PySet_Pop")]),

120 ("frozenset", "PyFrozenSet_Type", []),

121 ]

122

123 types_that_construct_their_instance = (

124 # some builtin types do not always return an instance of

125 # themselves - these do:

126 'type', 'bool', 'long', 'float', 'bytes', 'unicode', 'tuple', 'list',

127 'dict', 'file', 'set', 'frozenset'

128 # 'str', # only in Py3.x

129 )

130

131

132 builtin_structs_table = [

133 ('Py_buffer', 'Py_buffer',

134 [("buf", PyrexTypes.c_void_ptr_type),

135 ("obj", PyrexTypes.py_object_type),

136 ("len", PyrexTypes.c_py_ssize_t_type),

137 ("itemsize", PyrexTypes.c_py_ssize_t_type),

138 ("readonly", PyrexTypes.c_bint_type),

139 ("ndim", PyrexTypes.c_int_type),

140 ("format", PyrexTypes.c_char_ptr_type),

141 ("shape", PyrexTypes.c_py_ssize_t_ptr_type),

142 ("strides", PyrexTypes.c_py_ssize_t_ptr_type),

143 ("suboffsets", PyrexTypes.c_py_ssize_t_ptr_type),

144 ("internal", PyrexTypes.c_void_ptr_type),

145 ])

146 ]

147

148 getattr3_utility_code = UtilityCode(

149 proto = """

150 static PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /*proto*/

151 """,

152 impl = """

153 static PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) {

154 PyObject *r = PyObject_GetAttr(o, n);

155 if (!r) {

156 if (!PyErr_ExceptionMatches(PyExc_AttributeError))

157 goto bad;

158 PyErr_Clear();

159 r = d;

160 Py_INCREF(d);

161 }

162 return r;

163 bad:

164 return 0;

165 }

166 """)

167

168 pyexec_utility_code = UtilityCode(

169 proto = """

170 #if PY_VERSION_HEX < 0x02040000

171 #ifndef Py_COMPILE_H

172 #include "compile.h"

173 #endif

174 #ifndef Py_EVAL_H

175 #include "eval.h"

176 #endif

177 #endif

178 static PyObject* __Pyx_PyRun(PyObject*, PyObject*, PyObject*);

179 """,

180 impl = """

181 static PyObject* __Pyx_PyRun(PyObject* o, PyObject* globals, PyObject* locals) {

182 PyObject* result;

183 PyObject* s = 0;

184 char *code = 0;

185

186 if (!globals || globals == Py_None) {

187 globals = PyModule_GetDict(%s);""" % Naming.module_cname + """

188 if (!globals)

189 goto bad;

190 } else if (!PyDict_Check(globals)) {

191 PyErr_Format(PyExc_TypeError, "exec() arg 2 must be a dict, not %.100s",

192 globals->ob_type->tp_name);

193 goto bad;

194 }

195 if (!locals || locals == Py_None) {

196 locals = globals;

197 }

198

199

200 if (PyDict_GetItemString(globals, "__builtins__") == NULL) {

201 PyDict_SetItemString(globals, "__builtins__", PyEval_GetBuiltins());

202 }

203

204 if (PyCode_Check(o)) {

205 if (PyCode_GetNumFree((PyCodeObject *)o) > 0) {

206 PyErr_SetString(PyExc_TypeError,

207 "code object passed to exec() may not contain free variables");

208 goto bad;

209 }

210 result = PyEval_EvalCode((PyCodeObject *)o, globals, locals);

211 } else {

212 PyCompilerFlags cf;

213 cf.cf_flags = 0;

214 if (PyUnicode_Check(o)) {

215 cf.cf_flags = PyCF_SOURCE_IS_UTF8;

216 s = PyUnicode_AsUTF8String(o);

217 if (!s) goto bad;

218 o = s;

219 #if PY_MAJOR_VERSION >= 3

220 } else if (!PyBytes_Check(o)) {

221 #else

222 } else if (!PyString_Check(o)) {

223 #endif

224 PyErr_SetString(PyExc_TypeError,

225 "exec: arg 1 must be string, bytes or code object");

226 goto bad;

227 }

228 #if PY_MAJOR_VERSION >= 3

229 code = PyBytes_AS_STRING(o);

230 #else

231 code = PyString_AS_STRING(o);

232 #endif

233 if (PyEval_MergeCompilerFlags(&cf)) {

234 result = PyRun_StringFlags(code, Py_file_input, globals, locals, &cf);

235 } else {

236 result = PyRun_String(code, Py_file_input, globals, locals);

237 }

238 Py_XDECREF(s);

239 }

240

241 return result;

242 bad:

243 Py_XDECREF(s);

244 return 0;

245 }

246 """)

247

248 intern_utility_code = UtilityCode(

249 proto = """

250 static PyObject* __Pyx_Intern(PyObject* s); /* proto */

251 """,

252 impl = '''

253 static PyObject* __Pyx_Intern(PyObject* s) {

254 if (!(likely(PyString_CheckExact(s)))) {

255 PyErr_Format(PyExc_TypeError, "Expected str, got %s", Py_TYPE(s)->tp_name);

256 return 0;

257 }

258 Py_INCREF(s);

259 #if PY_MAJOR_VERSION >= 3

260 PyUnicode_InternInPlace(&s);

261 #else

262 PyString_InternInPlace(&s);

263 #endif

264 return s;

265 }

266 ''')

267

268 def put_py23_set_init_utility_code(code, pos):

269 code.putln("#if PY_VERSION_HEX < 0x02040000")

270 code.putln(code.error_goto_if_neg("__Pyx_Py23SetsImport()", pos))

271 code.putln("#endif")

272

273 py23_set_utility_code = UtilityCode(

274 proto = """

275 #if PY_VERSION_HEX < 0x02050000

276 #ifndef PyAnySet_CheckExact

277

278 #define PyAnySet_CheckExact(ob) \\

279 ((ob)->ob_type == &PySet_Type || \\

280 (ob)->ob_type == &PyFrozenSet_Type)

281

282 #define PySet_New(iterable) \\

283 PyObject_CallFunctionObjArgs((PyObject *)&PySet_Type, (iterable), NULL)

284

285 #define Pyx_PyFrozenSet_New(iterable) \\

286 PyObject_CallFunctionObjArgs((PyObject *)&PyFrozenSet_Type, (iterable), NULL)

287

288 #define PySet_Size(anyset) \\

289 PyObject_Size((anyset))

290

291 #define PySet_Contains(anyset, key) \\

292 PySequence_Contains((anyset), (key))

293

294 #define PySet_Pop(set) \\

295 PyObject_CallMethod(set, (char *)"pop", NULL)

296

297 static CYTHON_INLINE int PySet_Clear(PyObject *set) {

298 PyObject *ret = PyObject_CallMethod(set, (char *)"clear", NULL);

299 if (!ret) return -1;

300 Py_DECREF(ret); return 0;

301 }

302

303 static CYTHON_INLINE int PySet_Discard(PyObject *set, PyObject *key) {

304 PyObject *ret = PyObject_CallMethod(set, (char *)"discard", (char *)"O", key);

305 if (!ret) return -1;

306 Py_DECREF(ret); return 0;

307 }

308

309 static CYTHON_INLINE int PySet_Add(PyObject *set, PyObject *key) {

310 PyObject *ret = PyObject_CallMethod(set, (char *)"add", (char *)"O", key);

311 if (!ret) return -1;

312 Py_DECREF(ret); return 0;

313 }

314

315 #endif /* PyAnySet_CheckExact (<= Py2.4) */

316

317 #if PY_VERSION_HEX < 0x02040000

318 #ifndef Py_SETOBJECT_H

319 #define Py_SETOBJECT_H

320

321 static PyTypeObject *__Pyx_PySet_Type = NULL;

322 static PyTypeObject *__Pyx_PyFrozenSet_Type = NULL;

323

324 #define PySet_Type (*__Pyx_PySet_Type)

325 #define PyFrozenSet_Type (*__Pyx_PyFrozenSet_Type)

326

327 #define PyAnySet_Check(ob) \\

328 (PyAnySet_CheckExact(ob) || \\

329 PyType_IsSubtype((ob)->ob_type, &PySet_Type) || \\

330 PyType_IsSubtype((ob)->ob_type, &PyFrozenSet_Type))

331

332 #define PyFrozenSet_CheckExact(ob) ((ob)->ob_type == &PyFrozenSet_Type)

333

334 static int __Pyx_Py23SetsImport(void) {

335 PyObject *sets=0, *Set=0, *ImmutableSet=0;

336

337 sets = PyImport_ImportModule((char *)"sets");

338 if (!sets) goto bad;

339 Set = PyObject_GetAttrString(sets, (char *)"Set");

340 if (!Set) goto bad;

341 ImmutableSet = PyObject_GetAttrString(sets, (char *)"ImmutableSet");

342 if (!ImmutableSet) goto bad;

343 Py_DECREF(sets);

344

345 __Pyx_PySet_Type = (PyTypeObject*) Set;

346 __Pyx_PyFrozenSet_Type = (PyTypeObject*) ImmutableSet;

347

348 return 0;

349

350 bad:

351 Py_XDECREF(sets);

352 Py_XDECREF(Set);

353 Py_XDECREF(ImmutableSet);

354 return -1;

355 }

356

357 #else

358 static int __Pyx_Py23SetsImport(void) { return 0; }

359 #endif /* !Py_SETOBJECT_H */

360 #endif /* < Py2.4 */

361 #endif /* < Py2.5 */

362 """,

363 init = put_py23_set_init_utility_code,

364 cleanup = """

365 #if PY_VERSION_HEX < 0x02040000

366 Py_XDECREF(__Pyx_PySet_Type); __Pyx_PySet_Type = NULL;

367 Py_XDECREF(__Pyx_PyFrozenSet_Type); __Pyx_PyFrozenSet_Type = NULL;

368 #endif /* < Py2.4 */

369 """)

370

371 builtin_utility_code = {

372 'exec' : pyexec_utility_code,

373 'getattr3' : getattr3_utility_code,

374 'intern' : intern_utility_code,

375 'set' : py23_set_utility_code,

376 'frozenset' : py23_set_utility_code,

377 }

378

379 builtin_scope = BuiltinScope()

380

381 def declare_builtin_func(name, args, ret, cname, py_equiv = "*"):

382 sig = Signature(args, ret)

383 type = sig.function_type()

384 utility = builtin_utility_code.get(name)

385 builtin_scope.declare_builtin_cfunction(name, type, cname, py_equiv, utility)

386

387 def init_builtin_funcs():

388 for desc in builtin_function_table:

389 declare_builtin_func(*desc)

390

391 builtin_types = {}

392

393 def init_builtin_types():

394 global builtin_types

395 for name, cname, funcs in builtin_types_table:

396 utility = builtin_utility_code.get(name)

397 the_type = builtin_scope.declare_builtin_type(name, cname, utility)

398 builtin_types[name] = the_type

399 for name, args, ret, cname in funcs:

400 sig = Signature(args, ret)

401 the_type.scope.declare_cfunction(name, sig.function_type(), None, cname)

402

403 def init_builtin_structs():

404 for name, cname, attribute_types in builtin_structs_table:

405 scope = StructOrUnionScope(name)

406 for attribute_name, attribute_type in attribute_types:

407 scope.declare_var(

408 attribute_name, attribute_type, None, attribute_name)

409 builtin_scope.declare_struct_or_union(

410 name, "struct", scope, 1, None, cname = cname)

411

412 def init_builtins():

413 init_builtin_funcs()

414 init_builtin_types()

415 init_builtin_structs()

416 global list_type, tuple_type, dict_type, set_type, type_type

417 global bytes_type, str_type, unicode_type, float_type

418 type_type = builtin_scope.lookup('type').type

419 list_type = builtin_scope.lookup('list').type

420 tuple_type = builtin_scope.lookup('tuple').type

421 dict_type = builtin_scope.lookup('dict').type

422 set_type = builtin_scope.lookup('set').type

423 bytes_type = builtin_scope.lookup('bytes').type

424 str_type = builtin_scope.lookup('str').type

425 unicode_type = builtin_scope.lookup('unicode').type

426 float_type = builtin_scope.lookup('float').type

427

428 init_builtins()