third_party/cython/src/Cython/Utility/Optimize.c

   1 /*
   2  * Optional optimisations of built-in functions and methods.
   3  *
   4  * Required replacements of builtins are in Builtins.c.
   5  *
   6  * General object operations and protocols are in ObjectHandling.c.
   7  */
   8
   9 /////////////// append.proto ///////////////
  10
  11 static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); /*proto*/
  12
  13 /////////////// append ///////////////
  14 //@requires: ListAppend
  15 //@requires: ObjectHandling.c::PyObjectCallMethod
  16
  17 static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
  18     if (likely(PyList_CheckExact(L))) {
  19         if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1;
  20     } else {
  21         PyObject* retval = __Pyx_PyObject_CallMethod1(L, PYIDENT("append"), x);
  22         if (unlikely(!retval))
  23             return -1;
  24         Py_DECREF(retval);
  25     }
  26     return 0;
  27 }
  28
  29 /////////////// ListAppend.proto ///////////////
  30
  31 #if CYTHON_COMPILING_IN_CPYTHON
  32 static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
  33     PyListObject* L = (PyListObject*) list;
  34     Py_ssize_t len = Py_SIZE(list);
  35     if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
  36         Py_INCREF(x);
  37         PyList_SET_ITEM(list, len, x);
  38         Py_SIZE(list) = len+1;
  39         return 0;
  40     }
  41     return PyList_Append(list, x);
  42 }
  43 #else
  44 #define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
  45 #endif
  46
  47 /////////////// ListCompAppend.proto ///////////////
  48
  49 #if CYTHON_COMPILING_IN_CPYTHON
  50 static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
  51     PyListObject* L = (PyListObject*) list;
  52     Py_ssize_t len = Py_SIZE(list);
  53     if (likely(L->allocated > len)) {
  54         Py_INCREF(x);
  55         PyList_SET_ITEM(list, len, x);
  56         Py_SIZE(list) = len+1;
  57         return 0;
  58     }
  59     return PyList_Append(list, x);
  60 }
  61 #else
  62 #define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
  63 #endif
  64
  65 //////////////////// ListExtend.proto ////////////////////
  66
  67 static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) {
  68 #if CYTHON_COMPILING_IN_CPYTHON
  69     PyObject* none = _PyList_Extend((PyListObject*)L, v);
  70     if (unlikely(!none))
  71         return -1;
  72     Py_DECREF(none);
  73     return 0;
  74 #else
  75     return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v);
  76 #endif
  77 }
  78
  79 /////////////// pop.proto ///////////////
  80
  81 #define __Pyx_PyObject_Pop(L) (PyList_CheckExact(L) ? \
  82     __Pyx_PyList_Pop(L) : __Pyx__PyObject_Pop(L))
  83
  84 static CYTHON_INLINE PyObject* __Pyx_PyList_Pop(PyObject* L); /*proto*/
  85 static CYTHON_INLINE PyObject* __Pyx__PyObject_Pop(PyObject* L); /*proto*/
  86
  87 /////////////// pop ///////////////
  88 //@requires: ObjectHandling.c::PyObjectCallMethod
  89
  90 static CYTHON_INLINE PyObject* __Pyx__PyObject_Pop(PyObject* L) {
  91 #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02050000
  92     if (Py_TYPE(L) == &PySet_Type) {
  93         return PySet_Pop(L);
  94     }
  95 #endif
  96     return __Pyx_PyObject_CallMethod0(L, PYIDENT("pop"));
  97 }
  98
  99 static CYTHON_INLINE PyObject* __Pyx_PyList_Pop(PyObject* L) {
 100 #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02040000
 101     /* Check that both the size is positive and no reallocation shrinking needs to be done. */
 102     if (likely(PyList_GET_SIZE(L) > (((PyListObject*)L)->allocated >> 1))) {
 103         Py_SIZE(L) -= 1;
 104         return PyList_GET_ITEM(L, PyList_GET_SIZE(L));
 105     }
 106 #endif
 107     return __Pyx_PyObject_CallMethod0(L, PYIDENT("pop"));
 108 }
 109
 110
 111 /////////////// pop_index.proto ///////////////
 112
 113 #define __Pyx_PyObject_PopIndex(L, ix) (PyList_CheckExact(L) ? \
 114     __Pyx_PyList_PopIndex(L, ix) : __Pyx__PyObject_PopIndex(L, ix))
 115
 116 static PyObject* __Pyx_PyList_PopIndex(PyObject* L, Py_ssize_t ix); /*proto*/
 117 static PyObject* __Pyx__PyObject_PopIndex(PyObject* L, Py_ssize_t ix); /*proto*/
 118
 119 /////////////// pop_index ///////////////
 120 //@requires: ObjectHandling.c::PyObjectCallMethod
 121
 122 static PyObject* __Pyx__PyObject_PopIndex(PyObject* L, Py_ssize_t ix) {
 123     PyObject *r, *py_ix;
 124     py_ix = PyInt_FromSsize_t(ix);
 125     if (!py_ix) return NULL;
 126     r = __Pyx_PyObject_CallMethod1(L, PYIDENT("pop"), py_ix);
 127     Py_DECREF(py_ix);
 128     return r;
 129 }
 130
 131 static PyObject* __Pyx_PyList_PopIndex(PyObject* L, Py_ssize_t ix) {
 132 #if CYTHON_COMPILING_IN_CPYTHON
 133     Py_ssize_t size = PyList_GET_SIZE(L);
 134     if (likely(size > (((PyListObject*)L)->allocated >> 1))) {
 135         Py_ssize_t cix = ix;
 136         if (cix < 0) {
 137             cix += size;
 138         }
 139         if (likely(0 <= cix && cix < size)) {
 140             PyObject* v = PyList_GET_ITEM(L, cix);
 141             Py_SIZE(L) -= 1;
 142             size -= 1;
 143             memmove(&PyList_GET_ITEM(L, cix), &PyList_GET_ITEM(L, cix+1), (size_t)(size-cix)*sizeof(PyObject*));
 144             return v;
 145         }
 146     }
 147 #endif
 148     return __Pyx__PyObject_PopIndex(L, ix);
 149 }
 150
 151
 152 /////////////// dict_getitem_default.proto ///////////////
 153
 154 static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); /*proto*/
 155
 156 /////////////// dict_getitem_default ///////////////
 157
 158 static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) {
 159     PyObject* value;
 160 #if PY_MAJOR_VERSION >= 3
 161     value = PyDict_GetItemWithError(d, key);
 162     if (unlikely(!value)) {
 163         if (unlikely(PyErr_Occurred()))
 164             return NULL;
 165         value = default_value;
 166     }
 167     Py_INCREF(value);
 168 #else
 169     if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) {
 170         /* these presumably have safe hash functions */
 171         value = PyDict_GetItem(d, key);
 172         if (unlikely(!value)) {
 173             value = default_value;
 174         }
 175         Py_INCREF(value);
 176     } else {
 177         if (default_value == Py_None)
 178             default_value = NULL;
 179         value = PyObject_CallMethodObjArgs(
 180             d, PYIDENT("get"), key, default_value, NULL);
 181     }
 182 #endif
 183     return value;
 184 }
 185
 186
 187 /////////////// dict_setdefault.proto ///////////////
 188
 189 static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, int is_safe_type); /*proto*/
 190
 191 /////////////// dict_setdefault ///////////////
 192 //@requires: ObjectHandling.c::PyObjectCallMethod
 193
 194 static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value,
 195                                                        CYTHON_UNUSED int is_safe_type) {
 196     PyObject* value;
 197 #if PY_VERSION_HEX >= 0x030400A0
 198     // we keep the method call at the end to avoid "unused" C compiler warnings
 199     if (1) {
 200         value = PyDict_SetDefault(d, key, default_value);
 201         if (unlikely(!value)) return NULL;
 202         Py_INCREF(value);
 203 #else
 204     if (is_safe_type == 1 || (is_safe_type == -1 &&
 205         /* the following builtins presumably have repeatably safe and fast hash functions */
 206 #if PY_MAJOR_VERSION >= 3
 207             (PyUnicode_CheckExact(key) || PyString_CheckExact(key) || PyLong_CheckExact(key)))) {
 208         value = PyDict_GetItemWithError(d, key);
 209         if (unlikely(!value)) {
 210             if (unlikely(PyErr_Occurred()))
 211                 return NULL;
 212             if (unlikely(PyDict_SetItem(d, key, default_value) == -1))
 213                 return NULL;
 214             value = default_value;
 215         }
 216         Py_INCREF(value);
 217 #else
 218             (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key) || PyLong_CheckExact(key)))) {
 219         value = PyDict_GetItem(d, key);
 220         if (unlikely(!value)) {
 221             if (unlikely(PyDict_SetItem(d, key, default_value) == -1))
 222                 return NULL;
 223             value = default_value;
 224         }
 225         Py_INCREF(value);
 226 #endif
 227 #endif
 228     } else {
 229         value = __Pyx_PyObject_CallMethod2(d, PYIDENT("setdefault"), key, default_value);
 230     }
 231     return value;
 232 }
 233
 234
 235 /////////////// py_dict_clear.proto ///////////////
 236
 237 #define __Pyx_PyDict_Clear(d) (PyDict_Clear(d), 0)
 238
 239 /////////////// dict_iter.proto ///////////////
 240
 241 static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name,
 242                                                    Py_ssize_t* p_orig_length, int* p_is_dict);
 243 static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos,
 244                                               PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict);
 245
 246 /////////////// dict_iter ///////////////
 247 //@requires: ObjectHandling.c::UnpackTuple2
 248 //@requires: ObjectHandling.c::IterFinish
 249 //@requires: ObjectHandling.c::PyObjectCallMethod
 250
 251 static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name,
 252                                                    Py_ssize_t* p_orig_length, int* p_source_is_dict) {
 253     is_dict = is_dict || likely(PyDict_CheckExact(iterable));
 254     *p_source_is_dict = is_dict;
 255 #if !CYTHON_COMPILING_IN_PYPY
 256     if (is_dict) {
 257         *p_orig_length = PyDict_Size(iterable);
 258         Py_INCREF(iterable);
 259         return iterable;
 260     }
 261 #endif
 262     *p_orig_length = 0;
 263     if (method_name) {
 264         PyObject* iter;
 265         iterable = __Pyx_PyObject_CallMethod0(iterable, method_name);
 266         if (!iterable)
 267             return NULL;
 268 #if !CYTHON_COMPILING_IN_PYPY
 269         if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable))
 270             return iterable;
 271 #endif
 272         iter = PyObject_GetIter(iterable);
 273         Py_DECREF(iterable);
 274         return iter;
 275     }
 276     return PyObject_GetIter(iterable);
 277 }
 278
 279 static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* iter_obj, Py_ssize_t orig_length, Py_ssize_t* ppos,
 280                                               PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) {
 281     PyObject* next_item;
 282 #if !CYTHON_COMPILING_IN_PYPY
 283     if (source_is_dict) {
 284         PyObject *key, *value;
 285         if (unlikely(orig_length != PyDict_Size(iter_obj))) {
 286             PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration");
 287             return -1;
 288         }
 289         if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) {
 290             return 0;
 291         }
 292         if (pitem) {
 293             PyObject* tuple = PyTuple_New(2);
 294             if (unlikely(!tuple)) {
 295                 return -1;
 296             }
 297             Py_INCREF(key);
 298             Py_INCREF(value);
 299             PyTuple_SET_ITEM(tuple, 0, key);
 300             PyTuple_SET_ITEM(tuple, 1, value);
 301             *pitem = tuple;
 302         } else {
 303             if (pkey) {
 304                 Py_INCREF(key);
 305                 *pkey = key;
 306             }
 307             if (pvalue) {
 308                 Py_INCREF(value);
 309                 *pvalue = value;
 310             }
 311         }
 312         return 1;
 313     } else if (PyTuple_CheckExact(iter_obj)) {
 314         Py_ssize_t pos = *ppos;
 315         if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0;
 316         *ppos = pos + 1;
 317         next_item = PyTuple_GET_ITEM(iter_obj, pos);
 318         Py_INCREF(next_item);
 319     } else if (PyList_CheckExact(iter_obj)) {
 320         Py_ssize_t pos = *ppos;
 321         if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0;
 322         *ppos = pos + 1;
 323         next_item = PyList_GET_ITEM(iter_obj, pos);
 324         Py_INCREF(next_item);
 325     } else
 326 #endif
 327     {
 328         next_item = PyIter_Next(iter_obj);
 329         if (unlikely(!next_item)) {
 330             return __Pyx_IterFinish();
 331         }
 332     }
 333     if (pitem) {
 334         *pitem = next_item;
 335     } else if (pkey && pvalue) {
 336         if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1))
 337             return -1;
 338     } else if (pkey) {
 339         *pkey = next_item;
 340     } else {
 341         *pvalue = next_item;
 342     }
 343     return 1;
 344 }
 345
 346
 347 /////////////// unicode_iter.proto ///////////////
 348
 349 static CYTHON_INLINE int __Pyx_init_unicode_iteration(
 350     PyObject* ustring, Py_ssize_t *length, void** data, int *kind); /* proto */
 351
 352 /////////////// unicode_iter ///////////////
 353
 354 static CYTHON_INLINE int __Pyx_init_unicode_iteration(
 355     PyObject* ustring, Py_ssize_t *length, void** data, int *kind) {
 356 #if CYTHON_PEP393_ENABLED
 357     if (unlikely(__Pyx_PyUnicode_READY(ustring) < 0)) return -1;
 358     *kind   = PyUnicode_KIND(ustring);
 359     *length = PyUnicode_GET_LENGTH(ustring);
 360     *data   = PyUnicode_DATA(ustring);
 361 #else
 362     *kind   = 0;
 363     *length = PyUnicode_GET_SIZE(ustring);
 364     *data   = (void*)PyUnicode_AS_UNICODE(ustring);
 365 #endif
 366     return 0;
 367 }
 368
 369 /////////////// pyobject_as_double.proto ///////////////
 370
 371 static double __Pyx__PyObject_AsDouble(PyObject* obj); /* proto */
 372
 373 #if CYTHON_COMPILING_IN_PYPY
 374 #define __Pyx_PyObject_AsDouble(obj) \
 375 (likely(PyFloat_CheckExact(obj)) ? PyFloat_AS_DOUBLE(obj) : \
 376  likely(PyInt_CheckExact(obj)) ? \
 377  PyFloat_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj))
 378 #else
 379 #define __Pyx_PyObject_AsDouble(obj) \
 380 ((likely(PyFloat_CheckExact(obj))) ? \
 381  PyFloat_AS_DOUBLE(obj) : __Pyx__PyObject_AsDouble(obj))
 382 #endif
 383
 384 /////////////// pyobject_as_double ///////////////
 385
 386 static double __Pyx__PyObject_AsDouble(PyObject* obj) {
 387     PyObject* float_value;
 388 #if CYTHON_COMPILING_IN_PYPY
 389     float_value = PyNumber_Float(obj);
 390 #else
 391     PyNumberMethods *nb = Py_TYPE(obj)->tp_as_number;
 392     if (likely(nb) && likely(nb->nb_float)) {
 393         float_value = nb->nb_float(obj);
 394         if (likely(float_value) && unlikely(!PyFloat_Check(float_value))) {
 395             PyErr_Format(PyExc_TypeError,
 396                 "__float__ returned non-float (type %.200s)",
 397                 Py_TYPE(float_value)->tp_name);
 398             Py_DECREF(float_value);
 399             goto bad;
 400         }
 401     } else if (PyUnicode_CheckExact(obj) || PyBytes_CheckExact(obj)) {
 402 #if PY_MAJOR_VERSION >= 3
 403         float_value = PyFloat_FromString(obj);
 404 #else
 405         float_value = PyFloat_FromString(obj, 0);
 406 #endif
 407     } else {
 408         PyObject* args = PyTuple_New(1);
 409         if (unlikely(!args)) goto bad;
 410         PyTuple_SET_ITEM(args, 0, obj);
 411         float_value = PyObject_Call((PyObject*)&PyFloat_Type, args, 0);
 412         PyTuple_SET_ITEM(args, 0, 0);
 413         Py_DECREF(args);
 414     }
 415 #endif
 416     if (likely(float_value)) {
 417         double value = PyFloat_AS_DOUBLE(float_value);
 418         Py_DECREF(float_value);
 419         return value;
 420     }
 421 bad:
 422     return (double)-1;
 423 }