1/* 2 * Special implementations of built-in functions and methods. 3 * 4 * Optional optimisations for builtins are in Optimize.c. 5 * 6 * General object operations and protocols are in ObjectHandling.c. 7 */ 8 9//////////////////// Globals.proto //////////////////// 10 11static PyObject* __Pyx_Globals(void); /*proto*/ 12 13//////////////////// Globals //////////////////// 14//@substitute: naming 15//@requires: ObjectHandling.c::GetAttr 16 17// This is a stub implementation until we have something more complete. 18// Currently, we only handle the most common case of a read-only dict 19// of Python names. Supporting cdef names in the module and write 20// access requires a rewrite as a dedicated class. 21 22static PyObject* __Pyx_Globals(void) { 23 Py_ssize_t i; 24 //PyObject *d; 25 PyObject *names = NULL; 26 PyObject *globals = PyObject_GetAttr($module_cname, PYIDENT("__dict__")); 27 if (!globals) { 28 PyErr_SetString(PyExc_TypeError, 29 "current module must have __dict__ attribute"); 30 goto bad; 31 } 32 names = PyObject_Dir($module_cname); 33 if (!names) 34 goto bad; 35 for (i = PyList_GET_SIZE(names)-1; i >= 0; i--) { 36#if CYTHON_COMPILING_IN_PYPY 37 PyObject* name = PySequence_GetItem(names, i); 38 if (!name) 39 goto bad; 40#else 41 PyObject* name = PyList_GET_ITEM(names, i); 42#endif 43 if (!PyDict_Contains(globals, name)) { 44 PyObject* value = __Pyx_GetAttr($module_cname, name); 45 if (!value) { 46#if CYTHON_COMPILING_IN_PYPY 47 Py_DECREF(name); 48#endif 49 goto bad; 50 } 51 if (PyDict_SetItem(globals, name, value) < 0) { 52#if CYTHON_COMPILING_IN_PYPY 53 Py_DECREF(name); 54#endif 55 Py_DECREF(value); 56 goto bad; 57 } 58 } 59#if CYTHON_COMPILING_IN_PYPY 60 Py_DECREF(name); 61#endif 62 } 63 Py_DECREF(names); 64 return globals; 65 // d = PyDictProxy_New(globals); 66 // Py_DECREF(globals); 67 // return d; 68bad: 69 Py_XDECREF(names); 70 Py_XDECREF(globals); 71 return NULL; 72} 73 74//////////////////// PyExecGlobals.proto //////////////////// 75 76static PyObject* __Pyx_PyExecGlobals(PyObject*); 77 78//////////////////// PyExecGlobals //////////////////// 79//@requires: Globals 80//@requires: PyExec 81 82static PyObject* __Pyx_PyExecGlobals(PyObject* code) { 83 PyObject* result; 84 PyObject* globals = __Pyx_Globals(); 85 if (unlikely(!globals)) 86 return NULL; 87 result = __Pyx_PyExec2(code, globals); 88 Py_DECREF(globals); 89 return result; 90} 91 92//////////////////// PyExec.proto //////////////////// 93 94static PyObject* __Pyx_PyExec3(PyObject*, PyObject*, PyObject*); 95static CYTHON_INLINE PyObject* __Pyx_PyExec2(PyObject*, PyObject*); 96 97//////////////////// PyExec //////////////////// 98//@substitute: naming 99 100static CYTHON_INLINE PyObject* __Pyx_PyExec2(PyObject* o, PyObject* globals) { 101 return __Pyx_PyExec3(o, globals, NULL); 102} 103 104static PyObject* __Pyx_PyExec3(PyObject* o, PyObject* globals, PyObject* locals) { 105 PyObject* result; 106 PyObject* s = 0; 107 char *code = 0; 108 109 if (!globals || globals == Py_None) { 110 globals = PyModule_GetDict($module_cname); 111 if (!globals) 112 goto bad; 113 } else if (!PyDict_Check(globals)) { 114 PyErr_Format(PyExc_TypeError, "exec() arg 2 must be a dict, not %.200s", 115 Py_TYPE(globals)->tp_name); 116 goto bad; 117 } 118 if (!locals || locals == Py_None) { 119 locals = globals; 120 } 121 122 if (PyDict_GetItem(globals, PYIDENT("__builtins__")) == NULL) { 123 if (PyDict_SetItem(globals, PYIDENT("__builtins__"), PyEval_GetBuiltins()) < 0) 124 goto bad; 125 } 126 127 if (PyCode_Check(o)) { 128 if (PyCode_GetNumFree((PyCodeObject *)o) > 0) { 129 PyErr_SetString(PyExc_TypeError, 130 "code object passed to exec() may not contain free variables"); 131 goto bad; 132 } 133 #if PY_VERSION_HEX < 0x030200B1 134 result = PyEval_EvalCode((PyCodeObject *)o, globals, locals); 135 #else 136 result = PyEval_EvalCode(o, globals, locals); 137 #endif 138 } else { 139 PyCompilerFlags cf; 140 cf.cf_flags = 0; 141 if (PyUnicode_Check(o)) { 142 cf.cf_flags = PyCF_SOURCE_IS_UTF8; 143 s = PyUnicode_AsUTF8String(o); 144 if (!s) goto bad; 145 o = s; 146 #if PY_MAJOR_VERSION >= 3 147 } else if (!PyBytes_Check(o)) { 148 #else 149 } else if (!PyString_Check(o)) { 150 #endif 151 PyErr_Format(PyExc_TypeError, 152 "exec: arg 1 must be string, bytes or code object, got %.200s", 153 Py_TYPE(o)->tp_name); 154 goto bad; 155 } 156 #if PY_MAJOR_VERSION >= 3 157 code = PyBytes_AS_STRING(o); 158 #else 159 code = PyString_AS_STRING(o); 160 #endif 161 if (PyEval_MergeCompilerFlags(&cf)) { 162 result = PyRun_StringFlags(code, Py_file_input, globals, locals, &cf); 163 } else { 164 result = PyRun_String(code, Py_file_input, globals, locals); 165 } 166 Py_XDECREF(s); 167 } 168 169 return result; 170bad: 171 Py_XDECREF(s); 172 return 0; 173} 174 175//////////////////// GetAttr3.proto //////////////////// 176 177static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /*proto*/ 178 179//////////////////// GetAttr3 //////////////////// 180//@requires: ObjectHandling.c::GetAttr 181 182static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { 183 PyObject *r = __Pyx_GetAttr(o, n); 184 if (unlikely(!r)) { 185 if (!PyErr_ExceptionMatches(PyExc_AttributeError)) 186 goto bad; 187 PyErr_Clear(); 188 r = d; 189 Py_INCREF(d); 190 } 191 return r; 192bad: 193 return NULL; 194} 195 196//////////////////// Intern.proto //////////////////// 197 198static PyObject* __Pyx_Intern(PyObject* s); /* proto */ 199 200//////////////////// Intern //////////////////// 201 202static PyObject* __Pyx_Intern(PyObject* s) { 203 if (!(likely(PyString_CheckExact(s)))) { 204 PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(s)->tp_name); 205 return 0; 206 } 207 Py_INCREF(s); 208 #if PY_MAJOR_VERSION >= 3 209 PyUnicode_InternInPlace(&s); 210 #else 211 PyString_InternInPlace(&s); 212 #endif 213 return s; 214} 215 216//////////////////// abs_int.proto //////////////////// 217 218static CYTHON_INLINE unsigned int __Pyx_abs_int(int x) { 219 if (unlikely(x == -INT_MAX-1)) 220 return ((unsigned int)INT_MAX) + 1U; 221 return (unsigned int) abs(x); 222} 223 224//////////////////// abs_long.proto //////////////////// 225 226static CYTHON_INLINE unsigned long __Pyx_abs_long(long x) { 227 if (unlikely(x == -LONG_MAX-1)) 228 return ((unsigned long)LONG_MAX) + 1U; 229 return (unsigned long) labs(x); 230} 231 232//////////////////// abs_longlong.proto //////////////////// 233 234static CYTHON_INLINE unsigned PY_LONG_LONG __Pyx_abs_longlong(PY_LONG_LONG x) { 235#ifndef PY_LLONG_MAX 236#ifdef LLONG_MAX 237 const PY_LONG_LONG PY_LLONG_MAX = LLONG_MAX; 238#else 239 // copied from pyport.h in CPython 3.3, missing in 2.4 240 const PY_LONG_LONG PY_LLONG_MAX = (1 + 2 * ((1LL << (CHAR_BIT * sizeof(PY_LONG_LONG) - 2)) - 1)); 241#endif 242#endif 243 if (unlikely(x == -PY_LLONG_MAX-1)) 244 return ((unsigned PY_LONG_LONG)PY_LLONG_MAX) + 1U; 245#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 246 return (unsigned PY_LONG_LONG) llabs(x); 247#else 248 return (x<0) ? (unsigned PY_LONG_LONG)-x : (unsigned PY_LONG_LONG)x; 249#endif 250} 251 252//////////////////// pow2.proto //////////////////// 253 254#define __Pyx_PyNumber_Power2(a, b) PyNumber_Power(a, b, Py_None) 255 256//////////////////// py_dict_keys.proto //////////////////// 257 258static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d); /*proto*/ 259 260//////////////////// py_dict_keys //////////////////// 261//@requires: ObjectHandling.c::PyObjectCallMethod 262 263static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d) { 264 if (PY_MAJOR_VERSION >= 3) 265 return __Pyx_PyObject_CallMethod1((PyObject*)&PyDict_Type, PYIDENT("keys"), d); 266 else 267 return PyDict_Keys(d); 268} 269 270//////////////////// py_dict_values.proto //////////////////// 271 272static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d); /*proto*/ 273 274//////////////////// py_dict_values //////////////////// 275//@requires: ObjectHandling.c::PyObjectCallMethod 276 277static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d) { 278 if (PY_MAJOR_VERSION >= 3) 279 return __Pyx_PyObject_CallMethod1((PyObject*)&PyDict_Type, PYIDENT("values"), d); 280 else 281 return PyDict_Values(d); 282} 283 284//////////////////// py_dict_items.proto //////////////////// 285 286static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); /*proto*/ 287 288//////////////////// py_dict_items //////////////////// 289//@requires: ObjectHandling.c::PyObjectCallMethod 290 291static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { 292 if (PY_MAJOR_VERSION >= 3) 293 return __Pyx_PyObject_CallMethod1((PyObject*)&PyDict_Type, PYIDENT("items"), d); 294 else 295 return PyDict_Items(d); 296} 297 298//////////////////// py_dict_iterkeys.proto //////////////////// 299 300static CYTHON_INLINE PyObject* __Pyx_PyDict_IterKeys(PyObject* d); /*proto*/ 301 302//////////////////// py_dict_iterkeys //////////////////// 303//@requires: ObjectHandling.c::PyObjectCallMethod 304 305static CYTHON_INLINE PyObject* __Pyx_PyDict_IterKeys(PyObject* d) { 306 return __Pyx_PyObject_CallMethod0(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("keys") : PYIDENT("iterkeys")); 307} 308 309//////////////////// py_dict_itervalues.proto //////////////////// 310 311static CYTHON_INLINE PyObject* __Pyx_PyDict_IterValues(PyObject* d); /*proto*/ 312 313//////////////////// py_dict_itervalues //////////////////// 314//@requires: ObjectHandling.c::PyObjectCallMethod 315 316static CYTHON_INLINE PyObject* __Pyx_PyDict_IterValues(PyObject* d) { 317 return __Pyx_PyObject_CallMethod0(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("values") : PYIDENT("itervalues")); 318} 319 320//////////////////// py_dict_iteritems.proto //////////////////// 321 322static CYTHON_INLINE PyObject* __Pyx_PyDict_IterItems(PyObject* d); /*proto*/ 323 324//////////////////// py_dict_iteritems //////////////////// 325//@requires: ObjectHandling.c::PyObjectCallMethod 326 327static CYTHON_INLINE PyObject* __Pyx_PyDict_IterItems(PyObject* d) { 328 return __Pyx_PyObject_CallMethod0(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("items") : PYIDENT("iteritems")); 329} 330 331//////////////////// py_dict_viewkeys.proto //////////////////// 332 333#if PY_VERSION_HEX < 0x02070000 334#error This module uses dict views, which require Python 2.7 or later 335#endif 336static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewKeys(PyObject* d); /*proto*/ 337 338//////////////////// py_dict_viewkeys //////////////////// 339//@requires: ObjectHandling.c::PyObjectCallMethod 340 341static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewKeys(PyObject* d) { 342 return __Pyx_PyObject_CallMethod0(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("keys") : PYIDENT("viewkeys")); 343} 344 345//////////////////// py_dict_viewvalues.proto //////////////////// 346 347#if PY_VERSION_HEX < 0x02070000 348#error This module uses dict views, which require Python 2.7 or later 349#endif 350static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewValues(PyObject* d); /*proto*/ 351 352//////////////////// py_dict_viewvalues //////////////////// 353//@requires: ObjectHandling.c::PyObjectCallMethod 354 355static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewValues(PyObject* d) { 356 return __Pyx_PyObject_CallMethod0(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("values") : PYIDENT("viewvalues")); 357} 358 359//////////////////// py_dict_viewitems.proto //////////////////// 360 361#if PY_VERSION_HEX < 0x02070000 362#error This module uses dict views, which require Python 2.7 or later 363#endif 364static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewItems(PyObject* d); /*proto*/ 365 366//////////////////// py_dict_viewitems //////////////////// 367//@requires: ObjectHandling.c::PyObjectCallMethod 368 369static CYTHON_INLINE PyObject* __Pyx_PyDict_ViewItems(PyObject* d) { 370 return __Pyx_PyObject_CallMethod0(d, (PY_MAJOR_VERSION >= 3) ? PYIDENT("items") : PYIDENT("viewitems")); 371} 372 373//////////////////// pyset_compat.proto //////////////////// 374 375#if PY_VERSION_HEX < 0x02050000 376#ifndef PyAnySet_CheckExact 377 378#define PyAnySet_CheckExact(ob) \ 379 ((ob)->ob_type == &PySet_Type || \ 380 (ob)->ob_type == &PyFrozenSet_Type) 381 382#define PySet_New(iterable) \ 383 PyObject_CallFunctionObjArgs((PyObject *)&PySet_Type, (iterable), NULL) 384 385#define PyFrozenSet_New(iterable) \ 386 PyObject_CallFunctionObjArgs((PyObject *)&PyFrozenSet_Type, (iterable), NULL) 387 388#define PySet_Size(anyset) \ 389 PyObject_Size((anyset)) 390 391#define PySet_GET_SIZE(anyset) \ 392 PyObject_Size((anyset)) 393 394#define PySet_Contains(anyset, key) \ 395 PySequence_Contains((anyset), (key)) 396 397#define PySet_Pop(set) \ 398 PyObject_CallMethod((set), (char*)"pop", NULL) 399 400static CYTHON_INLINE int PySet_Clear(PyObject *set) { 401 PyObject *ret = PyObject_CallMethod(set, (char*)"clear", NULL); 402 if (!ret) return -1; 403 Py_DECREF(ret); return 0; 404} 405 406static CYTHON_INLINE int PySet_Discard(PyObject *set, PyObject *key) { 407 PyObject *ret = PyObject_CallMethod(set, (char*)"discard", (char*)"(O)", key); 408 if (!ret) return -1; 409 Py_DECREF(ret); return 0; 410} 411 412static CYTHON_INLINE int PySet_Add(PyObject *set, PyObject *key) { 413 PyObject *ret = PyObject_CallMethod(set, (char*)"add", (char*)"(O)", key); 414 if (!ret) return -1; 415 Py_DECREF(ret); return 0; 416} 417 418#endif /* PyAnySet_CheckExact (<= Py2.4) */ 419#endif /* < Py2.5 */ 420 421//////////////////// pyfrozenset_new.proto //////////////////// 422//@substitute: naming 423//@requires: pyset_compat 424 425static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it) { 426 if (it) { 427 PyObject* result; 428 if (PyFrozenSet_CheckExact(it)) { 429 Py_INCREF(it); 430 return it; 431 } 432 result = PyFrozenSet_New(it); 433 if (unlikely(!result)) 434 return NULL; 435 if (likely(PySet_GET_SIZE(result))) 436 return result; 437 // empty frozenset is a singleton 438 // seems wasteful, but CPython does the same 439 Py_DECREF(result); 440 } 441 #if CYTHON_COMPILING_IN_CPYTHON 442 return PyFrozenSet_Type.tp_new(&PyFrozenSet_Type, $empty_tuple, NULL); 443 #else 444 return PyObject_Call((PyObject*)&PyFrozenSet_Type, $empty_tuple, NULL); 445 #endif 446} 447