https://github.com/python/cpython/commit/805daa2edb19b78f76291d7a3147a06a5670a112
commit: 805daa2edb19b78f76291d7a3147a06a5670a112
branch: 3.14
author: Serhiy Storchaka <[email protected]>
committer: hugovk <[email protected]>
date: 2025-07-22T19:16:31+03:00
summary:
[3.14] Revert "gh-112068: C API: Add support of nullable arguments in
PyArg_Parse (GH-121303)" (GH-136991) (#137006)
files:
A Misc/NEWS.d/next/C_API/2025-07-22-15-18-08.gh-issue-112068.4WvT-8.rst
M Doc/c-api/arg.rst
M Doc/whatsnew/3.14.rst
M Lib/test/test_capi/test_getargs.py
M Lib/test/test_mmap.py
M Misc/NEWS.d/3.14.0b1.rst
M Modules/_ctypes/_ctypes.c
M Modules/_interpretersmodule.c
M Modules/_json.c
M Modules/_threadmodule.c
M Modules/mmapmodule.c
M Python/getargs.c
diff --git a/Doc/c-api/arg.rst b/Doc/c-api/arg.rst
index ab9f9c4539ae9a..112169635d999a 100644
--- a/Doc/c-api/arg.rst
+++ b/Doc/c-api/arg.rst
@@ -113,18 +113,14 @@ There are three ways strings and buffers can be converted
to C:
``z`` (:class:`str` or ``None``) [const char \*]
Like ``s``, but the Python object may also be ``None``, in which case the C
pointer is set to ``NULL``.
- It is the same as ``s?`` with the C pointer was initialized to ``NULL``.
``z*`` (:class:`str`, :term:`bytes-like object` or ``None``) [Py_buffer]
Like ``s*``, but the Python object may also be ``None``, in which case the
``buf`` member of the :c:type:`Py_buffer` structure is set to ``NULL``.
- It is the same as ``s*?`` with the ``buf`` member of the :c:type:`Py_buffer`
- structure was initialized to ``NULL``.
``z#`` (:class:`str`, read-only :term:`bytes-like object` or ``None``) [const
char \*, :c:type:`Py_ssize_t`]
Like ``s#``, but the Python object may also be ``None``, in which case the C
pointer is set to ``NULL``.
- It is the same as ``s#?`` with the C pointer was initialized to ``NULL``.
``y`` (read-only :term:`bytes-like object`) [const char \*]
This format converts a bytes-like object to a C pointer to a
@@ -387,17 +383,6 @@ Other objects
Non-tuple sequences are deprecated if *items* contains format units
which store a borrowed buffer or a borrowed reference.
-``unit?`` (anything or ``None``) [*matching-variable(s)*]
- ``?`` modifies the behavior of the preceding format unit.
- The C variable(s) corresponding to that parameter should be initialized
- to their default value --- when the argument is ``None``,
- :c:func:`PyArg_ParseTuple` does not touch the contents of the corresponding
- C variable(s).
- If the argument is not ``None``, it is parsed according to the specified
- format unit.
-
- .. versionadded:: 3.14
-
A few other characters have a meaning in a format string. These may not occur
inside nested parentheses. They are:
diff --git a/Doc/whatsnew/3.14.rst b/Doc/whatsnew/3.14.rst
index 2906828e05d229..2517dd93885d7f 100644
--- a/Doc/whatsnew/3.14.rst
+++ b/Doc/whatsnew/3.14.rst
@@ -2940,11 +2940,6 @@ New features
file.
(Contributed by Victor Stinner in :gh:`127350`.)
-* Add support of nullable arguments in :c:func:`PyArg_ParseTuple` and
- similar functions.
- Adding ``?`` after any format unit makes ``None`` be accepted as a value.
- (Contributed by Serhiy Storchaka in :gh:`112068`.)
-
* The ``k`` and ``K`` formats in :c:func:`PyArg_ParseTuple` and
similar functions now use :meth:`~object.__index__` if available,
like all other integer formats.
diff --git a/Lib/test/test_capi/test_getargs.py
b/Lib/test/test_capi/test_getargs.py
index 67a8da7599511f..700870b6266717 100644
--- a/Lib/test/test_capi/test_getargs.py
+++ b/Lib/test/test_capi/test_getargs.py
@@ -1389,123 +1389,6 @@ def test_nested_sequence(self):
"argument 1 must be sequence of length 1, not 0"):
parse(([],), {}, '(' + f + ')', ['a'])
- def test_specific_type_errors(self):
- parse = _testcapi.parse_tuple_and_keywords
-
- def check(format, arg, expected, got='list'):
- errmsg = f'must be {expected}, not {got}'
- with self.assertRaisesRegex(TypeError, errmsg):
- parse((arg,), {}, format, ['a'])
-
- check('k', [], 'int')
- check('k?', [], 'int or None')
- check('K', [], 'int')
- check('K?', [], 'int or None')
- check('c', [], 'a byte string of length 1')
- check('c?', [], 'a byte string of length 1 or None')
- check('c', b'abc', 'a byte string of length 1',
- 'a bytes object of length 3')
- check('c?', b'abc', 'a byte string of length 1 or None',
- 'a bytes object of length 3')
- check('c', bytearray(b'abc'), 'a byte string of length 1',
- 'a bytearray object of length 3')
- check('c?', bytearray(b'abc'), 'a byte string of length 1 or None',
- 'a bytearray object of length 3')
- check('C', [], 'a unicode character')
- check('C?', [], 'a unicode character or None')
- check('C', 'abc', 'a unicode character',
- 'a string of length 3')
- check('C?', 'abc', 'a unicode character or None',
- 'a string of length 3')
- check('s', [], 'str')
- check('s?', [], 'str or None')
- check('z', [], 'str or None')
- check('z?', [], 'str or None')
- check('es', [], 'str')
- check('es?', [], 'str or None')
- check('es#', [], 'str')
- check('es#?', [], 'str or None')
- check('et', [], 'str, bytes or bytearray')
- check('et?', [], 'str, bytes, bytearray or None')
- check('et#', [], 'str, bytes or bytearray')
- check('et#?', [], 'str, bytes, bytearray or None')
- check('w*', [], 'read-write bytes-like object')
- check('w*?', [], 'read-write bytes-like object or None')
- check('S', [], 'bytes')
- check('S?', [], 'bytes or None')
- check('U', [], 'str')
- check('U?', [], 'str or None')
- check('Y', [], 'bytearray')
- check('Y?', [], 'bytearray or None')
- check('(OO)', 42, '2-item tuple', 'int')
- check('(OO)?', 42, '2-item tuple or None', 'int')
- check('(OO)', (1, 2, 3), 'tuple of length 2', '3')
-
- def test_nullable(self):
- parse = _testcapi.parse_tuple_and_keywords
-
- def check(format, arg, allows_none=False):
- # Because some format units (such as y*) require cleanup,
- # we force the parsing code to perform the cleanup by adding
- # an argument that always fails.
- # By checking for an exception, we ensure that the parsing
- # of the first argument was successful.
- self.assertRaises(OverflowError, parse,
- (arg, 256), {}, format + '?b', ['a', 'b'])
- self.assertRaises(OverflowError, parse,
- (None, 256), {}, format + '?b', ['a', 'b'])
- self.assertRaises(OverflowError, parse,
- (arg, 256), {}, format + 'b', ['a', 'b'])
- self.assertRaises(OverflowError if allows_none else TypeError,
parse,
- (None, 256), {}, format + 'b', ['a', 'b'])
-
- check('b', 42)
- check('B', 42)
- check('h', 42)
- check('H', 42)
- check('i', 42)
- check('I', 42)
- check('n', 42)
- check('l', 42)
- check('k', 42)
- check('L', 42)
- check('K', 42)
- check('f', 2.5)
- check('d', 2.5)
- check('D', 2.5j)
- check('c', b'a')
- check('C', 'a')
- check('p', True, allows_none=True)
- check('y', b'buffer')
- check('y*', b'buffer')
- check('y#', b'buffer')
- check('s', 'string')
- check('s*', 'string')
- check('s#', 'string')
- check('z', 'string', allows_none=True)
- check('z*', 'string', allows_none=True)
- check('z#', 'string', allows_none=True)
- check('w*', bytearray(b'buffer'))
- check('U', 'string')
- check('S', b'bytes')
- check('Y', bytearray(b'bytearray'))
- check('O', object, allows_none=True)
-
- check('(OO)', (1, 2))
- self.assertEqual(parse((((1, 2), 3),), {}, '((OO)?O)', ['a']), (1, 2,
3))
- self.assertEqual(parse(((None, 3),), {}, '((OO)?O)', ['a']), (NULL,
NULL, 3))
- self.assertEqual(parse((((1, 2), 3),), {}, '((OO)O)', ['a']), (1, 2,
3))
- self.assertRaises(TypeError, parse, ((None, 3),), {}, '((OO)O)', ['a'])
-
- parse((None,), {}, 'es?', ['a'])
- parse((None,), {}, 'es#?', ['a'])
- parse((None,), {}, 'et?', ['a'])
- parse((None,), {}, 'et#?', ['a'])
- parse((None,), {}, 'O!?', ['a'])
- parse((None,), {}, 'O&?', ['a'])
-
- # TODO: More tests for es?, es#?, et?, et#?, O!, O&
-
@unittest.skipIf(_testinternalcapi is None, 'needs _testinternalcapi')
def test_gh_119213(self):
rc, out, err = script_helper.assert_python_ok("-c", """if True:
diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py
index fd4197b7086976..b2a299ed172967 100644
--- a/Lib/test/test_mmap.py
+++ b/Lib/test/test_mmap.py
@@ -732,7 +732,7 @@ def test_tagname(self):
m2.close()
m1.close()
- with self.assertRaisesRegex(TypeError, 'must be str or None'):
+ with self.assertRaisesRegex(TypeError, 'tagname'):
mmap.mmap(-1, 8, tagname=1)
@cpython_only
diff --git a/Misc/NEWS.d/3.14.0b1.rst b/Misc/NEWS.d/3.14.0b1.rst
index f76896954f321d..f2dd631358550b 100644
--- a/Misc/NEWS.d/3.14.0b1.rst
+++ b/Misc/NEWS.d/3.14.0b1.rst
@@ -2012,7 +2012,7 @@ interpreter.
.. nonce: ofI5Fl
.. section: C API
-Add support of nullable arguments in :c:func:`PyArg_Parse` and similar
+[Reverted in :gh:`136991`] Add support of nullable arguments in
:c:func:`PyArg_Parse` and similar
functions. Adding ``?`` after any format unit makes ``None`` be accepted as
a value.
diff --git
a/Misc/NEWS.d/next/C_API/2025-07-22-15-18-08.gh-issue-112068.4WvT-8.rst
b/Misc/NEWS.d/next/C_API/2025-07-22-15-18-08.gh-issue-112068.4WvT-8.rst
new file mode 100644
index 00000000000000..018c5c7880c001
--- /dev/null
+++ b/Misc/NEWS.d/next/C_API/2025-07-22-15-18-08.gh-issue-112068.4WvT-8.rst
@@ -0,0 +1 @@
+Revert support of nullable arguments in :c:func:`PyArg_Parse`.
diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
index 55a446d02b27f3..08e00adfd0c3e6 100644
--- a/Modules/_ctypes/_ctypes.c
+++ b/Modules/_ctypes/_ctypes.c
@@ -3918,7 +3918,9 @@ _validate_paramflags(ctypes_state *st, PyTypeObject
*type, PyObject *paramflags)
PyObject *name = Py_None;
PyObject *defval;
PyObject *typ;
- if (!PyArg_ParseTuple(item, "i|U?O", &flag, &name, &defval)) {
+ if (!PyArg_ParseTuple(item, "i|OO", &flag, &name, &defval) ||
+ !(name == Py_None || PyUnicode_Check(name)))
+ {
PyErr_SetString(PyExc_TypeError,
"paramflags must be a sequence of (int [,string [,value]])
tuples");
return 0;
@@ -3983,8 +3985,10 @@ PyCFuncPtr_FromDll(PyTypeObject *type, PyObject *args,
PyObject *kwds)
void *handle;
PyObject *paramflags = NULL;
- if (!PyArg_ParseTuple(args, "O|O?", &ftuple, ¶mflags))
+ if (!PyArg_ParseTuple(args, "O|O", &ftuple, ¶mflags))
return NULL;
+ if (paramflags == Py_None)
+ paramflags = NULL;
ftuple = PySequence_Tuple(ftuple);
if (!ftuple)
@@ -4116,8 +4120,10 @@ PyCFuncPtr_FromVtblIndex(PyTypeObject *type, PyObject
*args, PyObject *kwds)
GUID *iid = NULL;
Py_ssize_t iid_len = 0;
- if (!PyArg_ParseTuple(args, "is|O?z#", &index, &name, ¶mflags, &iid,
&iid_len))
+ if (!PyArg_ParseTuple(args, "is|Oz#", &index, &name, ¶mflags, &iid,
&iid_len))
return NULL;
+ if (paramflags == Py_None)
+ paramflags = NULL;
ctypes_state *st = get_module_state_by_def(Py_TYPE(type));
if (!_validate_paramflags(st, type, paramflags)) {
diff --git a/Modules/_interpretersmodule.c b/Modules/_interpretersmodule.c
index 9426ce72733c28..faf3b25b68c4eb 100644
--- a/Modules/_interpretersmodule.c
+++ b/Modules/_interpretersmodule.c
@@ -1415,11 +1415,14 @@ interp_get_config(PyObject *self, PyObject *args,
PyObject *kwds)
PyObject *idobj = NULL;
int restricted = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwds,
- "O?|$p:get_config", kwlist,
+ "O|$p:get_config", kwlist,
&idobj, &restricted))
{
return NULL;
}
+ if (idobj == Py_None) {
+ idobj = NULL;
+ }
int reqready = 0;
PyInterpreterState *interp = \
@@ -1536,14 +1539,14 @@ capture_exception(PyObject *self, PyObject *args,
PyObject *kwds)
static char *kwlist[] = {"exc", NULL};
PyObject *exc_arg = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kwds,
- "|O?:capture_exception", kwlist,
+ "|O:capture_exception", kwlist,
&exc_arg))
{
return NULL;
}
PyObject *exc = exc_arg;
- if (exc == NULL) {
+ if (exc == NULL || exc == Py_None) {
exc = PyErr_GetRaisedException();
if (exc == NULL) {
Py_RETURN_NONE;
diff --git a/Modules/_json.c b/Modules/_json.c
index 6c381fab449db2..2f82a69a1579dc 100644
--- a/Modules/_json.c
+++ b/Modules/_json.c
@@ -1228,16 +1228,23 @@ encoder_new(PyTypeObject *type, PyObject *args,
PyObject *kwds)
static char *kwlist[] = {"markers", "default", "encoder", "indent",
"key_separator", "item_separator", "sort_keys", "skipkeys", "allow_nan", NULL};
PyEncoderObject *s;
- PyObject *markers = Py_None, *defaultfn, *encoder, *indent, *key_separator;
+ PyObject *markers, *defaultfn, *encoder, *indent, *key_separator;
PyObject *item_separator;
int sort_keys, skipkeys, allow_nan;
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!?OOOUUppp:make_encoder",
kwlist,
- &PyDict_Type, &markers, &defaultfn, &encoder, &indent,
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOOOUUppp:make_encoder",
kwlist,
+ &markers, &defaultfn, &encoder, &indent,
&key_separator, &item_separator,
&sort_keys, &skipkeys, &allow_nan))
return NULL;
+ if (markers != Py_None && !PyDict_Check(markers)) {
+ PyErr_Format(PyExc_TypeError,
+ "make_encoder() argument 1 must be dict or None, "
+ "not %.200s", Py_TYPE(markers)->tp_name);
+ return NULL;
+ }
+
s = (PyEncoderObject *)type->tp_alloc(type, 0);
if (s == NULL)
return NULL;
diff --git a/Modules/_threadmodule.c b/Modules/_threadmodule.c
index 121b0f803715af..775cd704cda4ed 100644
--- a/Modules/_threadmodule.c
+++ b/Modules/_threadmodule.c
@@ -667,12 +667,12 @@ PyThreadHandleObject_join(PyObject *op, PyObject *args)
PyThreadHandleObject *self = PyThreadHandleObject_CAST(op);
PyObject *timeout_obj = NULL;
- if (!PyArg_ParseTuple(args, "|O?:join", &timeout_obj)) {
+ if (!PyArg_ParseTuple(args, "|O:join", &timeout_obj)) {
return NULL;
}
PyTime_t timeout_ns = -1;
- if (timeout_obj != NULL) {
+ if (timeout_obj != NULL && timeout_obj != Py_None) {
if (_PyTime_FromSecondsObject(&timeout_ns, timeout_obj,
_PyTime_ROUND_TIMEOUT) < 0) {
return NULL;
@@ -1945,10 +1945,10 @@ thread_PyThread_start_joinable_thread(PyObject *module,
PyObject *fargs,
PyObject *func = NULL;
int daemon = 1;
thread_module_state *state = get_thread_state(module);
- PyObject *hobj = Py_None;
+ PyObject *hobj = NULL;
if (!PyArg_ParseTupleAndKeywords(fargs, fkwargs,
- "O|O!?p:start_joinable_thread", keywords,
- &func, state->thread_handle_type, &hobj,
&daemon)) {
+ "O|Op:start_joinable_thread", keywords,
+ &func, &hobj, &daemon)) {
return NULL;
}
@@ -1958,6 +1958,14 @@ thread_PyThread_start_joinable_thread(PyObject *module,
PyObject *fargs,
return NULL;
}
+ if (hobj == NULL) {
+ hobj = Py_None;
+ }
+ else if (hobj != Py_None && !Py_IS_TYPE(hobj, state->thread_handle_type)) {
+ PyErr_SetString(PyExc_TypeError, "'handle' must be a _ThreadHandle");
+ return NULL;
+ }
+
if (PySys_Audit("_thread.start_joinable_thread", "OiO", func, daemon,
hobj) < 0) {
return NULL;
diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c
index d9e8c60209dae3..e2ae967ce0c33d 100644
--- a/Modules/mmapmodule.c
+++ b/Modules/mmapmodule.c
@@ -23,6 +23,7 @@
#endif
#include <Python.h>
+#include "pycore_abstract.h" // _Py_convert_optional_to_ssize_t()
#include "pycore_bytesobject.h" // _PyBytes_Find()
#include "pycore_fileutils.h" // _Py_stat_struct
#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS()
@@ -515,7 +516,7 @@ mmap_read_method(PyObject *op, PyObject *args)
mmap_object *self = mmap_object_CAST(op);
CHECK_VALID(NULL);
- if (!PyArg_ParseTuple(args, "|n?:read", &num_bytes))
+ if (!PyArg_ParseTuple(args, "|O&:read", _Py_convert_optional_to_ssize_t,
&num_bytes))
return NULL;
CHECK_VALID(NULL);
@@ -1709,7 +1710,7 @@ new_mmap_object(PyTypeObject *type, PyObject *args,
PyObject *kwdict)
DWORD off_lo; /* lower 32 bits of offset */
DWORD size_hi; /* upper 32 bits of size */
DWORD size_lo; /* lower 32 bits of size */
- PyObject *tagname = NULL;
+ PyObject *tagname = Py_None;
DWORD dwErr = 0;
int fileno;
HANDLE fh = 0;
@@ -1719,7 +1720,7 @@ new_mmap_object(PyTypeObject *type, PyObject *args,
PyObject *kwdict)
"tagname",
"access", "offset", NULL };
- if (!PyArg_ParseTupleAndKeywords(args, kwdict, "in|U?iL", keywords,
+ if (!PyArg_ParseTupleAndKeywords(args, kwdict, "in|OiL", keywords,
&fileno, &map_size,
&tagname, &access, &offset)) {
return NULL;
@@ -1852,7 +1853,13 @@ new_mmap_object(PyTypeObject *type, PyObject *args,
PyObject *kwdict)
m_obj->weakreflist = NULL;
m_obj->exports = 0;
/* set the tag name */
- if (tagname != NULL) {
+ if (!Py_IsNone(tagname)) {
+ if (!PyUnicode_Check(tagname)) {
+ Py_DECREF(m_obj);
+ return PyErr_Format(PyExc_TypeError, "expected str or None for "
+ "'tagname', not %.200s",
+ Py_TYPE(tagname)->tp_name);
+ }
m_obj->tagname = PyUnicode_AsWideCharString(tagname, NULL);
if (m_obj->tagname == NULL) {
Py_DECREF(m_obj);
diff --git a/Python/getargs.c b/Python/getargs.c
index 0cf596285cc7b5..9d3dea0cb4364b 100644
--- a/Python/getargs.c
+++ b/Python/getargs.c
@@ -1,8 +1,6 @@
/* New getargs implementation */
-#include <stdbool.h>
-
#define PY_CXX_CONST const
#include "Python.h"
#include "pycore_abstract.h" // _PyNumber_Index()
@@ -468,12 +466,9 @@ converttuple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
const char *format = *p_format;
int i;
Py_ssize_t len;
- bool nullable = false;
int istuple = PyTuple_Check(arg);
int mustbetuple = istuple;
- assert(*format == '(');
- format++;
for (;;) {
int c = *format++;
if (c == '(') {
@@ -482,12 +477,8 @@ converttuple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
level++;
}
else if (c == ')') {
- if (level == 0) {
- if (*format == '?') {
- nullable = true;
- }
+ if (level == 0)
break;
- }
level--;
}
else if (c == ':' || c == ';' || c == '\0')
@@ -524,13 +515,6 @@ converttuple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
}
}
- if (arg == Py_None && nullable) {
- const char *msg = skipitem(p_format, p_va, flags);
- if (msg != NULL) {
- levels[0] = 0;
- }
- return msg;
- }
if (istuple) {
/* fallthrough */
}
@@ -539,10 +523,9 @@ converttuple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
{
levels[0] = 0;
PyOS_snprintf(msgbuf, bufsize,
- "must be %d-item tuple%s, not %.50s",
- n,
- nullable ? " or None" : "",
- arg == Py_None ? "None" : Py_TYPE(arg)->tp_name);
+ "must be %d-item tuple, not %.50s",
+ n,
+ arg == Py_None ? "None" : Py_TYPE(arg)->tp_name);
return msgbuf;
}
else {
@@ -579,7 +562,7 @@ converttuple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
return msgbuf;
}
- format = *p_format + 1;
+ format = *p_format;
for (i = 0; i < n; i++) {
const char *msg;
PyObject *item = PyTuple_GET_ITEM(arg, i);
@@ -594,10 +577,6 @@ converttuple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
}
}
- format++;
- if (*format == '?') {
- format++;
- }
*p_format = format;
if (!istuple) {
Py_DECREF(arg);
@@ -616,8 +595,11 @@ convertitem(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
const char *format = *p_format;
if (*format == '(' /* ')' */) {
+ format++;
msg = converttuple(arg, &format, p_va, flags, levels, msgbuf,
bufsize, freelist);
+ if (msg == NULL)
+ format++;
}
else {
msg = convertsimple(arg, &format, p_va, flags,
@@ -647,7 +629,7 @@ _PyArg_BadArgument(const char *fname, const char
*displayname,
}
static const char *
-converterr(bool nullable, const char *expected, PyObject *arg, char *msgbuf,
size_t bufsize)
+converterr(const char *expected, PyObject *arg, char *msgbuf, size_t bufsize)
{
assert(expected != NULL);
assert(arg != NULL);
@@ -657,23 +639,20 @@ converterr(bool nullable, const char *expected, PyObject
*arg, char *msgbuf, siz
}
else {
PyOS_snprintf(msgbuf, bufsize,
- "must be %.50s%s, not %.50s", expected,
- nullable ? " or None" : "",
+ "must be %.50s, not %.50s", expected,
arg == Py_None ? "None" : Py_TYPE(arg)->tp_name);
}
return msgbuf;
}
static const char *
-convertcharerr(bool nullable, const char *expected, const char *what,
Py_ssize_t size,
+convertcharerr(const char *expected, const char *what, Py_ssize_t size,
char *msgbuf, size_t bufsize)
{
assert(expected != NULL);
PyOS_snprintf(msgbuf, bufsize,
- "must be %.50s%s, not %.50s of length %zd",
- expected,
- nullable ? " or None" : "",
- what, size);
+ "must be %.50s, not %.50s of length %zd",
+ expected, what, size);
return msgbuf;
}
@@ -693,26 +672,15 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
char *msgbuf, size_t bufsize, freelist_t *freelist)
{
#define RETURN_ERR_OCCURRED return msgbuf
-#define HANDLE_NULLABLE \
- if (*format == '?') { \
- format++; \
- if (arg == Py_None) { \
- break; \
- } \
- nullable = true; \
- }
-
const char *format = *p_format;
char c = *format++;
const char *sarg;
- bool nullable = false;
switch (c) {
case 'b': { /* unsigned byte -- very short int */
unsigned char *p = va_arg(*p_va, unsigned char *);
- HANDLE_NULLABLE;
long ival = PyLong_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
RETURN_ERR_OCCURRED;
@@ -726,6 +694,7 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
"unsigned byte integer is greater than maximum");
RETURN_ERR_OCCURRED;
}
+ else
*p = (unsigned char) ival;
break;
}
@@ -733,7 +702,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
case 'B': {/* byte sized bitfield - both signed and unsigned
values allowed */
unsigned char *p = va_arg(*p_va, unsigned char *);
- HANDLE_NULLABLE;
unsigned long ival = PyLong_AsUnsignedLongMask(arg);
if (ival == (unsigned long)-1 && PyErr_Occurred())
RETURN_ERR_OCCURRED;
@@ -744,7 +712,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
case 'h': {/* signed short int */
short *p = va_arg(*p_va, short *);
- HANDLE_NULLABLE;
long ival = PyLong_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
RETURN_ERR_OCCURRED;
@@ -766,7 +733,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
case 'H': { /* short int sized bitfield, both signed and
unsigned allowed */
unsigned short *p = va_arg(*p_va, unsigned short *);
- HANDLE_NULLABLE;
unsigned long ival = PyLong_AsUnsignedLongMask(arg);
if (ival == (unsigned long)-1 && PyErr_Occurred())
RETURN_ERR_OCCURRED;
@@ -777,7 +743,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
case 'i': {/* signed int */
int *p = va_arg(*p_va, int *);
- HANDLE_NULLABLE;
long ival = PyLong_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
RETURN_ERR_OCCURRED;
@@ -799,7 +764,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
case 'I': { /* int sized bitfield, both signed and
unsigned allowed */
unsigned int *p = va_arg(*p_va, unsigned int *);
- HANDLE_NULLABLE;
unsigned long ival = PyLong_AsUnsignedLongMask(arg);
if (ival == (unsigned long)-1 && PyErr_Occurred())
RETURN_ERR_OCCURRED;
@@ -812,7 +776,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
{
PyObject *iobj;
Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *);
- HANDLE_NULLABLE;
Py_ssize_t ival = -1;
iobj = _PyNumber_Index(arg);
if (iobj != NULL) {
@@ -826,7 +789,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
}
case 'l': {/* long int */
long *p = va_arg(*p_va, long *);
- HANDLE_NULLABLE;
long ival = PyLong_AsLong(arg);
if (ival == -1 && PyErr_Occurred())
RETURN_ERR_OCCURRED;
@@ -837,10 +799,9 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
case 'k': { /* long sized bitfield */
unsigned long *p = va_arg(*p_va, unsigned long *);
- HANDLE_NULLABLE;
unsigned long ival;
if (!PyIndex_Check(arg)) {
- return converterr(nullable, "int", arg, msgbuf, bufsize);
+ return converterr("int", arg, msgbuf, bufsize);
}
ival = PyLong_AsUnsignedLongMask(arg);
if (ival == (unsigned long)(long)-1 && PyErr_Occurred()) {
@@ -852,7 +813,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
case 'L': {/* long long */
long long *p = va_arg( *p_va, long long * );
- HANDLE_NULLABLE;
long long ival = PyLong_AsLongLong(arg);
if (ival == (long long)-1 && PyErr_Occurred())
RETURN_ERR_OCCURRED;
@@ -863,10 +823,9 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
case 'K': { /* long long sized bitfield */
unsigned long long *p = va_arg(*p_va, unsigned long long *);
- HANDLE_NULLABLE;
unsigned long long ival;
if (!PyIndex_Check(arg)) {
- return converterr(nullable, "int", arg, msgbuf, bufsize);
+ return converterr("int", arg, msgbuf, bufsize);
}
ival = PyLong_AsUnsignedLongLongMask(arg);
if (ival == (unsigned long long)(long long)-1 && PyErr_Occurred()) {
@@ -878,7 +837,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
case 'f': {/* float */
float *p = va_arg(*p_va, float *);
- HANDLE_NULLABLE;
double dval = PyFloat_AsDouble(arg);
if (dval == -1.0 && PyErr_Occurred())
RETURN_ERR_OCCURRED;
@@ -889,7 +847,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
case 'd': {/* double */
double *p = va_arg(*p_va, double *);
- HANDLE_NULLABLE;
double dval = PyFloat_AsDouble(arg);
if (dval == -1.0 && PyErr_Occurred())
RETURN_ERR_OCCURRED;
@@ -900,7 +857,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
case 'D': {/* complex double */
Py_complex *p = va_arg(*p_va, Py_complex *);
- HANDLE_NULLABLE;
Py_complex cval;
cval = PyComplex_AsCComplex(arg);
if (PyErr_Occurred())
@@ -912,10 +868,9 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
case 'c': {/* char */
char *p = va_arg(*p_va, char *);
- HANDLE_NULLABLE;
if (PyBytes_Check(arg)) {
if (PyBytes_GET_SIZE(arg) != 1) {
- return convertcharerr(nullable, "a byte string of length 1",
+ return convertcharerr("a byte string of length 1",
"a bytes object", PyBytes_GET_SIZE(arg),
msgbuf, bufsize);
}
@@ -923,28 +878,27 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
}
else if (PyByteArray_Check(arg)) {
if (PyByteArray_GET_SIZE(arg) != 1) {
- return convertcharerr(nullable, "a byte string of length 1",
+ return convertcharerr("a byte string of length 1",
"a bytearray object",
PyByteArray_GET_SIZE(arg),
msgbuf, bufsize);
}
*p = PyByteArray_AS_STRING(arg)[0];
}
else
- return converterr(nullable, "a byte string of length 1", arg,
msgbuf, bufsize);
+ return converterr("a byte string of length 1", arg, msgbuf,
bufsize);
break;
}
case 'C': {/* unicode char */
int *p = va_arg(*p_va, int *);
- HANDLE_NULLABLE;
int kind;
const void *data;
if (!PyUnicode_Check(arg))
- return converterr(nullable, "a unicode character", arg, msgbuf,
bufsize);
+ return converterr("a unicode character", arg, msgbuf, bufsize);
if (PyUnicode_GET_LENGTH(arg) != 1) {
- return convertcharerr(nullable, "a unicode character",
+ return convertcharerr("a unicode character",
"a string", PyUnicode_GET_LENGTH(arg),
msgbuf, bufsize);
}
@@ -957,7 +911,6 @@ convertsimple(PyObject *arg, const char **p_format, va_list
*p_va, int flags,
case 'p': {/* boolean *p*redicate */
int *p = va_arg(*p_va, int *);
- HANDLE_NULLABLE;
int val = PyObject_IsTrue(arg);
if (val > 0)
*p = 1;
@@ -976,31 +929,24 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
const char *buf;
Py_ssize_t count;
if (*format == '*') {
- format++;
- HANDLE_NULLABLE;
if (getbuffer(arg, (Py_buffer*)p, &buf) < 0)
- return converterr(nullable, buf, arg, msgbuf, bufsize);
+ return converterr(buf, arg, msgbuf, bufsize);
+ format++;
if (addcleanup(p, freelist, cleanup_buffer)) {
return converterr(
- nullable, "(cleanup problem)",
+ "(cleanup problem)",
arg, msgbuf, bufsize);
}
break;
}
- else if (*format == '#') {
+ count = convertbuffer(arg, (const void **)p, &buf);
+ if (count < 0)
+ return converterr(buf, arg, msgbuf, bufsize);
+ if (*format == '#') {
Py_ssize_t *psize = va_arg(*p_va, Py_ssize_t*);
- format++;
- HANDLE_NULLABLE;
- count = convertbuffer(arg, (const void **)p, &buf);
- if (count < 0)
- return converterr(nullable, buf, arg, msgbuf, bufsize);
*psize = count;
- }
- else {
- HANDLE_NULLABLE;
- count = convertbuffer(arg, (const void **)p, &buf);
- if (count < 0)
- return converterr(nullable, buf, arg, msgbuf, bufsize);
+ format++;
+ } else {
if (strlen(*p) != (size_t)count) {
PyErr_SetString(PyExc_ValueError, "embedded null byte");
RETURN_ERR_OCCURRED;
@@ -1016,35 +962,32 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
/* "s*" or "z*" */
Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
- format++;
- HANDLE_NULLABLE;
if (c == 'z' && arg == Py_None)
PyBuffer_FillInfo(p, NULL, NULL, 0, 1, 0);
else if (PyUnicode_Check(arg)) {
Py_ssize_t len;
sarg = PyUnicode_AsUTF8AndSize(arg, &len);
if (sarg == NULL)
- return converterr(nullable, CONV_UNICODE,
+ return converterr(CONV_UNICODE,
arg, msgbuf, bufsize);
PyBuffer_FillInfo(p, arg, (void *)sarg, len, 1, 0);
}
else { /* any bytes-like object */
const char *buf;
if (getbuffer(arg, p, &buf) < 0)
- return converterr(nullable, buf, arg, msgbuf, bufsize);
+ return converterr(buf, arg, msgbuf, bufsize);
}
if (addcleanup(p, freelist, cleanup_buffer)) {
return converterr(
- nullable, "(cleanup problem)",
+ "(cleanup problem)",
arg, msgbuf, bufsize);
}
+ format++;
} else if (*format == '#') { /* a string or read-only bytes-like
object */
/* "s#" or "z#" */
const void **p = (const void **)va_arg(*p_va, const char **);
Py_ssize_t *psize = va_arg(*p_va, Py_ssize_t*);
- format++;
- HANDLE_NULLABLE;
if (c == 'z' && arg == Py_None) {
*p = NULL;
*psize = 0;
@@ -1053,7 +996,7 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
Py_ssize_t len;
sarg = PyUnicode_AsUTF8AndSize(arg, &len);
if (sarg == NULL)
- return converterr(nullable, CONV_UNICODE,
+ return converterr(CONV_UNICODE,
arg, msgbuf, bufsize);
*p = sarg;
*psize = len;
@@ -1063,22 +1006,22 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
const char *buf;
Py_ssize_t count = convertbuffer(arg, p, &buf);
if (count < 0)
- return converterr(nullable, buf, arg, msgbuf, bufsize);
+ return converterr(buf, arg, msgbuf, bufsize);
*psize = count;
}
+ format++;
} else {
/* "s" or "z" */
const char **p = va_arg(*p_va, const char **);
Py_ssize_t len;
sarg = NULL;
- HANDLE_NULLABLE;
if (c == 'z' && arg == Py_None)
*p = NULL;
else if (PyUnicode_Check(arg)) {
sarg = PyUnicode_AsUTF8AndSize(arg, &len);
if (sarg == NULL)
- return converterr(nullable, CONV_UNICODE,
+ return converterr(CONV_UNICODE,
arg, msgbuf, bufsize);
if (strlen(sarg) != (size_t)len) {
PyErr_SetString(PyExc_ValueError, "embedded null
character");
@@ -1087,7 +1030,7 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
*p = sarg;
}
else
- return converterr(c == 'z' || nullable, "str",
+ return converterr(c == 'z' ? "str or None" : "str",
arg, msgbuf, bufsize);
}
break;
@@ -1116,46 +1059,13 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
recode_strings = 0;
else
return converterr(
- nullable, "(unknown parser marker combination)",
+ "(unknown parser marker combination)",
arg, msgbuf, bufsize);
buffer = (char **)va_arg(*p_va, char **);
format++;
if (buffer == NULL)
- return converterr(nullable, "(buffer is NULL)",
+ return converterr("(buffer is NULL)",
arg, msgbuf, bufsize);
- Py_ssize_t *psize = NULL;
- if (*format == '#') {
- /* Using buffer length parameter '#':
-
- - if *buffer is NULL, a new buffer of the
- needed size is allocated and the data
- copied into it; *buffer is updated to point
- to the new buffer; the caller is
- responsible for PyMem_Free()ing it after
- usage
-
- - if *buffer is not NULL, the data is
- copied to *buffer; *buffer_len has to be
- set to the size of the buffer on input;
- buffer overflow is signalled with an error;
- buffer has to provide enough room for the
- encoded string plus the trailing 0-byte
-
- - in both cases, *buffer_len is updated to
- the size of the buffer /excluding/ the
- trailing 0-byte
-
- */
- psize = va_arg(*p_va, Py_ssize_t*);
-
- format++;
- if (psize == NULL) {
- return converterr(
- nullable, "(buffer_len is NULL)",
- arg, msgbuf, bufsize);
- }
- }
- HANDLE_NULLABLE;
/* Encode object */
if (!recode_strings &&
@@ -1176,7 +1086,7 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
encoding,
NULL);
if (s == NULL)
- return converterr(nullable, "(encoding failed)",
+ return converterr("(encoding failed)",
arg, msgbuf, bufsize);
assert(PyBytes_Check(s));
size = PyBytes_GET_SIZE(s);
@@ -1186,15 +1096,42 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
}
else {
return converterr(
- nullable,
- recode_strings ? "str"
- : nullable ? "str, bytes, bytearray"
- : "str, bytes or bytearray",
+ recode_strings ? "str" : "str, bytes or bytearray",
arg, msgbuf, bufsize);
}
/* Write output; output is guaranteed to be 0-terminated */
- if (psize != NULL) {
+ if (*format == '#') {
+ /* Using buffer length parameter '#':
+
+ - if *buffer is NULL, a new buffer of the
+ needed size is allocated and the data
+ copied into it; *buffer is updated to point
+ to the new buffer; the caller is
+ responsible for PyMem_Free()ing it after
+ usage
+
+ - if *buffer is not NULL, the data is
+ copied to *buffer; *buffer_len has to be
+ set to the size of the buffer on input;
+ buffer overflow is signalled with an error;
+ buffer has to provide enough room for the
+ encoded string plus the trailing 0-byte
+
+ - in both cases, *buffer_len is updated to
+ the size of the buffer /excluding/ the
+ trailing 0-byte
+
+ */
+ Py_ssize_t *psize = va_arg(*p_va, Py_ssize_t*);
+
+ format++;
+ if (psize == NULL) {
+ Py_DECREF(s);
+ return converterr(
+ "(buffer_len is NULL)",
+ arg, msgbuf, bufsize);
+ }
if (*buffer == NULL) {
*buffer = PyMem_NEW(char, size + 1);
if (*buffer == NULL) {
@@ -1205,7 +1142,7 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
if (addcleanup(buffer, freelist, cleanup_ptr)) {
Py_DECREF(s);
return converterr(
- nullable, "(cleanup problem)",
+ "(cleanup problem)",
arg, msgbuf, bufsize);
}
} else {
@@ -1239,7 +1176,7 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
if ((Py_ssize_t)strlen(ptr) != size) {
Py_DECREF(s);
return converterr(
- nullable, "encoded string without null bytes",
+ "encoded string without null bytes",
arg, msgbuf, bufsize);
}
*buffer = PyMem_NEW(char, size + 1);
@@ -1250,7 +1187,7 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
}
if (addcleanup(buffer, freelist, cleanup_ptr)) {
Py_DECREF(s);
- return converterr(nullable, "(cleanup problem)",
+ return converterr("(cleanup problem)",
arg, msgbuf, bufsize);
}
memcpy(*buffer, ptr, size+1);
@@ -1261,32 +1198,29 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
case 'S': { /* PyBytes object */
PyObject **p = va_arg(*p_va, PyObject **);
- HANDLE_NULLABLE;
if (PyBytes_Check(arg))
*p = arg;
else
- return converterr(nullable, "bytes", arg, msgbuf, bufsize);
+ return converterr("bytes", arg, msgbuf, bufsize);
break;
}
case 'Y': { /* PyByteArray object */
PyObject **p = va_arg(*p_va, PyObject **);
- HANDLE_NULLABLE;
if (PyByteArray_Check(arg))
*p = arg;
else
- return converterr(nullable, "bytearray", arg, msgbuf, bufsize);
+ return converterr("bytearray", arg, msgbuf, bufsize);
break;
}
case 'U': { /* PyUnicode object */
PyObject **p = va_arg(*p_va, PyObject **);
- HANDLE_NULLABLE;
if (PyUnicode_Check(arg)) {
*p = arg;
}
else
- return converterr(nullable, "str", arg, msgbuf, bufsize);
+ return converterr("str", arg, msgbuf, bufsize);
break;
}
@@ -1297,11 +1231,10 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
type = va_arg(*p_va, PyTypeObject*);
p = va_arg(*p_va, PyObject **);
format++;
- HANDLE_NULLABLE;
if (PyType_IsSubtype(Py_TYPE(arg), type))
*p = arg;
else
- return converterr(nullable, type->tp_name, arg, msgbuf,
bufsize);
+ return converterr(type->tp_name, arg, msgbuf, bufsize);
}
else if (*format == '&') {
@@ -1310,18 +1243,16 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
void *addr = va_arg(*p_va, void *);
int res;
format++;
- HANDLE_NULLABLE;
if (! (res = (*convert)(arg, addr)))
- return converterr(nullable, "(unspecified)",
+ return converterr("(unspecified)",
arg, msgbuf, bufsize);
if (res == Py_CLEANUP_SUPPORTED &&
addcleanup(addr, freelist, convert) == -1)
- return converterr(nullable, "(cleanup problem)",
+ return converterr("(cleanup problem)",
arg, msgbuf, bufsize);
}
else {
p = va_arg(*p_va, PyObject **);
- HANDLE_NULLABLE;
*p = arg;
}
break;
@@ -1333,30 +1264,29 @@ convertsimple(PyObject *arg, const char **p_format,
va_list *p_va, int flags,
if (*format != '*')
return converterr(
- nullable, "(invalid use of 'w' format character)",
+ "(invalid use of 'w' format character)",
arg, msgbuf, bufsize);
format++;
- HANDLE_NULLABLE;
/* Caller is interested in Py_buffer, and the object supports it
directly. The request implicitly asks for PyBUF_SIMPLE, so the
result is C-contiguous with format 'B'. */
if (PyObject_GetBuffer(arg, (Py_buffer*)p, PyBUF_WRITABLE) < 0) {
PyErr_Clear();
- return converterr(nullable, "read-write bytes-like object",
+ return converterr("read-write bytes-like object",
arg, msgbuf, bufsize);
}
assert(PyBuffer_IsContiguous((Py_buffer *)p, 'C'));
if (addcleanup(p, freelist, cleanup_buffer)) {
return converterr(
- nullable, "(cleanup problem)",
+ "(cleanup problem)",
arg, msgbuf, bufsize);
}
break;
}
default:
- return converterr(nullable, "(impossible<bad format char>)", arg,
msgbuf, bufsize);
+ return converterr("(impossible<bad format char>)", arg, msgbuf,
bufsize);
}
@@ -2751,9 +2681,6 @@ skipitem(const char **p_format, va_list *p_va, int flags)
return "impossible<bad format char>";
}
- if (*format == '?') {
- format++;
- }
*p_format = format;
return NULL;
_______________________________________________
Python-checkins mailing list -- [email protected]
To unsubscribe send an email to [email protected]
https://mail.python.org/mailman3//lists/python-checkins.python.org
Member address: [email protected]
