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