Current File : //usr/lib/python3/dist-packages/mypyc/lib-rt/getargs.c
/* 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
Mini Shell