convertsimple() doesn't need to call converterr() if an exception was already raised

Python/getargs.c

 
 /* New getargs implementation */
 
 #include "Python.h"
 
 #include <ctype.h>
 
 
 #ifdef __cplusplus
 extern "C" {
@@ skipping 144 matching lines @@
 static void
 cleanup_buffer(PyObject *self)
 {
     Py_buffer *ptr = (Py_buffer *)PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_BUFFER);
     if (ptr) {
         PyBuffer_Release(ptr);
     }
 }
 
 static int
-addcleanup(void *ptr, PyObject **freelist, PyCapsule_Destructor destr)
+addcleanup(void *ptr, PyObject **freelist, int is_buffer)
 {
     PyObject *cobj;
     const char *name;
+    PyCapsule_Destructor destr;
+
+    if (is_buffer) {
+        destr = cleanup_buffer;
+        name = GETARGS_CAPSULE_NAME_CLEANUP_BUFFER;
+    } else {
+        destr = cleanup_ptr;
+        name = GETARGS_CAPSULE_NAME_CLEANUP_PTR;
+    }
 
     if (!*freelist) {
         *freelist = PyList_New(0);
         if (!*freelist) {
             destr(ptr);
             return -1;
         }
     }
 
-    if (destr == cleanup_ptr) {
-        name = GETARGS_CAPSULE_NAME_CLEANUP_PTR;
-    } else if (destr == cleanup_buffer) {
-        name = GETARGS_CAPSULE_NAME_CLEANUP_BUFFER;
-    } else {
-        return -1;
-    }
     cobj = PyCapsule_New(ptr, name, destr);
     if (!cobj) {
         destr(ptr);
         return -1;
     }
     if (PyList_Append(*freelist, cobj)) {
         Py_DECREF(cobj);
         return -1;
     }
     Py_DECREF(cobj);
@@ skipping 413 matching lines @@
 static char *
 convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
               char *msgbuf, size_t bufsize, PyObject **freelist)
 {
     /* For # codes */
 #define FETCH_SIZE      int *q=NULL;Py_ssize_t *q2=NULL;\
     if (flags & FLAG_SIZE_T) q2=va_arg(*p_va, Py_ssize_t*); \
     else q=va_arg(*p_va, int*);
 #define STORE_SIZE(s)   if (flags & FLAG_SIZE_T) *q2=s; else *q=s;
 #define BUFFER_LEN      ((flags & FLAG_SIZE_T) ? *q2:*q)
+#define RETURN_ERR_OCCURRED return msgbuf
 
     const char *format = *p_format;
     char c = *format++;
     PyObject *uarg;
 
     switch (c) {
 
     case 'b': { /* unsigned byte -- very short int */
         char *p = va_arg(*p_va, char *);
         long ival;
         if (float_argument_error(arg))
-            return converterr("integer<b>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         ival = PyLong_AsLong(arg);
         if (ival == -1 && PyErr_Occurred())
-            return converterr("integer<b>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         else if (ival < 0) {
             PyErr_SetString(PyExc_OverflowError,
             "unsigned byte integer is less than minimum");
-            return converterr("integer<b>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         }
         else if (ival > UCHAR_MAX) {
             PyErr_SetString(PyExc_OverflowError,
             "unsigned byte integer is greater than maximum");
-            return converterr("integer<b>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         }
         else
             *p = (unsigned char) ival;
         break;
     }
 
     case 'B': {/* byte sized bitfield - both signed and unsigned
                   values allowed */
         char *p = va_arg(*p_va, char *);
         long ival;
         if (float_argument_error(arg))
-            return converterr("integer<B>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         ival = PyLong_AsUnsignedLongMask(arg);
         if (ival == -1 && PyErr_Occurred())
-            return converterr("integer<B>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         else
             *p = (unsigned char) ival;
         break;
     }
 
     case 'h': {/* signed short int */
         short *p = va_arg(*p_va, short *);
         long ival;
         if (float_argument_error(arg))
-            return converterr("integer<h>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         ival = PyLong_AsLong(arg);
         if (ival == -1 && PyErr_Occurred())
-            return converterr("integer<h>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         else if (ival < SHRT_MIN) {
             PyErr_SetString(PyExc_OverflowError,
             "signed short integer is less than minimum");
-            return converterr("integer<h>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         }
         else if (ival > SHRT_MAX) {
             PyErr_SetString(PyExc_OverflowError,
             "signed short integer is greater than maximum");
-            return converterr("integer<h>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         }
         else
             *p = (short) ival;
         break;
     }
 
     case 'H': { /* short int sized bitfield, both signed and
                    unsigned allowed */
         unsigned short *p = va_arg(*p_va, unsigned short *);
         long ival;
         if (float_argument_error(arg))
-            return converterr("integer<H>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         ival = PyLong_AsUnsignedLongMask(arg);
         if (ival == -1 && PyErr_Occurred())
-            return converterr("integer<H>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         else
             *p = (unsigned short) ival;
         break;
     }
 
     case 'i': {/* signed int */
         int *p = va_arg(*p_va, int *);
         long ival;
         if (float_argument_error(arg))
-            return converterr("integer<i>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         ival = PyLong_AsLong(arg);
         if (ival == -1 && PyErr_Occurred())
-            return converterr("integer<i>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         else if (ival > INT_MAX) {
             PyErr_SetString(PyExc_OverflowError,
                 "signed integer is greater than maximum");
-            return converterr("integer<i>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         }
         else if (ival < INT_MIN) {
             PyErr_SetString(PyExc_OverflowError,
                 "signed integer is less than minimum");
-            return converterr("integer<i>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         }
         else
             *p = ival;
         break;
     }
 
     case 'I': { /* int sized bitfield, both signed and
                    unsigned allowed */
         unsigned int *p = va_arg(*p_va, unsigned int *);
         unsigned int ival;
         if (float_argument_error(arg))
-            return converterr("integer<I>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         ival = (unsigned int)PyLong_AsUnsignedLongMask(arg);
         if (ival == (unsigned int)-1 && PyErr_Occurred())
-            return converterr("integer<I>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         else
             *p = ival;
         break;
     }
 
     case 'n': /* Py_ssize_t */
     {
         PyObject *iobj;
         Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *);
         Py_ssize_t ival = -1;
         if (float_argument_error(arg))
-            return converterr("integer<n>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         iobj = PyNumber_Index(arg);
         if (iobj != NULL) {
             ival = PyLong_AsSsize_t(iobj);
             Py_DECREF(iobj);
         }
         if (ival == -1 && PyErr_Occurred())
-            return converterr("integer<n>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         *p = ival;
         break;
     }
     case 'l': {/* long int */
         long *p = va_arg(*p_va, long *);
         long ival;
         if (float_argument_error(arg))
-            return converterr("integer<l>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         ival = PyLong_AsLong(arg);
         if (ival == -1 && PyErr_Occurred())
-            return converterr("integer<l>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         else
             *p = ival;
         break;
     }
 
     case 'k': { /* long sized bitfield */
         unsigned long *p = va_arg(*p_va, unsigned long *);
         unsigned long ival;
         if (PyLong_Check(arg))
             ival = PyLong_AsUnsignedLongMask(arg);
         else
             return converterr("integer<k>", arg, msgbuf, bufsize);
         *p = ival;
         break;
     }
 
 #ifdef HAVE_LONG_LONG
     case 'L': {/* PY_LONG_LONG */
         PY_LONG_LONG *p = va_arg( *p_va, PY_LONG_LONG * );
         PY_LONG_LONG ival;
         if (float_argument_error(arg))
-            return converterr("long<L>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         ival = PyLong_AsLongLong(arg);
         if (ival == (PY_LONG_LONG)-1 && PyErr_Occurred())
-            return converterr("long<L>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         else
             *p = ival;
         break;
     }
 
     case 'K': { /* long long sized bitfield */
         unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *);
         unsigned PY_LONG_LONG ival;
         if (PyLong_Check(arg))
             ival = PyLong_AsUnsignedLongLongMask(arg);
         else
             return converterr("integer<K>", arg, msgbuf, bufsize);
         *p = ival;
         break;
     }
 #endif
 
     case 'f': {/* float */
         float *p = va_arg(*p_va, float *);
         double dval = PyFloat_AsDouble(arg);
         if (PyErr_Occurred())
-            return converterr("float<f>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         else
             *p = (float) dval;
         break;
     }
 
     case 'd': {/* double */
         double *p = va_arg(*p_va, double *);
         double dval = PyFloat_AsDouble(arg);
         if (PyErr_Occurred())
-            return converterr("float<d>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         else
             *p = dval;
         break;
     }
 
     case 'D': {/* complex double */
         Py_complex *p = va_arg(*p_va, Py_complex *);
         Py_complex cval;
         cval = PyComplex_AsCComplex(arg);
         if (PyErr_Occurred())
-            return converterr("complex<D>", arg, msgbuf, bufsize);
+            RETURN_ERR_OCCURRED;
         else
             *p = cval;
         break;
     }
 
     case 'c': {/* char */
         char *p = va_arg(*p_va, char *);
         if (PyBytes_Check(arg) && PyBytes_Size(arg) == 1)
             *p = PyBytes_AS_STRING(arg)[0];
         else
@@ skipping 14 matching lines @@
     /* XXX WAAAAH!  's', 'y', 'z', 'u', 'Z', 'e', 'w' codes all
        need to be cleaned up! */
 
     case 's': {/* text string */
         if (*format == '*') {
             Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
 
             if (PyUnicode_Check(arg)) {
                 uarg = UNICODE_DEFAULT_ENCODING(arg);
                 if (uarg == NULL)
-                    return converterr(CONV_UNICODE,
-                                      arg, msgbuf, bufsize);
+                    RETURN_ERR_OCCURRED;
                 PyBuffer_FillInfo(p, arg,
                                   PyBytes_AS_STRING(uarg), PyBytes_GET_SIZE(uarg),
                                   1, 0);
             }
             else { /* any buffer-like object */
                 char *buf;
                 if (getbuffer(arg, p, &buf) < 0)
                     return converterr(buf, arg, msgbuf, bufsize);
             }
-            if (addcleanup(p, freelist, cleanup_buffer)) {
-                return converterr(
-                    "(cleanup problem)",
-                    arg, msgbuf, bufsize);
-            }
+            if (addcleanup(p, freelist, 1))
+                RETURN_ERR_OCCURRED;
             format++;
         } else if (*format == '#') {
             void **p = (void **)va_arg(*p_va, char **);
             FETCH_SIZE;
 
             if (PyUnicode_Check(arg)) {
                 uarg = UNICODE_DEFAULT_ENCODING(arg);
                 if (uarg == NULL)
-                    return converterr(CONV_UNICODE,
-                                      arg, msgbuf, bufsize);
+                    RETURN_ERR_OCCURRED;
                 *p = PyBytes_AS_STRING(uarg);
                 STORE_SIZE(PyBytes_GET_SIZE(uarg));
             }
             else { /* any buffer-like object */
                 /* XXX Really? */
                 char *buf;
                 Py_ssize_t count = convertbuffer(arg, p, &buf);
                 if (count < 0)
                     return converterr(buf, arg, msgbuf, bufsize);
                 STORE_SIZE(count);
             }
             format++;
         } else {
             char **p = va_arg(*p_va, char **);
 
             if (PyUnicode_Check(arg)) {
                 uarg = UNICODE_DEFAULT_ENCODING(arg);
                 if (uarg == NULL)
-                    return converterr(CONV_UNICODE,
-                                      arg, msgbuf, bufsize);
+                    RETURN_ERR_OCCURRED;
                 *p = PyBytes_AS_STRING(uarg);
             }
             else
                 return converterr("string", arg, msgbuf, bufsize);
             if ((Py_ssize_t) strlen(*p) != PyBytes_GET_SIZE(uarg))
                 return converterr("string without null bytes",
                                   arg, msgbuf, bufsize);
         }
         break;
     }
 
     case 'y': {/* any buffer-like object, but not PyUnicode */
         void **p = (void **)va_arg(*p_va, char **);
         char *buf;
         Py_ssize_t count;
         if (*format == '*') {
             if (getbuffer(arg, (Py_buffer*)p, &buf) < 0)
                 return converterr(buf, arg, msgbuf, bufsize);
             format++;
-            if (addcleanup(p, freelist, cleanup_buffer)) {
-                return converterr(
-                    "(cleanup problem)",
-                    arg, msgbuf, bufsize);
-            }
+            if (addcleanup(p, freelist, 1))
+                RETURN_ERR_OCCURRED;
             break;
         }
         count = convertbuffer(arg, p, &buf);
         if (count < 0)
             return converterr(buf, arg, msgbuf, bufsize);
         if (*format == '#') {
             FETCH_SIZE;
             STORE_SIZE(count);
             format++;
         } else {
             if (strlen(*p) != count)
                 return converterr(
                     "bytes without null bytes",
                     arg, msgbuf, bufsize);
         }
         break;
     }
 
     case 'z': {/* like 's' or 's#', but None is okay, stored as NULL */
         if (*format == '*') {
             Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);
 
             if (arg == Py_None)
                 PyBuffer_FillInfo(p, NULL, NULL, 0, 1, 0);
             else if (PyUnicode_Check(arg)) {
                 uarg = UNICODE_DEFAULT_ENCODING(arg);
                 if (uarg == NULL)
-                    return converterr(CONV_UNICODE,
-                                      arg, msgbuf, bufsize);
+                    RETURN_ERR_OCCURRED;
                 PyBuffer_FillInfo(p, arg,
                                   PyBytes_AS_STRING(uarg), PyBytes_GET_SIZE(uarg),
                                   1, 0);
             }
             else { /* any buffer-like object */
                 char *buf;
                 if (getbuffer(arg, p, &buf) < 0)
                     return converterr(buf, arg, msgbuf, bufsize);
             }
-            if (addcleanup(p, freelist, cleanup_buffer)) {
-                return converterr(
-                    "(cleanup problem)",
-                    arg, msgbuf, bufsize);
-            }
+            if (addcleanup(p, freelist, 1))
+                RETURN_ERR_OCCURRED;
             format++;
         } else if (*format == '#') { /* any buffer-like object */
             void **p = (void **)va_arg(*p_va, char **);
             FETCH_SIZE;
 
             if (arg == Py_None) {
                 *p = 0;
                 STORE_SIZE(0);
             }
             else if (PyUnicode_Check(arg)) {
                 uarg = UNICODE_DEFAULT_ENCODING(arg);
                 if (uarg == NULL)
-                    return converterr(CONV_UNICODE,
-                                      arg, msgbuf, bufsize);
+                    RETURN_ERR_OCCURRED;
                 *p = PyBytes_AS_STRING(uarg);
                 STORE_SIZE(PyBytes_GET_SIZE(uarg));
             }
             else { /* any buffer-like object */
                 /* XXX Really? */
                 char *buf;
                 Py_ssize_t count = convertbuffer(arg, p, &buf);
                 if (count < 0)
                     return converterr(buf, arg, msgbuf, bufsize);
                 STORE_SIZE(count);
             }
             format++;
         } else {
             char **p = va_arg(*p_va, char **);
             uarg = NULL;
 
             if (arg == Py_None)
                 *p = 0;
             else if (PyBytes_Check(arg)) {
                 /* Enable null byte check below */
                 uarg = arg;
                 *p = PyBytes_AS_STRING(arg);
             }
             else if (PyUnicode_Check(arg)) {
                 uarg = UNICODE_DEFAULT_ENCODING(arg);
                 if (uarg == NULL)
-                    return converterr(CONV_UNICODE,
-                                      arg, msgbuf, bufsize);
+                    RETURN_ERR_OCCURRED;
                 *p = PyBytes_AS_STRING(uarg);
             }
             else
                 return converterr("string or None",
                                   arg, msgbuf, bufsize);
             if (*p != NULL && uarg != NULL &&
                 (Py_ssize_t) strlen(*p) != PyBytes_GET_SIZE(uarg))
                 return converterr(
                     "string without null bytes or None",
                     arg, msgbuf, bufsize);
@@ skipping 64 matching lines @@
         if (buffer == NULL)
             return converterr("(buffer is NULL)",
                               arg, msgbuf, bufsize);
 
         /* Encode object */
         if (!recode_strings &&
             (PyBytes_Check(arg) || PyByteArray_Check(arg))) {
             s = arg;
             Py_INCREF(s);
             if (PyObject_AsCharBuffer(s, &ptr, &size) < 0)
-                return converterr("(AsCharBuffer failed)",
-                                  arg, msgbuf, bufsize);
+                RETURN_ERR_OCCURRED;
         }
         else {
             PyObject *u;
 
             /* Convert object to Unicode */
             u = PyUnicode_FromObject(arg);
             if (u == NULL)
-                return converterr(
-                    "string or unicode or text buffer",
-                    arg, msgbuf, bufsize);
+                RETURN_ERR_OCCURRED;
 
             /* Encode object; use default error handling */
-            s = PyUnicode_AsEncodedString(u,
-                                          encoding,
-                                          NULL);
+            s = PyUnicode_AsEncodedString(u, encoding, NULL);
             Py_DECREF(u);
             if (s == NULL)
-                return converterr("(encoding failed)",
-                                  arg, msgbuf, bufsize);
-            if (!PyBytes_Check(s)) {
-                Py_DECREF(s);
-                return converterr(
-                    "(encoder failed to return bytes)",
-                    arg, msgbuf, bufsize);
-            }
+                RETURN_ERR_OCCURRED;
             size = PyBytes_GET_SIZE(s);
             ptr = PyBytes_AS_STRING(s);
             if (ptr == NULL)
                 ptr = "";
         }
 
         /* Write output; output is guaranteed to be 0-terminated */
         if (*format == '#') {
             /* Using buffer length parameter '#':
 
@@ skipping 23 matching lines @@
                 Py_DECREF(s);
                 return converterr(
                     "(buffer_len is NULL)",
                     arg, msgbuf, bufsize);
             }
             if (*buffer == NULL) {
                 *buffer = PyMem_NEW(char, size + 1);
                 if (*buffer == NULL) {
                     Py_DECREF(s);
                     PyErr_NoMemory();
-                    return converterr(
-                        "(memory error)",
-                        arg, msgbuf, bufsize);
+                    RETURN_ERR_OCCURRED;
                 }
-                if (addcleanup(*buffer, freelist, cleanup_ptr)) {
+                if (addcleanup(*buffer, freelist, 0)) {
                     Py_DECREF(s);
-                    return converterr(
-                        "(cleanup problem)",
-                        arg, msgbuf, bufsize);
+                    RETURN_ERR_OCCURRED;
                 }
             } else {
                 if (size + 1 > BUFFER_LEN) {
                     Py_DECREF(s);
                     return converterr(
                         "(buffer overflow)",
                         arg, msgbuf, bufsize);
                 }
             }
             memcpy(*buffer, ptr, size+1);
@@ skipping 15 matching lines @@
             if ((Py_ssize_t)strlen(ptr) != size) {
                 Py_DECREF(s);
                 return converterr(
                     "encoded string without NULL bytes",
                     arg, msgbuf, bufsize);
             }
             *buffer = PyMem_NEW(char, size + 1);
             if (*buffer == NULL) {
                 Py_DECREF(s);
                 PyErr_NoMemory();
-                return converterr("(memory error)",
-                                  arg, msgbuf, bufsize);
+                RETURN_ERR_OCCURRED;
             }
-            if (addcleanup(*buffer, freelist, cleanup_ptr)) {
+            if (addcleanup(*buffer, freelist, 0)) {
                 Py_DECREF(s);
-                return converterr("(cleanup problem)",
-                                arg, msgbuf, bufsize);
+                RETURN_ERR_OCCURRED;
             }
             memcpy(*buffer, ptr, size+1);
         }
         Py_DECREF(s);
         break;
     }
 
     case 'u': {/* raw unicode buffer (Py_UNICODE *) */
         Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
         if (!PyUnicode_Check(arg))
@@ skipping 52 matching lines @@
                 return converterr(type->tp_name, arg, msgbuf, bufsize);
 
         }
         else if (*format == '&') {
             typedef int (*converter)(PyObject *, void *);
             converter convert = va_arg(*p_va, converter);
             void *addr = va_arg(*p_va, void *);
             int res;
             format++;
             if (! (res = (*convert)(arg, addr)))
-                return converterr("(unspecified)",
-                                  arg, msgbuf, bufsize);
+                return converterr("(converter error)", arg, msgbuf, bufsize);
             if (res == Py_CLEANUP_SUPPORTED &&
                 addcleanup_convert(addr, freelist, convert) == -1)
-                return converterr("(cleanup problem)",
-                                arg, msgbuf, bufsize);
+                RETURN_ERR_OCCURRED;
         }
         else {
             p = va_arg(*p_va, PyObject **);
             *p = arg;
         }
         break;
     }
 
 
     case 'w': { /* memory buffer, read-write access */
@@ skipping 10 matching lines @@
 
 
         if (pb && pb->bf_getbuffer && *format == '*') {
             /* Caller is interested in Py_buffer, and the object
                supports it directly. */
             format++;
             if (PyObject_GetBuffer(arg, (Py_buffer*)p, PyBUF_WRITABLE) < 0) {
                 PyErr_Clear();
                 return converterr("read-write buffer", arg, msgbuf, bufsize);
             }
-            if (addcleanup(p, freelist, cleanup_buffer)) {
-                return converterr(
-                    "(cleanup problem)",
-                    arg, msgbuf, bufsize);
-            }
+            if (addcleanup(p, freelist, 1))
+                RETURN_ERR_OCCURRED;
             if (!PyBuffer_IsContiguous((Py_buffer*)p, 'C'))
                 return converterr("contiguous buffer", arg, msgbuf, bufsize);
             break;
         }
 
         /* Here we have processed w*, only w and w# remain. */
         if (pb == NULL ||
             pb->bf_getbuffer == NULL ||
             ((temp = PyObject_GetBuffer(arg, &view,
                                         PyBUF_SIMPLE)) != 0) ||
@@ skipping 574 matching lines @@
     if (PyDict_Size(kw) == 0)
         return 1;
 
     PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",
                     funcname);
     return 0;
 }
 #ifdef __cplusplus
 };
 #endif