| /* getargs implementation copied from Python 3.8 and stripped down to only include |
| * the functions we need. |
| * We also add support for required kwonly args and accepting *args / **kwargs. |
| * A good idea would be to also vendor in the Fast versions and get our stuff |
| * working with *that*. |
| * Another probably good idea is to strip out all the formatting stuff we don't need |
| * and then add in custom stuff that we do need. |
| * |
| * DOCUMENTATION OF THE EXTENSIONS: |
| * - Arguments given after a @ format specify are required keyword-only arguments. |
| * The | and $ specifiers must both appear before @. |
| * - If the first character of a format string is %, then the function can support |
| * *args and **kwargs. On seeing a %, the parser will consume two arguments, |
| * which should be pointers to variables to store the *args and **kwargs, respectively. |
| * Either pointer can be NULL, in which case the function doesn't take that |
| * variety of vararg. |
| * Unlike most format specifiers, the caller takes ownership of these objects |
| * and is responsible for decrefing them. |
| * - All arguments must use the 'O' format. |
| * - There's minimal error checking of format strings. They are generated |
| * programmatically and can be assumed valid. |
| */ |
| |
| // These macro definitions are copied from pyport.h in Python 3.9 and later |
| // https://bugs.python.org/issue19569 |
| #if defined(__clang__) |
| #define _Py_COMP_DIAG_PUSH _Pragma("clang diagnostic push") |
| #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ |
| _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") |
| #define _Py_COMP_DIAG_POP _Pragma("clang diagnostic pop") |
| #elif defined(__GNUC__) \ |
| && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) |
| #define _Py_COMP_DIAG_PUSH _Pragma("GCC diagnostic push") |
| #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ |
| _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") |
| #define _Py_COMP_DIAG_POP _Pragma("GCC diagnostic pop") |
| #elif defined(_MSC_VER) |
| #define _Py_COMP_DIAG_PUSH __pragma(warning(push)) |
| #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS __pragma(warning(disable: 4996)) |
| #define _Py_COMP_DIAG_POP __pragma(warning(pop)) |
| #else |
| #define _Py_COMP_DIAG_PUSH |
| #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS |
| #define _Py_COMP_DIAG_POP |
| #endif |
| |
| #include "Python.h" |
| #include "pythonsupport.h" |
| |
| #include <ctype.h> |
| #include <float.h> |
| |
| #ifndef PyDict_GET_SIZE |
| #define PyDict_GET_SIZE(d) PyDict_Size(d) |
| #endif |
| |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| int CPyArg_ParseTupleAndKeywords(PyObject *, PyObject *, |
| const char *, const char *, const char * const *, ...); |
| |
| /* Forward */ |
| static int vgetargskeywords(PyObject *, PyObject *, |
| const char *, const char *, const char * const *, va_list *); |
| static void skipitem(const char **, va_list *); |
| |
| /* Support for keyword arguments donated by |
| Geoff Philbrick <philbric@delphi.hks.com> */ |
| |
| /* Return false (0) for error, else true. */ |
| int |
| CPyArg_ParseTupleAndKeywords(PyObject *args, |
| PyObject *keywords, |
| const char *format, |
| const char *fname, |
| const char * const *kwlist, ...) |
| { |
| int retval; |
| va_list va; |
| |
| va_start(va, kwlist); |
| retval = vgetargskeywords(args, keywords, format, fname, kwlist, &va); |
| va_end(va); |
| return retval; |
| } |
| |
| #define IS_END_OF_FORMAT(c) (c == '\0' || c == ';' || c == ':') |
| |
| static int |
| vgetargskeywords(PyObject *args, PyObject *kwargs, const char *format, |
| const char *fname, const char * const *kwlist, va_list *p_va) |
| { |
| int min = INT_MAX; |
| int max = INT_MAX; |
| int required_kwonly_start = INT_MAX; |
| int has_required_kws = 0; |
| int i, pos, len; |
| int skip = 0; |
| Py_ssize_t nargs, nkwargs; |
| PyObject *current_arg; |
| int bound_pos_args; |
| |
| PyObject **p_args = NULL, **p_kwargs = NULL; |
| |
| assert(args != NULL && PyTuple_Check(args)); |
| assert(kwargs == NULL || PyDict_Check(kwargs)); |
| assert(format != NULL); |
| assert(kwlist != NULL); |
| assert(p_va != NULL); |
| |
| /* scan kwlist and count the number of positional-only parameters */ |
| for (pos = 0; kwlist[pos] && !*kwlist[pos]; pos++) { |
| } |
| /* scan kwlist and get greatest possible nbr of args */ |
| for (len = pos; kwlist[len]; len++) { |
| #ifdef DEBUG |
| if (!*kwlist[len]) { |
| PyErr_SetString(PyExc_SystemError, |
| "Empty keyword parameter name"); |
| return 0; |
| } |
| #endif |
| } |
| |
| if (*format == '%') { |
| p_args = va_arg(*p_va, PyObject **); |
| p_kwargs = va_arg(*p_va, PyObject **); |
| format++; |
| } |
| |
| nargs = PyTuple_GET_SIZE(args); |
| nkwargs = (kwargs == NULL) ? 0 : PyDict_GET_SIZE(kwargs); |
| if (unlikely(nargs + nkwargs > len && !p_args && !p_kwargs)) { |
| /* Adding "keyword" (when nargs == 0) prevents producing wrong error |
| messages in some special cases (see bpo-31229). */ |
| PyErr_Format(PyExc_TypeError, |
| "%.200s%s takes at most %d %sargument%s (%zd given)", |
| (fname == NULL) ? "function" : fname, |
| (fname == NULL) ? "" : "()", |
| len, |
| (nargs == 0) ? "keyword " : "", |
| (len == 1) ? "" : "s", |
| nargs + nkwargs); |
| return 0; |
| } |
| |
| /* convert tuple args and keyword args in same loop, using kwlist to drive process */ |
| for (i = 0; i < len; i++) { |
| if (*format == '|') { |
| #ifdef DEBUG |
| if (min != INT_MAX) { |
| PyErr_SetString(PyExc_SystemError, |
| "Invalid format string (| specified twice)"); |
| return 0; |
| } |
| #endif |
| |
| min = i; |
| format++; |
| |
| #ifdef DEBUG |
| if (max != INT_MAX) { |
| PyErr_SetString(PyExc_SystemError, |
| "Invalid format string ($ before |)"); |
| return 0; |
| } |
| #endif |
| |
| /* If there are optional args, figure out whether we have |
| * required keyword arguments so that we don't bail without |
| * enforcing them. */ |
| has_required_kws = strchr(format, '@') != NULL; |
| } |
| if (*format == '$') { |
| #ifdef DEBUG |
| if (max != INT_MAX) { |
| PyErr_SetString(PyExc_SystemError, |
| "Invalid format string ($ specified twice)"); |
| return 0; |
| } |
| #endif |
| |
| max = i; |
| format++; |
| |
| #ifdef DEBUG |
| if (max < pos) { |
| PyErr_SetString(PyExc_SystemError, |
| "Empty parameter name after $"); |
| return 0; |
| } |
| #endif |
| if (skip) { |
| /* Now we know the minimal and the maximal numbers of |
| * positional arguments and can raise an exception with |
| * informative message (see below). */ |
| break; |
| } |
| if (unlikely(max < nargs && !p_args)) { |
| if (max == 0) { |
| PyErr_Format(PyExc_TypeError, |
| "%.200s%s takes no positional arguments", |
| (fname == NULL) ? "function" : fname, |
| (fname == NULL) ? "" : "()"); |
| } |
| else { |
| PyErr_Format(PyExc_TypeError, |
| "%.200s%s takes %s %d positional argument%s" |
| " (%zd given)", |
| (fname == NULL) ? "function" : fname, |
| (fname == NULL) ? "" : "()", |
| (min < max) ? "at most" : "exactly", |
| max, |
| max == 1 ? "" : "s", |
| nargs); |
| } |
| return 0; |
| } |
| } |
| if (*format == '@') { |
| #ifdef DEBUG |
| if (min == INT_MAX && max == INT_MAX) { |
| PyErr_SetString(PyExc_SystemError, |
| "Invalid format string " |
| "(@ without preceding | and $)"); |
| return 0; |
| } |
| if (required_kwonly_start != INT_MAX) { |
| PyErr_SetString(PyExc_SystemError, |
| "Invalid format string (@ specified twice)"); |
| return 0; |
| } |
| #endif |
| |
| required_kwonly_start = i; |
| format++; |
| } |
| #ifdef DEBUG |
| if (IS_END_OF_FORMAT(*format)) { |
| PyErr_Format(PyExc_SystemError, |
| "More keyword list entries (%d) than " |
| "format specifiers (%d)", len, i); |
| return 0; |
| } |
| #endif |
| if (!skip) { |
| if (i < nargs && i < max) { |
| current_arg = PyTuple_GET_ITEM(args, i); |
| } |
| else if (nkwargs && i >= pos) { |
| current_arg = _PyDict_GetItemStringWithError(kwargs, kwlist[i]); |
| if (current_arg) { |
| --nkwargs; |
| } |
| else if (PyErr_Occurred()) { |
| return 0; |
| } |
| } |
| else { |
| current_arg = NULL; |
| } |
| |
| if (current_arg) { |
| PyObject **p = va_arg(*p_va, PyObject **); |
| *p = current_arg; |
| format++; |
| continue; |
| } |
| |
| if (i < min || i >= required_kwonly_start) { |
| if (likely(i < pos)) { |
| assert (min == INT_MAX); |
| assert (max == INT_MAX); |
| skip = 1; |
| /* At that moment we still don't know the minimal and |
| * the maximal numbers of positional arguments. Raising |
| * an exception is deferred until we encounter | and $ |
| * or the end of the format. */ |
| } |
| else { |
| if (i >= max) { |
| PyErr_Format(PyExc_TypeError, |
| "%.200s%s missing required " |
| "keyword-only argument '%s'", |
| (fname == NULL) ? "function" : fname, |
| (fname == NULL) ? "" : "()", |
| kwlist[i]); |
| } |
| else { |
| PyErr_Format(PyExc_TypeError, |
| "%.200s%s missing required " |
| "argument '%s' (pos %d)", |
| (fname == NULL) ? "function" : fname, |
| (fname == NULL) ? "" : "()", |
| kwlist[i], i+1); |
| } |
| return 0; |
| } |
| } |
| /* current code reports success when all required args |
| * fulfilled and no keyword args left, with no further |
| * validation. XXX Maybe skip this in debug build ? |
| */ |
| if (!nkwargs && !skip && !has_required_kws && |
| !p_args && !p_kwargs) |
| { |
| return 1; |
| } |
| } |
| |
| /* We are into optional args, skip through to any remaining |
| * keyword args */ |
| skipitem(&format, p_va); |
| } |
| |
| if (unlikely(skip)) { |
| PyErr_Format(PyExc_TypeError, |
| "%.200s%s takes %s %d positional argument%s" |
| " (%zd given)", |
| (fname == NULL) ? "function" : fname, |
| (fname == NULL) ? "" : "()", |
| (Py_MIN(pos, min) < i) ? "at least" : "exactly", |
| Py_MIN(pos, min), |
| Py_MIN(pos, min) == 1 ? "" : "s", |
| nargs); |
| return 0; |
| } |
| |
| #ifdef DEBUG |
| if (!IS_END_OF_FORMAT(*format) && |
| (*format != '|') && (*format != '$') && (*format != '@')) |
| { |
| PyErr_Format(PyExc_SystemError, |
| "more argument specifiers than keyword list entries " |
| "(remaining format:'%s')", format); |
| return 0; |
| } |
| #endif |
| |
| bound_pos_args = Py_MIN(nargs, Py_MIN(max, len)); |
| if (p_args) { |
| *p_args = PyTuple_GetSlice(args, bound_pos_args, nargs); |
| if (!*p_args) { |
| return 0; |
| } |
| } |
| |
| if (p_kwargs) { |
| /* This unfortunately needs to be special cased because if len is 0 then we |
| * never go through the main loop. */ |
| if (unlikely(nargs > 0 && len == 0 && !p_args)) { |
| PyErr_Format(PyExc_TypeError, |
| "%.200s%s takes no positional arguments", |
| (fname == NULL) ? "function" : fname, |
| (fname == NULL) ? "" : "()"); |
| |
| return 0; |
| } |
| |
| *p_kwargs = PyDict_New(); |
| if (!*p_kwargs) { |
| goto latefail; |
| } |
| } |
| |
| if (nkwargs > 0) { |
| PyObject *key, *value; |
| Py_ssize_t j; |
| /* make sure there are no arguments given by name and position */ |
| for (i = pos; i < bound_pos_args && i < len; i++) { |
| current_arg = _PyDict_GetItemStringWithError(kwargs, kwlist[i]); |
| if (unlikely(current_arg != NULL)) { |
| /* arg present in tuple and in dict */ |
| PyErr_Format(PyExc_TypeError, |
| "argument for %.200s%s given by name ('%s') " |
| "and position (%d)", |
| (fname == NULL) ? "function" : fname, |
| (fname == NULL) ? "" : "()", |
| kwlist[i], i+1); |
| goto latefail; |
| } |
| else if (unlikely(PyErr_Occurred() != NULL)) { |
| goto latefail; |
| } |
| } |
| /* make sure there are no extraneous keyword arguments */ |
| j = 0; |
| while (PyDict_Next(kwargs, &j, &key, &value)) { |
| int match = 0; |
| if (unlikely(!PyUnicode_Check(key))) { |
| PyErr_SetString(PyExc_TypeError, |
| "keywords must be strings"); |
| goto latefail; |
| } |
| for (i = pos; i < len; i++) { |
| if (CPyUnicode_EqualToASCIIString(key, kwlist[i])) { |
| match = 1; |
| break; |
| } |
| } |
| if (!match) { |
| if (unlikely(!p_kwargs)) { |
| PyErr_Format(PyExc_TypeError, |
| "'%U' is an invalid keyword " |
| "argument for %.200s%s", |
| key, |
| (fname == NULL) ? "this function" : fname, |
| (fname == NULL) ? "" : "()"); |
| goto latefail; |
| } else { |
| if (PyDict_SetItem(*p_kwargs, key, value) < 0) { |
| goto latefail; |
| } |
| } |
| } |
| } |
| } |
| |
| return 1; |
| /* Handle failures that have happened after we have tried to |
| * create *args and **kwargs, if they exist. */ |
| latefail: |
| if (p_args) { |
| Py_XDECREF(*p_args); |
| } |
| if (p_kwargs) { |
| Py_XDECREF(*p_kwargs); |
| } |
| return 0; |
| } |
| |
| |
| static void |
| skipitem(const char **p_format, va_list *p_va) |
| { |
| const char *format = *p_format; |
| char c = *format++; |
| |
| if (p_va != NULL) { |
| (void) va_arg(*p_va, PyObject **); |
| } |
| |
| *p_format = format; |
| } |
| |
| #ifdef __cplusplus |
| }; |
| #endif |
