| //////////////////// ArgTypeTest.proto //////////////////// |
| |
| static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, |
| const char *name, int exact); /*proto*/ |
| |
| //////////////////// ArgTypeTest //////////////////// |
| |
| static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { |
| PyErr_Format(PyExc_TypeError, |
| "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", |
| name, type->tp_name, Py_TYPE(obj)->tp_name); |
| } |
| |
| static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, |
| const char *name, int exact) |
| { |
| if (unlikely(!type)) { |
| PyErr_SetString(PyExc_SystemError, "Missing type object"); |
| return 0; |
| } |
| if (none_allowed && obj == Py_None) return 1; |
| else if (exact) { |
| if (likely(Py_TYPE(obj) == type)) return 1; |
| #if PY_MAJOR_VERSION == 2 |
| else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; |
| #endif |
| } |
| else { |
| if (likely(PyObject_TypeCheck(obj, type))) return 1; |
| } |
| __Pyx_RaiseArgumentTypeInvalid(name, obj, type); |
| return 0; |
| } |
| |
| //////////////////// RaiseArgTupleInvalid.proto //////////////////// |
| |
| static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, |
| Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /*proto*/ |
| |
| //////////////////// RaiseArgTupleInvalid //////////////////// |
| |
| // __Pyx_RaiseArgtupleInvalid raises the correct exception when too |
| // many or too few positional arguments were found. This handles |
| // Py_ssize_t formatting correctly. |
| |
| static void __Pyx_RaiseArgtupleInvalid( |
| const char* func_name, |
| int exact, |
| Py_ssize_t num_min, |
| Py_ssize_t num_max, |
| Py_ssize_t num_found) |
| { |
| Py_ssize_t num_expected; |
| const char *more_or_less; |
| |
| if (num_found < num_min) { |
| num_expected = num_min; |
| more_or_less = "at least"; |
| } else { |
| num_expected = num_max; |
| more_or_less = "at most"; |
| } |
| if (exact) { |
| more_or_less = "exactly"; |
| } |
| PyErr_Format(PyExc_TypeError, |
| "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", |
| func_name, more_or_less, num_expected, |
| (num_expected == 1) ? "" : "s", num_found); |
| } |
| |
| |
| //////////////////// RaiseKeywordRequired.proto //////////////////// |
| |
| static CYTHON_INLINE void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name); /*proto*/ |
| |
| //////////////////// RaiseKeywordRequired //////////////////// |
| |
| static CYTHON_INLINE void __Pyx_RaiseKeywordRequired( |
| const char* func_name, |
| PyObject* kw_name) |
| { |
| PyErr_Format(PyExc_TypeError, |
| #if PY_MAJOR_VERSION >= 3 |
| "%s() needs keyword-only argument %U", func_name, kw_name); |
| #else |
| "%s() needs keyword-only argument %s", func_name, |
| PyString_AS_STRING(kw_name)); |
| #endif |
| } |
| |
| |
| //////////////////// RaiseDoubleKeywords.proto //////////////////// |
| |
| static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /*proto*/ |
| |
| //////////////////// RaiseDoubleKeywords //////////////////// |
| |
| static void __Pyx_RaiseDoubleKeywordsError( |
| const char* func_name, |
| PyObject* kw_name) |
| { |
| PyErr_Format(PyExc_TypeError, |
| #if PY_MAJOR_VERSION >= 3 |
| "%s() got multiple values for keyword argument '%U'", func_name, kw_name); |
| #else |
| "%s() got multiple values for keyword argument '%s'", func_name, |
| PyString_AsString(kw_name)); |
| #endif |
| } |
| |
| |
| //////////////////// KeywordStringCheck.proto //////////////////// |
| |
| static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); /*proto*/ |
| |
| //////////////////// KeywordStringCheck //////////////////// |
| |
| // __Pyx_CheckKeywordStrings raises an error if non-string keywords |
| // were passed to a function, or if any keywords were passed to a |
| // function that does not accept them. |
| |
| static CYTHON_INLINE int __Pyx_CheckKeywordStrings( |
| PyObject *kwdict, |
| const char* function_name, |
| int kw_allowed) |
| { |
| PyObject* key = 0; |
| Py_ssize_t pos = 0; |
| #if CYTHON_COMPILING_IN_PYPY |
| /* PyPy appears to check keywords at call time, not at unpacking time => not much to do here */ |
| if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) |
| goto invalid_keyword; |
| return 1; |
| #else |
| while (PyDict_Next(kwdict, &pos, &key, 0)) { |
| #if PY_MAJOR_VERSION < 3 |
| if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) |
| #endif |
| if (unlikely(!PyUnicode_Check(key))) |
| goto invalid_keyword_type; |
| } |
| if ((!kw_allowed) && unlikely(key)) |
| goto invalid_keyword; |
| return 1; |
| invalid_keyword_type: |
| PyErr_Format(PyExc_TypeError, |
| "%.200s() keywords must be strings", function_name); |
| return 0; |
| #endif |
| invalid_keyword: |
| PyErr_Format(PyExc_TypeError, |
| #if PY_MAJOR_VERSION < 3 |
| "%.200s() got an unexpected keyword argument '%.200s'", |
| function_name, PyString_AsString(key)); |
| #else |
| "%s() got an unexpected keyword argument '%U'", |
| function_name, key); |
| #endif |
| return 0; |
| } |
| |
| |
| //////////////////// ParseKeywords.proto //////////////////// |
| |
| static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \ |
| PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \ |
| const char* function_name); /*proto*/ |
| |
| //////////////////// ParseKeywords //////////////////// |
| //@requires: RaiseDoubleKeywords |
| |
| // __Pyx_ParseOptionalKeywords copies the optional/unknown keyword |
| // arguments from the kwds dict into kwds2. If kwds2 is NULL, unknown |
| // keywords will raise an invalid keyword error. |
| // |
| // Three kinds of errors are checked: 1) non-string keywords, 2) |
| // unexpected keywords and 3) overlap with positional arguments. |
| // |
| // If num_posargs is greater 0, it denotes the number of positional |
| // arguments that were passed and that must therefore not appear |
| // amongst the keywords as well. |
| // |
| // This method does not check for required keyword arguments. |
| |
| static int __Pyx_ParseOptionalKeywords( |
| PyObject *kwds, |
| PyObject **argnames[], |
| PyObject *kwds2, |
| PyObject *values[], |
| Py_ssize_t num_pos_args, |
| const char* function_name) |
| { |
| PyObject *key = 0, *value = 0; |
| Py_ssize_t pos = 0; |
| PyObject*** name; |
| PyObject*** first_kw_arg = argnames + num_pos_args; |
| |
| while (PyDict_Next(kwds, &pos, &key, &value)) { |
| name = first_kw_arg; |
| while (*name && (**name != key)) name++; |
| if (*name) { |
| values[name-argnames] = value; |
| continue; |
| } |
| |
| name = first_kw_arg; |
| #if PY_MAJOR_VERSION < 3 |
| if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { |
| while (*name) { |
| if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) |
| && _PyString_Eq(**name, key)) { |
| values[name-argnames] = value; |
| break; |
| } |
| name++; |
| } |
| if (*name) continue; |
| else { |
| // not found after positional args, check for duplicate |
| PyObject*** argname = argnames; |
| while (argname != first_kw_arg) { |
| if ((**argname == key) || ( |
| (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) |
| && _PyString_Eq(**argname, key))) { |
| goto arg_passed_twice; |
| } |
| argname++; |
| } |
| } |
| } else |
| #endif |
| if (likely(PyUnicode_Check(key))) { |
| while (*name) { |
| int cmp = (**name == key) ? 0 : |
| #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 |
| (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : |
| #endif |
| // need to convert argument name from bytes to unicode for comparison |
| PyUnicode_Compare(**name, key); |
| if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; |
| if (cmp == 0) { |
| values[name-argnames] = value; |
| break; |
| } |
| name++; |
| } |
| if (*name) continue; |
| else { |
| // not found after positional args, check for duplicate |
| PyObject*** argname = argnames; |
| while (argname != first_kw_arg) { |
| int cmp = (**argname == key) ? 0 : |
| #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 |
| (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : |
| #endif |
| // need to convert argument name from bytes to unicode for comparison |
| PyUnicode_Compare(**argname, key); |
| if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; |
| if (cmp == 0) goto arg_passed_twice; |
| argname++; |
| } |
| } |
| } else |
| goto invalid_keyword_type; |
| |
| if (kwds2) { |
| if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; |
| } else { |
| goto invalid_keyword; |
| } |
| } |
| return 0; |
| arg_passed_twice: |
| __Pyx_RaiseDoubleKeywordsError(function_name, key); |
| goto bad; |
| invalid_keyword_type: |
| PyErr_Format(PyExc_TypeError, |
| "%.200s() keywords must be strings", function_name); |
| goto bad; |
| invalid_keyword: |
| PyErr_Format(PyExc_TypeError, |
| #if PY_MAJOR_VERSION < 3 |
| "%.200s() got an unexpected keyword argument '%.200s'", |
| function_name, PyString_AsString(key)); |
| #else |
| "%s() got an unexpected keyword argument '%U'", |
| function_name, key); |
| #endif |
| bad: |
| return -1; |
| } |
