blob: ccd18175683939baafe44c101387a39db08331e0 [file] [log] [blame]
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00001
2/* New getargs implementation */
3
Guido van Rossum79f25d91997-04-29 20:08:16 +00004#include "Python.h"
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00005
Guido van Rossumc1d50531996-08-21 23:38:24 +00006#include <ctype.h>
7
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00008
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00009#ifdef __cplusplus
Guido van Rossum98297ee2007-11-06 21:34:58 +000010extern "C" {
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000011#endif
Jeremy Hyltonaf68c872005-12-10 18:50:16 +000012int PyArg_Parse(PyObject *, const char *, ...);
13int PyArg_ParseTuple(PyObject *, const char *, ...);
14int PyArg_VaParse(PyObject *, const char *, va_list);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +000015
Tim Petersdbd9ba62000-07-09 03:09:57 +000016int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
Martin v. Löwis15e62742006-02-27 16:46:16 +000017 const char *, char **, ...);
Brett Cannon711e7d92004-07-10 22:20:32 +000018int PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,
Martin v. Löwis15e62742006-02-27 16:46:16 +000019 const char *, char **, va_list);
Brett Cannon711e7d92004-07-10 22:20:32 +000020
Thomas Wouters49fd7fa2006-04-21 10:40:58 +000021#ifdef HAVE_DECLSPEC_DLL
22/* Export functions */
23PyAPI_FUNC(int) _PyArg_Parse_SizeT(PyObject *, char *, ...);
24PyAPI_FUNC(int) _PyArg_ParseTuple_SizeT(PyObject *, char *, ...);
25PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywords_SizeT(PyObject *, PyObject *,
26 const char *, char **, ...);
27PyAPI_FUNC(PyObject *) _Py_BuildValue_SizeT(const char *, ...);
28PyAPI_FUNC(int) _PyArg_VaParse_SizeT(PyObject *, char *, va_list);
29PyAPI_FUNC(int) _PyArg_VaParseTupleAndKeywords_SizeT(PyObject *, PyObject *,
30 const char *, char **, va_list);
31#endif
32
Martin v. Löwis18e16552006-02-15 17:27:45 +000033#define FLAG_COMPAT 1
34#define FLAG_SIZE_T 2
35
Guido van Rossumfe3f1a21994-09-29 09:42:55 +000036
37/* Forward */
Jeremy Hyltonaf68c872005-12-10 18:50:16 +000038static int vgetargs1(PyObject *, const char *, va_list *, int);
39static void seterror(int, const char *, int *, const char *, const char *);
Guido van Rossum98297ee2007-11-06 21:34:58 +000040static char *convertitem(PyObject *, const char **, va_list *, int, int *,
Martin v. Löwis18e16552006-02-15 17:27:45 +000041 char *, size_t, PyObject **);
42static char *converttuple(PyObject *, const char **, va_list *, int,
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +000043 int *, char *, size_t, int, PyObject **);
Martin v. Löwis18e16552006-02-15 17:27:45 +000044static char *convertsimple(PyObject *, const char **, va_list *, int, char *,
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +000045 size_t, PyObject **);
Martin v. Löwis18e16552006-02-15 17:27:45 +000046static Py_ssize_t convertbuffer(PyObject *, void **p, char **);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +000047
Tim Petersdbd9ba62000-07-09 03:09:57 +000048static int vgetargskeywords(PyObject *, PyObject *,
Martin v. Löwis15e62742006-02-27 16:46:16 +000049 const char *, char **, va_list *, int);
Martin v. Löwis18e16552006-02-15 17:27:45 +000050static char *skipitem(const char **, va_list *, int);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +000051
Fred Drake563dfc22001-10-23 14:41:08 +000052int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +000053PyArg_Parse(PyObject *args, const char *format, ...)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +000054{
55 int retval;
56 va_list va;
Guido van Rossum98297ee2007-11-06 21:34:58 +000057
Guido van Rossumfe3f1a21994-09-29 09:42:55 +000058 va_start(va, format);
Martin v. Löwis18e16552006-02-15 17:27:45 +000059 retval = vgetargs1(args, format, &va, FLAG_COMPAT);
60 va_end(va);
61 return retval;
62}
63
64int
65_PyArg_Parse_SizeT(PyObject *args, char *format, ...)
66{
67 int retval;
68 va_list va;
Guido van Rossum98297ee2007-11-06 21:34:58 +000069
Martin v. Löwis18e16552006-02-15 17:27:45 +000070 va_start(va, format);
71 retval = vgetargs1(args, format, &va, FLAG_COMPAT|FLAG_SIZE_T);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +000072 va_end(va);
73 return retval;
74}
75
76
Fred Drake563dfc22001-10-23 14:41:08 +000077int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +000078PyArg_ParseTuple(PyObject *args, const char *format, ...)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +000079{
80 int retval;
81 va_list va;
Guido van Rossum98297ee2007-11-06 21:34:58 +000082
Guido van Rossumfe3f1a21994-09-29 09:42:55 +000083 va_start(va, format);
Guido van Rossum1ae940a1995-01-02 19:04:15 +000084 retval = vgetargs1(args, format, &va, 0);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +000085 va_end(va);
86 return retval;
87}
88
Martin v. Löwis18e16552006-02-15 17:27:45 +000089int
90_PyArg_ParseTuple_SizeT(PyObject *args, char *format, ...)
91{
92 int retval;
93 va_list va;
Guido van Rossum98297ee2007-11-06 21:34:58 +000094
Martin v. Löwis18e16552006-02-15 17:27:45 +000095 va_start(va, format);
96 retval = vgetargs1(args, format, &va, FLAG_SIZE_T);
97 va_end(va);
98 return retval;
99}
100
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000101
102int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000103PyArg_VaParse(PyObject *args, const char *format, va_list va)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000104{
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000105 va_list lva;
106
107#ifdef VA_LIST_IS_ARRAY
108 memcpy(lva, va, sizeof(va_list));
109#else
Martin v. Löwis75d2d942002-07-28 10:23:27 +0000110#ifdef __va_copy
111 __va_copy(lva, va);
112#else
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000113 lva = va;
114#endif
Martin v. Löwis75d2d942002-07-28 10:23:27 +0000115#endif
Guido van Rossum1ae940a1995-01-02 19:04:15 +0000116
117 return vgetargs1(args, format, &lva, 0);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000118}
119
Martin v. Löwis18e16552006-02-15 17:27:45 +0000120int
121_PyArg_VaParse_SizeT(PyObject *args, char *format, va_list va)
122{
123 va_list lva;
124
125#ifdef VA_LIST_IS_ARRAY
126 memcpy(lva, va, sizeof(va_list));
127#else
128#ifdef __va_copy
129 __va_copy(lva, va);
130#else
131 lva = va;
132#endif
133#endif
134
135 return vgetargs1(args, format, &lva, FLAG_SIZE_T);
136}
137
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000138
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000139/* Handle cleanup of allocated memory in case of exception */
140
141static int
142addcleanup(void *ptr, PyObject **freelist)
143{
144 PyObject *cobj;
145 if (!*freelist) {
146 *freelist = PyList_New(0);
147 if (!*freelist) {
148 PyMem_FREE(ptr);
149 return -1;
150 }
151 }
152 cobj = PyCObject_FromVoidPtr(ptr, NULL);
153 if (!cobj) {
154 PyMem_FREE(ptr);
155 return -1;
156 }
Christian Heimes836baa52008-02-26 08:18:30 +0000157 if (PyList_Append(*freelist, cobj)) {
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000158 PyMem_FREE(ptr);
159 Py_DECREF(cobj);
160 return -1;
161 }
162 Py_DECREF(cobj);
163 return 0;
164}
165
166static int
167cleanreturn(int retval, PyObject *freelist)
168{
Christian Heimes836baa52008-02-26 08:18:30 +0000169 if (freelist) {
170 if (retval == 0) {
Martin v. Löwisd96ee902006-02-16 14:37:16 +0000171 Py_ssize_t len = PyList_GET_SIZE(freelist), i;
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000172 for (i = 0; i < len; i++)
173 PyMem_FREE(PyCObject_AsVoidPtr(
174 PyList_GET_ITEM(freelist, i)));
175 }
176 Py_DECREF(freelist);
177 }
178 return retval;
179}
180
181
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000182static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000183vgetargs1(PyObject *args, const char *format, va_list *p_va, int flags)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000184{
185 char msgbuf[256];
186 int levels[32];
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000187 const char *fname = NULL;
188 const char *message = NULL;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000189 int min = -1;
190 int max = 0;
191 int level = 0;
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000192 int endfmt = 0;
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000193 const char *formatsave = format;
Martin v. Löwisd96ee902006-02-16 14:37:16 +0000194 Py_ssize_t i, len;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000195 char *msg;
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000196 PyObject *freelist = NULL;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000197 int compat = flags & FLAG_COMPAT;
198
Tim Peters5c4d5bf2001-02-12 22:13:26 +0000199 assert(compat || (args != (PyObject*)NULL));
Martin v. Löwis18e16552006-02-15 17:27:45 +0000200 flags = flags & ~FLAG_COMPAT;
Tim Peters5c4d5bf2001-02-12 22:13:26 +0000201
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000202 while (endfmt == 0) {
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000203 int c = *format++;
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000204 switch (c) {
205 case '(':
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000206 if (level == 0)
207 max++;
208 level++;
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000209 if (level >= 30)
210 Py_FatalError("too many tuple nesting levels "
211 "in argument format string");
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000212 break;
213 case ')':
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000214 if (level == 0)
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000215 Py_FatalError("excess ')' in getargs format");
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000216 else
217 level--;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000218 break;
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000219 case '\0':
220 endfmt = 1;
221 break;
222 case ':':
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000223 fname = format;
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000224 endfmt = 1;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000225 break;
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000226 case ';':
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000227 message = format;
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000228 endfmt = 1;
229 break;
230 default:
231 if (level == 0) {
232 if (c == 'O')
233 max++;
Neal Norwitz30b5c5d2005-12-19 06:05:18 +0000234 else if (isalpha(Py_CHARMASK(c))) {
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000235 if (c != 'e') /* skip encoded */
236 max++;
237 } else if (c == '|')
238 min = max;
239 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000240 break;
241 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000242 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000243
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000244 if (level != 0)
Guido van Rossum79f25d91997-04-29 20:08:16 +0000245 Py_FatalError(/* '(' */ "missing ')' in getargs format");
Guido van Rossum98297ee2007-11-06 21:34:58 +0000246
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000247 if (min < 0)
248 min = max;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000249
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000250 format = formatsave;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000251
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000252 if (compat) {
253 if (max == 0) {
254 if (args == NULL)
255 return 1;
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000256 PyOS_snprintf(msgbuf, sizeof(msgbuf),
257 "%.200s%s takes no arguments",
258 fname==NULL ? "function" : fname,
259 fname==NULL ? "" : "()");
Guido van Rossum79f25d91997-04-29 20:08:16 +0000260 PyErr_SetString(PyExc_TypeError, msgbuf);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000261 return 0;
262 }
263 else if (min == 1 && max == 1) {
Guido van Rossum13d0ed11994-11-10 22:35:48 +0000264 if (args == NULL) {
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000265 PyOS_snprintf(msgbuf, sizeof(msgbuf),
266 "%.200s%s takes at least one argument",
267 fname==NULL ? "function" : fname,
268 fname==NULL ? "" : "()");
Guido van Rossum79f25d91997-04-29 20:08:16 +0000269 PyErr_SetString(PyExc_TypeError, msgbuf);
Guido van Rossum13d0ed11994-11-10 22:35:48 +0000270 return 0;
271 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000272 msg = convertitem(args, &format, p_va, flags, levels,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000273 msgbuf, sizeof(msgbuf), &freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000274 if (msg == NULL)
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000275 return cleanreturn(1, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000276 seterror(levels[0], msg, levels+1, fname, message);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000277 return cleanreturn(0, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000278 }
279 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000280 PyErr_SetString(PyExc_SystemError,
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000281 "old style getargs format uses new features");
282 return 0;
283 }
284 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000285
Guido van Rossum79f25d91997-04-29 20:08:16 +0000286 if (!PyTuple_Check(args)) {
287 PyErr_SetString(PyExc_SystemError,
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000288 "new style getargs format but argument is not a tuple");
289 return 0;
290 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000291
Jeremy Hylton0f8117f2001-05-18 20:57:38 +0000292 len = PyTuple_GET_SIZE(args);
Guido van Rossum98297ee2007-11-06 21:34:58 +0000293
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000294 if (len < min || max < len) {
295 if (message == NULL) {
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000296 PyOS_snprintf(msgbuf, sizeof(msgbuf),
297 "%.150s%s takes %s %d argument%s "
Neal Norwitz20dd93f2006-02-19 19:34:15 +0000298 "(%ld given)",
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000299 fname==NULL ? "function" : fname,
300 fname==NULL ? "" : "()",
301 min==max ? "exactly"
302 : len < min ? "at least" : "at most",
303 len < min ? min : max,
304 (len < min ? min : max) == 1 ? "" : "s",
Neal Norwitz9a276172006-02-20 18:57:39 +0000305 Py_SAFE_DOWNCAST(len, Py_ssize_t, long));
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000306 message = msgbuf;
307 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000308 PyErr_SetString(PyExc_TypeError, message);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000309 return 0;
310 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000311
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000312 for (i = 0; i < len; i++) {
313 if (*format == '|')
314 format++;
Jeremy Hylton0f8117f2001-05-18 20:57:38 +0000315 msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
Guido van Rossum98297ee2007-11-06 21:34:58 +0000316 flags, levels, msgbuf,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000317 sizeof(msgbuf), &freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000318 if (msg) {
319 seterror(i+1, msg, levels, fname, message);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000320 return cleanreturn(0, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000321 }
322 }
Guido van Rossum231a41e1997-12-09 20:36:39 +0000323
Neal Norwitz4ac13df2005-12-19 06:10:07 +0000324 if (*format != '\0' && !isalpha(Py_CHARMASK(*format)) &&
Guido van Rossum7d4f68c1997-12-19 04:25:23 +0000325 *format != '(' &&
Guido van Rossum231a41e1997-12-09 20:36:39 +0000326 *format != '|' && *format != ':' && *format != ';') {
327 PyErr_Format(PyExc_SystemError,
Guido van Rossum0d6b49e1998-01-19 22:22:44 +0000328 "bad format string: %.200s", formatsave);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000329 return cleanreturn(0, freelist);
Guido van Rossum231a41e1997-12-09 20:36:39 +0000330 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000331
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000332 return cleanreturn(1, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000333}
334
335
336
337static void
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000338seterror(int iarg, const char *msg, int *levels, const char *fname,
339 const char *message)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000340{
Marc-André Lemburgd4c0a9c2001-11-28 11:47:00 +0000341 char buf[512];
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000342 int i;
343 char *p = buf;
344
Guido van Rossum79f25d91997-04-29 20:08:16 +0000345 if (PyErr_Occurred())
Guido van Rossum64fc6491995-01-21 14:09:37 +0000346 return;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000347 else if (message == NULL) {
348 if (fname != NULL) {
Jeremy Hyltonf16e05e2001-11-28 21:46:59 +0000349 PyOS_snprintf(p, sizeof(buf), "%.200s() ", fname);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000350 p += strlen(p);
351 }
Ka-Ping Yee20579702001-01-15 22:14:16 +0000352 if (iarg != 0) {
Tim Petersfaad5ad2001-12-03 00:43:33 +0000353 PyOS_snprintf(p, sizeof(buf) - (p - buf),
Jeremy Hyltonf16e05e2001-11-28 21:46:59 +0000354 "argument %d", iarg);
Ka-Ping Yee20579702001-01-15 22:14:16 +0000355 i = 0;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000356 p += strlen(p);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000357 while (levels[i] > 0 && i < 32 && (int)(p-buf) < 220) {
358 PyOS_snprintf(p, sizeof(buf) - (p - buf),
Jeremy Hyltonf16e05e2001-11-28 21:46:59 +0000359 ", item %d", levels[i]-1);
Ka-Ping Yee20579702001-01-15 22:14:16 +0000360 p += strlen(p);
361 i++;
362 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000363 }
Ka-Ping Yee20579702001-01-15 22:14:16 +0000364 else {
Tim Petersfaad5ad2001-12-03 00:43:33 +0000365 PyOS_snprintf(p, sizeof(buf) - (p - buf), "argument");
Ka-Ping Yee20579702001-01-15 22:14:16 +0000366 p += strlen(p);
367 }
Tim Petersfaad5ad2001-12-03 00:43:33 +0000368 PyOS_snprintf(p, sizeof(buf) - (p - buf), " %.256s", msg);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000369 message = buf;
370 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000371 PyErr_SetString(PyExc_TypeError, message);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000372}
373
374
375/* Convert a tuple argument.
376 On entry, *p_format points to the character _after_ the opening '('.
377 On successful exit, *p_format points to the closing ')'.
378 If successful:
379 *p_format and *p_va are updated,
380 *levels and *msgbuf are untouched,
381 and NULL is returned.
382 If the argument is invalid:
383 *p_format is unchanged,
384 *p_va is undefined,
385 *levels is a 0-terminated list of item numbers,
386 *msgbuf contains an error message, whose format is:
Ka-Ping Yee20579702001-01-15 22:14:16 +0000387 "must be <typename1>, not <typename2>", where:
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000388 <typename1> is the name of the expected type, and
389 <typename2> is the name of the actual type,
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000390 and msgbuf is returned.
391*/
392
393static char *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000394converttuple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
Guido van Rossum98297ee2007-11-06 21:34:58 +0000395 int *levels, char *msgbuf, size_t bufsize, int toplevel,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000396 PyObject **freelist)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000397{
398 int level = 0;
399 int n = 0;
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000400 const char *format = *p_format;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000401 int i;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000402
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000403 for (;;) {
404 int c = *format++;
405 if (c == '(') {
406 if (level == 0)
407 n++;
408 level++;
409 }
410 else if (c == ')') {
411 if (level == 0)
412 break;
413 level--;
414 }
415 else if (c == ':' || c == ';' || c == '\0')
416 break;
Neal Norwitz30b5c5d2005-12-19 06:05:18 +0000417 else if (level == 0 && isalpha(Py_CHARMASK(c)))
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000418 n++;
419 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000420
Christian Heimes72b710a2008-05-26 13:28:38 +0000421 if (!PySequence_Check(arg) || PyBytes_Check(arg)) {
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000422 levels[0] = 0;
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000423 PyOS_snprintf(msgbuf, bufsize,
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000424 toplevel ? "expected %d arguments, not %.50s" :
425 "must be %d-item sequence, not %.50s",
Guido van Rossum98297ee2007-11-06 21:34:58 +0000426 n,
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000427 arg == Py_None ? "None" : arg->ob_type->tp_name);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000428 return msgbuf;
429 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000430
Jeremy Hylton03657cf2000-07-12 13:05:33 +0000431 if ((i = PySequence_Size(arg)) != n) {
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000432 levels[0] = 0;
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000433 PyOS_snprintf(msgbuf, bufsize,
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000434 toplevel ? "expected %d arguments, not %d" :
435 "must be sequence of length %d, not %d",
436 n, i);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000437 return msgbuf;
438 }
Ka-Ping Yee20579702001-01-15 22:14:16 +0000439
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000440 format = *p_format;
441 for (i = 0; i < n; i++) {
442 char *msg;
Guido van Rossum66368cc1999-02-17 23:16:43 +0000443 PyObject *item;
444 item = PySequence_GetItem(arg, i);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000445 if (item == NULL) {
446 PyErr_Clear();
447 levels[0] = i+1;
448 levels[1] = 0;
449 strncpy(msgbuf, "is not retrievable", bufsize);
450 return msgbuf;
451 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000452 msg = convertitem(item, &format, p_va, flags, levels+1,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000453 msgbuf, bufsize, freelist);
Guido van Rossum66368cc1999-02-17 23:16:43 +0000454 /* PySequence_GetItem calls tp->sq_item, which INCREFs */
455 Py_XDECREF(item);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000456 if (msg != NULL) {
457 levels[0] = i+1;
458 return msg;
459 }
460 }
Ka-Ping Yee20579702001-01-15 22:14:16 +0000461
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000462 *p_format = format;
463 return NULL;
464}
465
466
467/* Convert a single item. */
468
469static char *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000470convertitem(PyObject *arg, const char **p_format, va_list *p_va, int flags,
471 int *levels, char *msgbuf, size_t bufsize, PyObject **freelist)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000472{
473 char *msg;
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000474 const char *format = *p_format;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000475
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000476 if (*format == '(' /* ')' */) {
477 format++;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000478 msg = converttuple(arg, &format, p_va, flags, levels, msgbuf,
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000479 bufsize, 0, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000480 if (msg == NULL)
481 format++;
482 }
483 else {
Guido van Rossum98297ee2007-11-06 21:34:58 +0000484 msg = convertsimple(arg, &format, p_va, flags,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000485 msgbuf, bufsize, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000486 if (msg != NULL)
487 levels[0] = 0;
488 }
489 if (msg == NULL)
490 *p_format = format;
491 return msg;
492}
493
494
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000495
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000496#define UNICODE_DEFAULT_ENCODING(arg) \
497 _PyUnicode_AsDefaultEncodedString(arg, NULL)
498
499/* Format an error message generated by convertsimple(). */
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000500
501static char *
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000502converterr(const char *expected, PyObject *arg, char *msgbuf, size_t bufsize)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000503{
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000504 assert(expected != NULL);
Guido van Rossum98297ee2007-11-06 21:34:58 +0000505 assert(arg != NULL);
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000506 PyOS_snprintf(msgbuf, bufsize,
507 "must be %.50s, not %.50s", expected,
508 arg == Py_None ? "None" : arg->ob_type->tp_name);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000509 return msgbuf;
510}
511
512#define CONV_UNICODE "(unicode conversion error)"
513
Guido van Rossum45aecf42006-03-15 04:58:47 +0000514/* Explicitly check for float arguments when integers are expected.
515 Return 1 for error, 0 if ok. */
Neil Schemenauer5042da62003-02-04 20:59:40 +0000516static int
517float_argument_error(PyObject *arg)
518{
Guido van Rossum45aecf42006-03-15 04:58:47 +0000519 if (PyFloat_Check(arg)) {
520 PyErr_SetString(PyExc_TypeError,
521 "integer argument expected, got float" );
Neil Schemenauer5042da62003-02-04 20:59:40 +0000522 return 1;
Guido van Rossum45aecf42006-03-15 04:58:47 +0000523 }
Neil Schemenauer5042da62003-02-04 20:59:40 +0000524 else
525 return 0;
526}
527
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000528/* Convert a non-tuple argument. Return NULL if conversion went OK,
529 or a string with a message describing the failure. The message is
530 formatted as "must be <desired type>, not <actual type>".
531 When failing, an exception may or may not have been raised.
Georg Brandl6dd14612005-09-14 19:29:53 +0000532 Don't call if a tuple is expected.
533
534 When you add new format codes, please don't forget poor skipitem() below.
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000535*/
536
537static char *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000538convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000539 char *msgbuf, size_t bufsize, PyObject **freelist)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000540{
Martin v. Löwis18e16552006-02-15 17:27:45 +0000541 /* For # codes */
542#define FETCH_SIZE int *q=NULL;Py_ssize_t *q2=NULL;\
543 if (flags & FLAG_SIZE_T) q2=va_arg(*p_va, Py_ssize_t*); \
544 else q=va_arg(*p_va, int*);
545#define STORE_SIZE(s) if (flags & FLAG_SIZE_T) *q2=s; else *q=s;
546#define BUFFER_LEN ((flags & FLAG_SIZE_T) ? *q2:*q)
547
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000548 const char *format = *p_format;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000549 char c = *format++;
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000550 PyObject *uarg;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000551
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000552 switch (c) {
Guido van Rossum98297ee2007-11-06 21:34:58 +0000553
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000554 case 'b': { /* unsigned byte -- very short int */
555 char *p = va_arg(*p_va, char *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000556 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000557 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000558 return converterr("integer<b>", arg, msgbuf, bufsize);
Christian Heimes217cfd12007-12-02 14:31:20 +0000559 ival = PyLong_AsLong(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000560 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000561 return converterr("integer<b>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000562 else if (ival < 0) {
563 PyErr_SetString(PyExc_OverflowError,
564 "unsigned byte integer is less than minimum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000565 return converterr("integer<b>", arg, msgbuf, bufsize);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000566 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000567 else if (ival > UCHAR_MAX) {
568 PyErr_SetString(PyExc_OverflowError,
569 "unsigned byte integer is greater than maximum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000570 return converterr("integer<b>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000571 }
572 else
573 *p = (unsigned char) ival;
574 break;
575 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000576
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000577 case 'B': {/* byte sized bitfield - both signed and unsigned
Guido van Rossum98297ee2007-11-06 21:34:58 +0000578 values allowed */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000579 char *p = va_arg(*p_va, char *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000580 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000581 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000582 return converterr("integer<B>", arg, msgbuf, bufsize);
Christian Heimes217cfd12007-12-02 14:31:20 +0000583 ival = PyLong_AsUnsignedLongMask(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000584 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000585 return converterr("integer<B>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000586 else
587 *p = (unsigned char) ival;
588 break;
589 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000590
Guido van Rossumfce26e72003-04-18 00:12:30 +0000591 case 'h': {/* signed short int */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000592 short *p = va_arg(*p_va, short *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000593 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000594 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000595 return converterr("integer<h>", arg, msgbuf, bufsize);
Christian Heimes217cfd12007-12-02 14:31:20 +0000596 ival = PyLong_AsLong(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000597 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000598 return converterr("integer<h>", arg, msgbuf, bufsize);
Guido van Rossumfce26e72003-04-18 00:12:30 +0000599 else if (ival < SHRT_MIN) {
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000600 PyErr_SetString(PyExc_OverflowError,
Guido van Rossumfce26e72003-04-18 00:12:30 +0000601 "signed short integer is less than minimum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000602 return converterr("integer<h>", arg, msgbuf, bufsize);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000603 }
Guido van Rossumfce26e72003-04-18 00:12:30 +0000604 else if (ival > SHRT_MAX) {
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000605 PyErr_SetString(PyExc_OverflowError,
Guido van Rossumfce26e72003-04-18 00:12:30 +0000606 "signed short integer is greater than maximum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000607 return converterr("integer<h>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000608 }
609 else
610 *p = (short) ival;
611 break;
612 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000613
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000614 case 'H': { /* short int sized bitfield, both signed and
Guido van Rossum98297ee2007-11-06 21:34:58 +0000615 unsigned allowed */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000616 unsigned short *p = va_arg(*p_va, unsigned short *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000617 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000618 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000619 return converterr("integer<H>", arg, msgbuf, bufsize);
Christian Heimes217cfd12007-12-02 14:31:20 +0000620 ival = PyLong_AsUnsignedLongMask(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000621 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000622 return converterr("integer<H>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000623 else
624 *p = (unsigned short) ival;
625 break;
626 }
Martin v. Löwis18e16552006-02-15 17:27:45 +0000627
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000628 case 'i': {/* signed int */
629 int *p = va_arg(*p_va, int *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000630 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000631 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000632 return converterr("integer<i>", arg, msgbuf, bufsize);
Christian Heimes217cfd12007-12-02 14:31:20 +0000633 ival = PyLong_AsLong(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000634 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000635 return converterr("integer<i>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000636 else if (ival > INT_MAX) {
637 PyErr_SetString(PyExc_OverflowError,
638 "signed integer is greater than maximum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000639 return converterr("integer<i>", arg, msgbuf, bufsize);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000640 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000641 else if (ival < INT_MIN) {
642 PyErr_SetString(PyExc_OverflowError,
643 "signed integer is less than minimum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000644 return converterr("integer<i>", arg, msgbuf, bufsize);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000645 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000646 else
647 *p = ival;
648 break;
649 }
650
Thomas Hellera4ea6032003-04-17 18:55:45 +0000651 case 'I': { /* int sized bitfield, both signed and
Guido van Rossum98297ee2007-11-06 21:34:58 +0000652 unsigned allowed */
Thomas Hellera4ea6032003-04-17 18:55:45 +0000653 unsigned int *p = va_arg(*p_va, unsigned int *);
654 unsigned int ival;
655 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000656 return converterr("integer<I>", arg, msgbuf, bufsize);
Christian Heimes217cfd12007-12-02 14:31:20 +0000657 ival = (unsigned int)PyLong_AsUnsignedLongMask(arg);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000658 if (ival == (unsigned int)-1 && PyErr_Occurred())
Thomas Hellera4ea6032003-04-17 18:55:45 +0000659 return converterr("integer<I>", arg, msgbuf, bufsize);
660 else
661 *p = ival;
662 break;
663 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000664
Martin v. Löwis18e16552006-02-15 17:27:45 +0000665 case 'n': /* Py_ssize_t */
Martin v. Löwis18e16552006-02-15 17:27:45 +0000666 {
Neal Norwitzb879f572007-08-31 05:20:36 +0000667 PyObject *iobj;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000668 Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *);
Neal Norwitzb879f572007-08-31 05:20:36 +0000669 Py_ssize_t ival = -1;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000670 if (float_argument_error(arg))
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000671 return converterr("integer<n>", arg, msgbuf, bufsize);
Neal Norwitzb879f572007-08-31 05:20:36 +0000672 iobj = PyNumber_Index(arg);
Christian Heimesbcd2c082008-05-08 01:20:25 +0000673 if (iobj != NULL) {
Trent Nelson35133582008-04-22 19:02:40 +0000674 ival = PyLong_AsSsize_t(iobj);
Christian Heimesbcd2c082008-05-08 01:20:25 +0000675 Py_DECREF(iobj);
676 }
Martin v. Löwis18e16552006-02-15 17:27:45 +0000677 if (ival == -1 && PyErr_Occurred())
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000678 return converterr("integer<n>", arg, msgbuf, bufsize);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000679 *p = ival;
680 break;
681 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000682 case 'l': {/* long int */
683 long *p = va_arg(*p_va, long *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000684 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000685 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000686 return converterr("integer<l>", arg, msgbuf, bufsize);
Christian Heimes217cfd12007-12-02 14:31:20 +0000687 ival = PyLong_AsLong(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000688 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000689 return converterr("integer<l>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000690 else
691 *p = ival;
692 break;
693 }
Thomas Hellera4ea6032003-04-17 18:55:45 +0000694
695 case 'k': { /* long sized bitfield */
696 unsigned long *p = va_arg(*p_va, unsigned long *);
697 unsigned long ival;
Georg Brandle1a0d112007-10-23 19:24:22 +0000698 if (PyLong_Check(arg))
Thomas Hellera4ea6032003-04-17 18:55:45 +0000699 ival = PyLong_AsUnsignedLongMask(arg);
700 else
701 return converterr("integer<k>", arg, msgbuf, bufsize);
702 *p = ival;
703 break;
704 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000705
Guido van Rossum3dbba6e1999-01-25 21:48:56 +0000706#ifdef HAVE_LONG_LONG
Martin v. Löwisb9a0f912003-03-29 10:06:18 +0000707 case 'L': {/* PY_LONG_LONG */
708 PY_LONG_LONG *p = va_arg( *p_va, PY_LONG_LONG * );
709 PY_LONG_LONG ival = PyLong_AsLongLong( arg );
Christian Heimes836baa52008-02-26 08:18:30 +0000710 if (ival == (PY_LONG_LONG)-1 && PyErr_Occurred() ) {
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000711 return converterr("long<L>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000712 } else {
713 *p = ival;
Guido van Rossum1a8791e1998-08-04 22:46:29 +0000714 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000715 break;
716 }
Thomas Hellera4ea6032003-04-17 18:55:45 +0000717
718 case 'K': { /* long long sized bitfield */
719 unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *);
720 unsigned PY_LONG_LONG ival;
Guido van Rossumddefaf32007-01-14 03:31:43 +0000721 if (PyLong_Check(arg))
Thomas Hellera4ea6032003-04-17 18:55:45 +0000722 ival = PyLong_AsUnsignedLongLongMask(arg);
723 else
724 return converterr("integer<K>", arg, msgbuf, bufsize);
725 *p = ival;
726 break;
727 }
Guido van Rossum1a8791e1998-08-04 22:46:29 +0000728#endif
Guido van Rossum98297ee2007-11-06 21:34:58 +0000729
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000730 case 'f': {/* float */
731 float *p = va_arg(*p_va, float *);
732 double dval = PyFloat_AsDouble(arg);
733 if (PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000734 return converterr("float<f>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000735 else
736 *p = (float) dval;
737 break;
738 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000739
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000740 case 'd': {/* double */
741 double *p = va_arg(*p_va, double *);
742 double dval = PyFloat_AsDouble(arg);
743 if (PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000744 return converterr("float<d>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000745 else
746 *p = dval;
747 break;
748 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000749
Guido van Rossum530956d1996-07-21 02:27:43 +0000750#ifndef WITHOUT_COMPLEX
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000751 case 'D': {/* complex double */
752 Py_complex *p = va_arg(*p_va, Py_complex *);
753 Py_complex cval;
754 cval = PyComplex_AsCComplex(arg);
755 if (PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000756 return converterr("complex<D>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000757 else
758 *p = cval;
759 break;
760 }
Guido van Rossum530956d1996-07-21 02:27:43 +0000761#endif /* WITHOUT_COMPLEX */
Guido van Rossum98297ee2007-11-06 21:34:58 +0000762
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000763 case 'c': {/* char */
Walter Dörwaldd0941302007-07-01 21:58:22 +0000764 char *p = va_arg(*p_va, char *);
Christian Heimes72b710a2008-05-26 13:28:38 +0000765 if (PyBytes_Check(arg) && PyBytes_Size(arg) == 1)
766 *p = PyBytes_AS_STRING(arg)[0];
Walter Dörwaldd0941302007-07-01 21:58:22 +0000767 else if (PyUnicode_Check(arg) &&
768 PyUnicode_GET_SIZE(arg) == 1 &&
769 PyUnicode_AS_UNICODE(arg)[0] < 256)
Amaury Forgeot d'Arc39599dc2007-11-22 02:48:12 +0000770 *p = (char)PyUnicode_AS_UNICODE(arg)[0];
Walter Dörwaldd0941302007-07-01 21:58:22 +0000771 else
772 return converterr("char < 256", arg, msgbuf, bufsize);
773 break;
774 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000775
Walter Dörwaldd0941302007-07-01 21:58:22 +0000776 case 'C': {/* unicode char */
Walter Dörwaldbc1f8862007-06-20 11:02:38 +0000777 int *p = va_arg(*p_va, int *);
Christian Heimes72b710a2008-05-26 13:28:38 +0000778 if (PyBytes_Check(arg) && PyBytes_Size(arg) == 1)
779 *p = PyBytes_AS_STRING(arg)[0];
Guido van Rossum09dc34f2007-05-04 04:17:33 +0000780 else if (PyUnicode_Check(arg) &&
Walter Dörwaldbc1f8862007-06-20 11:02:38 +0000781 PyUnicode_GET_SIZE(arg) == 1)
Guido van Rossum09dc34f2007-05-04 04:17:33 +0000782 *p = PyUnicode_AS_UNICODE(arg)[0];
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000783 else
Walter Dörwaldbc1f8862007-06-20 11:02:38 +0000784 return converterr("char", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000785 break;
786 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000787
788 /* XXX WAAAAH! 's', 'y', 'z', 'u', 'Z', 'e', 'w', 't' codes all
789 need to be cleaned up! */
790
791 case 's': {/* text string */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000792 if (*format == '#') {
793 void **p = (void **)va_arg(*p_va, char **);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000794 FETCH_SIZE;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000795
796 if (PyUnicode_Check(arg)) {
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000797 uarg = UNICODE_DEFAULT_ENCODING(arg);
798 if (uarg == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000799 return converterr(CONV_UNICODE,
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000800 arg, msgbuf, bufsize);
Christian Heimes72b710a2008-05-26 13:28:38 +0000801 *p = PyBytes_AS_STRING(uarg);
802 STORE_SIZE(PyBytes_GET_SIZE(uarg));
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000803 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000804 else { /* any buffer-like object */
Guido van Rossum98297ee2007-11-06 21:34:58 +0000805 /* XXX Really? */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000806 char *buf;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000807 Py_ssize_t count = convertbuffer(arg, p, &buf);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000808 if (count < 0)
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000809 return converterr(buf, arg, msgbuf, bufsize);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000810 STORE_SIZE(count);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000811 }
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000812 format++;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000813 } else {
814 char **p = va_arg(*p_va, char **);
Guido van Rossum98297ee2007-11-06 21:34:58 +0000815
816 if (PyUnicode_Check(arg)) {
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000817 uarg = UNICODE_DEFAULT_ENCODING(arg);
818 if (uarg == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000819 return converterr(CONV_UNICODE,
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000820 arg, msgbuf, bufsize);
Christian Heimes72b710a2008-05-26 13:28:38 +0000821 *p = PyBytes_AS_STRING(uarg);
Marc-André Lemburg6f15e572001-05-02 17:16:16 +0000822 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000823 else
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000824 return converterr("string", arg, msgbuf, bufsize);
Christian Heimes72b710a2008-05-26 13:28:38 +0000825 if ((Py_ssize_t) strlen(*p) != PyBytes_GET_SIZE(uarg))
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000826 return converterr("string without null bytes",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000827 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000828 }
829 break;
830 }
831
Guido van Rossum98297ee2007-11-06 21:34:58 +0000832 case 'y': {/* any buffer-like object, but not PyUnicode */
833 void **p = (void **)va_arg(*p_va, char **);
834 char *buf;
835 Py_ssize_t count = convertbuffer(arg, p, &buf);
836 if (count < 0)
837 return converterr(buf, arg, msgbuf, bufsize);
Walter Dörwald612344f2007-05-04 19:28:21 +0000838 if (*format == '#') {
Walter Dörwald612344f2007-05-04 19:28:21 +0000839 FETCH_SIZE;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000840 STORE_SIZE(count);
Walter Dörwald612344f2007-05-04 19:28:21 +0000841 format++;
Walter Dörwald612344f2007-05-04 19:28:21 +0000842 }
843 break;
844 }
845
Guido van Rossum98297ee2007-11-06 21:34:58 +0000846 case 'z': {/* like 's' or 's#', but None is okay, stored as NULL */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000847 if (*format == '#') { /* any buffer-like object */
848 void **p = (void **)va_arg(*p_va, char **);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000849 FETCH_SIZE;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000850
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000851 if (arg == Py_None) {
852 *p = 0;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000853 STORE_SIZE(0);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000854 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000855 else if (PyUnicode_Check(arg)) {
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000856 uarg = UNICODE_DEFAULT_ENCODING(arg);
857 if (uarg == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000858 return converterr(CONV_UNICODE,
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000859 arg, msgbuf, bufsize);
Christian Heimes72b710a2008-05-26 13:28:38 +0000860 *p = PyBytes_AS_STRING(uarg);
861 STORE_SIZE(PyBytes_GET_SIZE(uarg));
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000862 }
863 else { /* any buffer-like object */
Guido van Rossum98297ee2007-11-06 21:34:58 +0000864 /* XXX Really? */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000865 char *buf;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000866 Py_ssize_t count = convertbuffer(arg, p, &buf);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000867 if (count < 0)
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000868 return converterr(buf, arg, msgbuf, bufsize);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000869 STORE_SIZE(count);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000870 }
871 format++;
872 } else {
873 char **p = va_arg(*p_va, char **);
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +0000874 uarg = NULL;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000875
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000876 if (arg == Py_None)
877 *p = 0;
Christian Heimes72b710a2008-05-26 13:28:38 +0000878 else if (PyBytes_Check(arg)) {
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +0000879 /* Enable null byte check below */
880 uarg = arg;
Christian Heimes72b710a2008-05-26 13:28:38 +0000881 *p = PyBytes_AS_STRING(arg);
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +0000882 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000883 else if (PyUnicode_Check(arg)) {
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000884 uarg = UNICODE_DEFAULT_ENCODING(arg);
885 if (uarg == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000886 return converterr(CONV_UNICODE,
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000887 arg, msgbuf, bufsize);
Christian Heimes72b710a2008-05-26 13:28:38 +0000888 *p = PyBytes_AS_STRING(uarg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000889 }
890 else
Guido van Rossum98297ee2007-11-06 21:34:58 +0000891 return converterr("string or None",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000892 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000893 if (*format == '#') {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000894 FETCH_SIZE;
Thomas Woutersc3547a32006-03-01 21:31:21 +0000895 assert(0); /* XXX redundant with if-case */
Guido van Rossum98297ee2007-11-06 21:34:58 +0000896 if (arg == Py_None) {
897 STORE_SIZE(0);
898 }
899 else {
Christian Heimes72b710a2008-05-26 13:28:38 +0000900 STORE_SIZE(PyBytes_Size(arg));
Guido van Rossum98297ee2007-11-06 21:34:58 +0000901 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000902 format++;
903 }
Amaury Forgeot d'Arc07404592008-05-12 13:19:07 +0000904 else if (*p != NULL && uarg != NULL &&
Christian Heimes72b710a2008-05-26 13:28:38 +0000905 (Py_ssize_t) strlen(*p) != PyBytes_GET_SIZE(uarg))
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000906 return converterr(
Guido van Rossum98297ee2007-11-06 21:34:58 +0000907 "string without null bytes or None",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000908 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000909 }
910 break;
911 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000912
Guido van Rossumfb67be22007-08-29 18:38:11 +0000913 case 'Z': {/* unicode, may be NULL (None) */
914 if (*format == '#') { /* any buffer-like object */
915 Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
916 FETCH_SIZE;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000917
Guido van Rossumfb67be22007-08-29 18:38:11 +0000918 if (arg == Py_None) {
919 *p = 0;
920 STORE_SIZE(0);
921 }
922 else if (PyUnicode_Check(arg)) {
923 *p = PyUnicode_AS_UNICODE(arg);
924 STORE_SIZE(PyUnicode_GET_SIZE(arg));
925 }
926 format++;
927 } else {
928 Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
Guido van Rossum98297ee2007-11-06 21:34:58 +0000929
Guido van Rossumfb67be22007-08-29 18:38:11 +0000930 if (arg == Py_None)
931 *p = 0;
932 else if (PyUnicode_Check(arg))
933 *p = PyUnicode_AS_UNICODE(arg);
934 else
Guido van Rossum98297ee2007-11-06 21:34:58 +0000935 return converterr("string or None",
Guido van Rossumfb67be22007-08-29 18:38:11 +0000936 arg, msgbuf, bufsize);
937 }
938 break;
939 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000940
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000941 case 'e': {/* encoded string */
942 char **buffer;
943 const char *encoding;
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000944 PyObject *s;
Guido van Rossumf15a29f2007-05-04 00:41:39 +0000945 int recode_strings;
946 Py_ssize_t size;
Guido van Rossumd70539a2007-05-09 23:35:09 +0000947 const char *ptr;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000948
949 /* Get 'e' parameter: the encoding name */
950 encoding = (const char *)va_arg(*p_va, const char *);
951 if (encoding == NULL)
952 encoding = PyUnicode_GetDefaultEncoding();
Guido van Rossum98297ee2007-11-06 21:34:58 +0000953
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000954 /* Get output buffer parameter:
955 's' (recode all objects via Unicode) or
Guido van Rossum98297ee2007-11-06 21:34:58 +0000956 't' (only recode non-string objects)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000957 */
958 if (*format == 's')
959 recode_strings = 1;
960 else if (*format == 't')
961 recode_strings = 0;
962 else
963 return converterr(
964 "(unknown parser marker combination)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000965 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000966 buffer = (char **)va_arg(*p_va, char **);
967 format++;
968 if (buffer == NULL)
Guido van Rossum98297ee2007-11-06 21:34:58 +0000969 return converterr("(buffer is NULL)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000970 arg, msgbuf, bufsize);
Guido van Rossum98297ee2007-11-06 21:34:58 +0000971
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000972 /* Encode object */
Guido van Rossumd70539a2007-05-09 23:35:09 +0000973 if (!recode_strings &&
Christian Heimes72b710a2008-05-26 13:28:38 +0000974 (PyBytes_Check(arg) || PyByteArray_Check(arg))) {
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000975 s = arg;
976 Py_INCREF(s);
Guido van Rossumd70539a2007-05-09 23:35:09 +0000977 if (PyObject_AsCharBuffer(s, &ptr, &size) < 0)
978 return converterr("(AsCharBuffer failed)",
979 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000980 }
981 else {
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000982 PyObject *u;
983
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000984 /* Convert object to Unicode */
985 u = PyUnicode_FromObject(arg);
986 if (u == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000987 return converterr(
Guido van Rossum98297ee2007-11-06 21:34:58 +0000988 "string or unicode or text buffer",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000989 arg, msgbuf, bufsize);
Guido van Rossum98297ee2007-11-06 21:34:58 +0000990
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000991 /* Encode object; use default error handling */
992 s = PyUnicode_AsEncodedString(u,
993 encoding,
994 NULL);
995 Py_DECREF(u);
996 if (s == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000997 return converterr("(encoding failed)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000998 arg, msgbuf, bufsize);
Christian Heimes72b710a2008-05-26 13:28:38 +0000999 if (!PyBytes_Check(s)) {
Guido van Rossumd8855fd2000-03-24 22:14:19 +00001000 Py_DECREF(s);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001001 return converterr(
Guido van Rossumf15a29f2007-05-04 00:41:39 +00001002 "(encoder failed to return bytes)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001003 arg, msgbuf, bufsize);
Guido van Rossumd8855fd2000-03-24 22:14:19 +00001004 }
Christian Heimes72b710a2008-05-26 13:28:38 +00001005 size = PyBytes_GET_SIZE(s);
1006 ptr = PyBytes_AS_STRING(s);
Guido van Rossumd70539a2007-05-09 23:35:09 +00001007 if (ptr == NULL)
1008 ptr = "";
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001009 }
Guido van Rossumd8855fd2000-03-24 22:14:19 +00001010
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001011 /* Write output; output is guaranteed to be 0-terminated */
Guido van Rossum98297ee2007-11-06 21:34:58 +00001012 if (*format == '#') {
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001013 /* Using buffer length parameter '#':
Guido van Rossum98297ee2007-11-06 21:34:58 +00001014
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001015 - if *buffer is NULL, a new buffer of the
1016 needed size is allocated and the data
1017 copied into it; *buffer is updated to point
1018 to the new buffer; the caller is
1019 responsible for PyMem_Free()ing it after
Guido van Rossum98297ee2007-11-06 21:34:58 +00001020 usage
Guido van Rossumd8855fd2000-03-24 22:14:19 +00001021
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001022 - if *buffer is not NULL, the data is
1023 copied to *buffer; *buffer_len has to be
1024 set to the size of the buffer on input;
1025 buffer overflow is signalled with an error;
1026 buffer has to provide enough room for the
1027 encoded string plus the trailing 0-byte
Guido van Rossum98297ee2007-11-06 21:34:58 +00001028
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001029 - in both cases, *buffer_len is updated to
1030 the size of the buffer /excluding/ the
Guido van Rossum98297ee2007-11-06 21:34:58 +00001031 trailing 0-byte
1032
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001033 */
Martin v. Löwis18e16552006-02-15 17:27:45 +00001034 FETCH_SIZE;
Guido van Rossumd8855fd2000-03-24 22:14:19 +00001035
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001036 format++;
Martin v. Löwis18e16552006-02-15 17:27:45 +00001037 if (q == NULL && q2 == NULL) {
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001038 Py_DECREF(s);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001039 return converterr(
1040 "(buffer_len is NULL)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001041 arg, msgbuf, bufsize);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001042 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001043 if (*buffer == NULL) {
Guido van Rossumd8855fd2000-03-24 22:14:19 +00001044 *buffer = PyMem_NEW(char, size + 1);
1045 if (*buffer == NULL) {
1046 Py_DECREF(s);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001047 return converterr(
1048 "(memory error)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001049 arg, msgbuf, bufsize);
Guido van Rossumd8855fd2000-03-24 22:14:19 +00001050 }
Christian Heimes836baa52008-02-26 08:18:30 +00001051 if (addcleanup(*buffer, freelist)) {
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001052 Py_DECREF(s);
1053 return converterr(
1054 "(cleanup problem)",
1055 arg, msgbuf, bufsize);
1056 }
Fred Drake25871c02000-05-03 15:17:02 +00001057 } else {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001058 if (size + 1 > BUFFER_LEN) {
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001059 Py_DECREF(s);
1060 return converterr(
Guido van Rossum98297ee2007-11-06 21:34:58 +00001061 "(buffer overflow)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001062 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001063 }
Fred Drake25871c02000-05-03 15:17:02 +00001064 }
Guido van Rossumf15a29f2007-05-04 00:41:39 +00001065 memcpy(*buffer, ptr, size+1);
Martin v. Löwis18e16552006-02-15 17:27:45 +00001066 STORE_SIZE(size);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001067 } else {
1068 /* Using a 0-terminated buffer:
Guido van Rossum98297ee2007-11-06 21:34:58 +00001069
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001070 - the encoded string has to be 0-terminated
1071 for this variant to work; if it is not, an
Guido van Rossum98297ee2007-11-06 21:34:58 +00001072 error raised
Fred Drake25871c02000-05-03 15:17:02 +00001073
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001074 - a new buffer of the needed size is
1075 allocated and the data copied into it;
1076 *buffer is updated to point to the new
1077 buffer; the caller is responsible for
1078 PyMem_Free()ing it after usage
1079
1080 */
Guido van Rossumf15a29f2007-05-04 00:41:39 +00001081 if ((Py_ssize_t)strlen(ptr) != size) {
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001082 Py_DECREF(s);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001083 return converterr(
1084 "(encoded string without NULL bytes)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001085 arg, msgbuf, bufsize);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001086 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001087 *buffer = PyMem_NEW(char, size + 1);
1088 if (*buffer == NULL) {
1089 Py_DECREF(s);
1090 return converterr("(memory error)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001091 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001092 }
Christian Heimes836baa52008-02-26 08:18:30 +00001093 if (addcleanup(*buffer, freelist)) {
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001094 Py_DECREF(s);
1095 return converterr("(cleanup problem)",
1096 arg, msgbuf, bufsize);
1097 }
Guido van Rossumf15a29f2007-05-04 00:41:39 +00001098 memcpy(*buffer, ptr, size+1);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00001099 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001100 Py_DECREF(s);
1101 break;
1102 }
1103
1104 case 'u': {/* raw unicode buffer (Py_UNICODE *) */
Guido van Rossum98297ee2007-11-06 21:34:58 +00001105 Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
1106 if (!PyUnicode_Check(arg))
1107 return converterr("str", arg, msgbuf, bufsize);
1108 *p = PyUnicode_AS_UNICODE(arg);
1109 if (*format == '#') { /* store pointer and size */
Martin v. Löwis18e16552006-02-15 17:27:45 +00001110 FETCH_SIZE;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001111 STORE_SIZE(PyUnicode_GET_SIZE(arg));
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001112 format++;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001113 }
1114 break;
1115 }
1116
Christian Heimes72b710a2008-05-26 13:28:38 +00001117 case 'S': { /* PyBytes object */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001118 PyObject **p = va_arg(*p_va, PyObject **);
Christian Heimes72b710a2008-05-26 13:28:38 +00001119 if (PyBytes_Check(arg))
Guido van Rossum617dbc42007-05-07 23:57:08 +00001120 *p = arg;
1121 else
1122 return converterr("bytes", arg, msgbuf, bufsize);
1123 break;
1124 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001125
Christian Heimes9c4756e2008-05-26 13:22:05 +00001126 case 'Y': { /* PyByteArray object */
Guido van Rossum98297ee2007-11-06 21:34:58 +00001127 PyObject **p = va_arg(*p_va, PyObject **);
Christian Heimes9c4756e2008-05-26 13:22:05 +00001128 if (PyByteArray_Check(arg))
Guido van Rossum98297ee2007-11-06 21:34:58 +00001129 *p = arg;
1130 else
1131 return converterr("buffer", arg, msgbuf, bufsize);
1132 break;
1133 }
1134
1135 case 'U': { /* PyUnicode object */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001136 PyObject **p = va_arg(*p_va, PyObject **);
1137 if (PyUnicode_Check(arg))
1138 *p = arg;
1139 else
Guido van Rossum98297ee2007-11-06 21:34:58 +00001140 return converterr("str", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001141 break;
1142 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001143
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001144 case 'O': { /* object */
1145 PyTypeObject *type;
1146 PyObject **p;
1147 if (*format == '!') {
1148 type = va_arg(*p_va, PyTypeObject*);
1149 p = va_arg(*p_va, PyObject **);
1150 format++;
Guido van Rossumcbfc8552001-08-28 16:37:51 +00001151 if (PyType_IsSubtype(arg->ob_type, type))
Guido van Rossume826ef02000-03-10 23:02:17 +00001152 *p = arg;
1153 else
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001154 return converterr(type->tp_name, arg, msgbuf, bufsize);
Guido van Rossumfccfe891998-05-15 22:04:07 +00001155
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001156 }
1157 else if (*format == '?') {
1158 inquiry pred = va_arg(*p_va, inquiry);
1159 p = va_arg(*p_va, PyObject **);
1160 format++;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001161 if ((*pred)(arg))
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00001162 *p = arg;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001163 else
Guido van Rossum98297ee2007-11-06 21:34:58 +00001164 return converterr("(unspecified)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001165 arg, msgbuf, bufsize);
Guido van Rossum98297ee2007-11-06 21:34:58 +00001166
Guido van Rossumfdf95dd1997-05-05 22:15:02 +00001167 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001168 else if (*format == '&') {
1169 typedef int (*converter)(PyObject *, void *);
1170 converter convert = va_arg(*p_va, converter);
1171 void *addr = va_arg(*p_va, void *);
1172 format++;
1173 if (! (*convert)(arg, addr))
Guido van Rossum98297ee2007-11-06 21:34:58 +00001174 return converterr("(unspecified)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001175 arg, msgbuf, bufsize);
Guido van Rossumb317f8a1998-10-08 02:21:21 +00001176 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001177 else {
1178 p = va_arg(*p_va, PyObject **);
1179 *p = arg;
1180 }
1181 break;
1182 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001183
1184
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001185 case 'w': { /* memory buffer, read-write access */
1186 void **p = va_arg(*p_va, void **);
1187 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
Christian Heimes4e30a842007-11-30 22:12:06 +00001188 Py_ssize_t count;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001189 int temp=-1;
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +00001190 Py_buffer view;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001191
1192 if (pb == NULL ||
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001193 pb->bf_getbuffer == NULL ||
Guido van Rossum98297ee2007-11-06 21:34:58 +00001194 ((temp = (*pb->bf_getbuffer)(arg, &view,
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001195 PyBUF_SIMPLE)) != 0) ||
1196 view.readonly == 1) {
1197 if (temp==0 && pb->bf_releasebuffer != NULL) {
1198 (*pb->bf_releasebuffer)(arg, &view);
1199 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001200 return converterr("single-segment read-write buffer",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001201 arg, msgbuf, bufsize);
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001202 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001203
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001204 if ((count = view.len) < 0)
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001205 return converterr("(unspecified)", arg, msgbuf, bufsize);
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001206 *p = view.buf;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001207 if (*format == '#') {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001208 FETCH_SIZE;
1209 STORE_SIZE(count);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001210 format++;
1211 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001212 if (pb->bf_releasebuffer != NULL)
1213 (*pb->bf_releasebuffer)(arg, &view);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001214 break;
1215 }
Travis E. Oliphantddacf962007-10-13 21:03:27 +00001216
1217 /*TEO: This can be eliminated --- here only for backward
1218 compatibility */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001219 case 't': { /* 8-bit character buffer, read-only access */
Martin v. Löwis15e62742006-02-27 16:46:16 +00001220 char **p = va_arg(*p_va, char **);
Jeremy Hylton4819e972001-10-11 14:40:37 +00001221 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
Christian Heimes4e30a842007-11-30 22:12:06 +00001222 Py_ssize_t count;
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +00001223 Py_buffer view;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001224
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001225 if (*format++ != '#')
1226 return converterr(
Guido van Rossum98297ee2007-11-06 21:34:58 +00001227 "invalid use of 't' format character",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001228 arg, msgbuf, bufsize);
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001229 if (pb == NULL || pb->bf_getbuffer == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001230 return converterr(
Alexandre Vassalotti70a23712007-10-14 02:05:51 +00001231 "bytes or read-only character buffer",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001232 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001233
Guido van Rossum98297ee2007-11-06 21:34:58 +00001234 if ((*pb->bf_getbuffer)(arg, &view, PyBUF_SIMPLE) != 0)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001235 return converterr("string or single-segment read-only buffer",
1236 arg, msgbuf, bufsize);
Jeremy Hylton4819e972001-10-11 14:40:37 +00001237
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001238 count = view.len;
1239 *p = view.buf;
1240 /* XXX : shouldn't really release buffer, but it should be O.K.
1241 */
Guido van Rossum98297ee2007-11-06 21:34:58 +00001242 if (pb->bf_releasebuffer != NULL)
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001243 (*pb->bf_releasebuffer)(arg, &view);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001244 if (count < 0)
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001245 return converterr("(unspecified)", arg, msgbuf, bufsize);
Martin v. Löwis18e16552006-02-15 17:27:45 +00001246 {
1247 FETCH_SIZE;
1248 STORE_SIZE(count);
1249 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001250 break;
1251 }
1252
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00001253 default:
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001254 return converterr("impossible<bad format char>", arg, msgbuf, bufsize);
Guido van Rossum98297ee2007-11-06 21:34:58 +00001255
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00001256 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001257
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00001258 *p_format = format;
1259 return NULL;
1260}
Guido van Rossumaa354651996-08-19 19:32:04 +00001261
Martin v. Löwis18e16552006-02-15 17:27:45 +00001262static Py_ssize_t
Fred Drake563dfc22001-10-23 14:41:08 +00001263convertbuffer(PyObject *arg, void **p, char **errmsg)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001264{
1265 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
Martin v. Löwis18e16552006-02-15 17:27:45 +00001266 Py_ssize_t count;
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +00001267 Py_buffer view;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001268
1269 *errmsg = NULL;
1270 *p = NULL;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001271 if (pb == NULL ||
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001272 pb->bf_getbuffer == NULL) {
Guido van Rossumb0834002007-11-21 21:53:51 +00001273 *errmsg = "bytes or read-only buffer";
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001274 return -1;
1275 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001276
1277 if ((*pb->bf_getbuffer)(arg, &view, PyBUF_SIMPLE) != 0) {
Guido van Rossumb0834002007-11-21 21:53:51 +00001278 *errmsg = "bytes or single-segment read-only buffer";
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001279 return -1;
1280 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001281 count = view.len;
1282 *p = view.buf;
1283 if (pb->bf_releasebuffer != NULL)
1284 (*pb->bf_releasebuffer)(arg, &view);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001285 return count;
1286}
Guido van Rossumaa354651996-08-19 19:32:04 +00001287
1288/* Support for keyword arguments donated by
1289 Geoff Philbrick <philbric@delphi.hks.com> */
1290
Tim Petersf8cd3e82001-10-27 04:26:57 +00001291/* Return false (0) for error, else true. */
Fred Drake563dfc22001-10-23 14:41:08 +00001292int
1293PyArg_ParseTupleAndKeywords(PyObject *args,
1294 PyObject *keywords,
Guido van Rossum98297ee2007-11-06 21:34:58 +00001295 const char *format,
Martin v. Löwis15e62742006-02-27 16:46:16 +00001296 char **kwlist, ...)
Guido van Rossumaa354651996-08-19 19:32:04 +00001297{
1298 int retval;
1299 va_list va;
Tim Peters45772cd2001-10-27 03:58:40 +00001300
1301 if ((args == NULL || !PyTuple_Check(args)) ||
1302 (keywords != NULL && !PyDict_Check(keywords)) ||
1303 format == NULL ||
1304 kwlist == NULL)
1305 {
1306 PyErr_BadInternalCall();
Tim Petersf8cd3e82001-10-27 04:26:57 +00001307 return 0;
Tim Peters45772cd2001-10-27 03:58:40 +00001308 }
1309
Guido van Rossumaa354651996-08-19 19:32:04 +00001310 va_start(va, kwlist);
Guido van Rossum98297ee2007-11-06 21:34:58 +00001311 retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0);
Martin v. Löwis18e16552006-02-15 17:27:45 +00001312 va_end(va);
1313 return retval;
1314}
1315
1316int
1317_PyArg_ParseTupleAndKeywords_SizeT(PyObject *args,
1318 PyObject *keywords,
Guido van Rossum98297ee2007-11-06 21:34:58 +00001319 const char *format,
Martin v. Löwis15e62742006-02-27 16:46:16 +00001320 char **kwlist, ...)
Martin v. Löwis18e16552006-02-15 17:27:45 +00001321{
1322 int retval;
1323 va_list va;
1324
1325 if ((args == NULL || !PyTuple_Check(args)) ||
1326 (keywords != NULL && !PyDict_Check(keywords)) ||
1327 format == NULL ||
1328 kwlist == NULL)
1329 {
1330 PyErr_BadInternalCall();
1331 return 0;
1332 }
1333
1334 va_start(va, kwlist);
Guido van Rossum98297ee2007-11-06 21:34:58 +00001335 retval = vgetargskeywords(args, keywords, format,
Martin v. Löwis18e16552006-02-15 17:27:45 +00001336 kwlist, &va, FLAG_SIZE_T);
Guido van Rossumaa354651996-08-19 19:32:04 +00001337 va_end(va);
1338 return retval;
1339}
1340
1341
Brett Cannon711e7d92004-07-10 22:20:32 +00001342int
1343PyArg_VaParseTupleAndKeywords(PyObject *args,
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001344 PyObject *keywords,
Guido van Rossum98297ee2007-11-06 21:34:58 +00001345 const char *format,
Martin v. Löwis15e62742006-02-27 16:46:16 +00001346 char **kwlist, va_list va)
Brett Cannon711e7d92004-07-10 22:20:32 +00001347{
1348 int retval;
1349 va_list lva;
1350
1351 if ((args == NULL || !PyTuple_Check(args)) ||
1352 (keywords != NULL && !PyDict_Check(keywords)) ||
1353 format == NULL ||
1354 kwlist == NULL)
1355 {
1356 PyErr_BadInternalCall();
1357 return 0;
1358 }
1359
1360#ifdef VA_LIST_IS_ARRAY
1361 memcpy(lva, va, sizeof(va_list));
1362#else
1363#ifdef __va_copy
1364 __va_copy(lva, va);
1365#else
1366 lva = va;
1367#endif
1368#endif
1369
Guido van Rossum98297ee2007-11-06 21:34:58 +00001370 retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0);
Martin v. Löwis18e16552006-02-15 17:27:45 +00001371 return retval;
1372}
1373
1374int
1375_PyArg_VaParseTupleAndKeywords_SizeT(PyObject *args,
1376 PyObject *keywords,
Guido van Rossum98297ee2007-11-06 21:34:58 +00001377 const char *format,
Martin v. Löwis15e62742006-02-27 16:46:16 +00001378 char **kwlist, va_list va)
Martin v. Löwis18e16552006-02-15 17:27:45 +00001379{
1380 int retval;
1381 va_list lva;
1382
1383 if ((args == NULL || !PyTuple_Check(args)) ||
1384 (keywords != NULL && !PyDict_Check(keywords)) ||
1385 format == NULL ||
1386 kwlist == NULL)
1387 {
1388 PyErr_BadInternalCall();
1389 return 0;
1390 }
1391
1392#ifdef VA_LIST_IS_ARRAY
1393 memcpy(lva, va, sizeof(va_list));
1394#else
1395#ifdef __va_copy
1396 __va_copy(lva, va);
1397#else
1398 lva = va;
1399#endif
1400#endif
1401
Guido van Rossum98297ee2007-11-06 21:34:58 +00001402 retval = vgetargskeywords(args, keywords, format,
Martin v. Löwis18e16552006-02-15 17:27:45 +00001403 kwlist, &lva, FLAG_SIZE_T);
Brett Cannon711e7d92004-07-10 22:20:32 +00001404 return retval;
1405}
1406
Christian Heimes380f7f22008-02-28 11:19:05 +00001407#define IS_END_OF_FORMAT(c) (c == '\0' || c == ';' || c == ':')
Brett Cannon711e7d92004-07-10 22:20:32 +00001408
Guido van Rossumaa354651996-08-19 19:32:04 +00001409static int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001410vgetargskeywords(PyObject *args, PyObject *keywords, const char *format,
Martin v. Löwis15e62742006-02-27 16:46:16 +00001411 char **kwlist, va_list *p_va, int flags)
Guido van Rossumaa354651996-08-19 19:32:04 +00001412{
Tim Petersdc5eff92001-10-27 06:53:00 +00001413 char msgbuf[512];
Guido van Rossumaa354651996-08-19 19:32:04 +00001414 int levels[32];
Christian Heimes380f7f22008-02-28 11:19:05 +00001415 const char *fname, *msg, *custom_msg, *keyword;
1416 int min = INT_MAX;
Tim Petersb639d492001-10-27 07:00:56 +00001417 int i, len, nargs, nkeywords;
Christian Heimes380f7f22008-02-28 11:19:05 +00001418 PyObject *freelist = NULL, *current_arg;
Tim Petersf4331c12001-10-27 00:17:34 +00001419
Tim Peters45772cd2001-10-27 03:58:40 +00001420 assert(args != NULL && PyTuple_Check(args));
1421 assert(keywords == NULL || PyDict_Check(keywords));
1422 assert(format != NULL);
1423 assert(kwlist != NULL);
1424 assert(p_va != NULL);
1425
Christian Heimes380f7f22008-02-28 11:19:05 +00001426 /* grab the function name or custom error msg first (mutually exclusive) */
1427 fname = strchr(format, ':');
1428 if (fname) {
1429 fname++;
1430 custom_msg = NULL;
Tim Peters62d48e12001-10-27 06:42:16 +00001431 }
Christian Heimes380f7f22008-02-28 11:19:05 +00001432 else {
1433 custom_msg = strchr(format,';');
1434 if (custom_msg)
1435 custom_msg++;
Tim Peters62d48e12001-10-27 06:42:16 +00001436 }
Christian Heimes380f7f22008-02-28 11:19:05 +00001437
1438 /* scan kwlist and get greatest possible nbr of args */
1439 for (len=0; kwlist[len]; len++)
1440 continue;
Tim Petersf8cd3e82001-10-27 04:26:57 +00001441
Tim Peters6fb26352001-10-27 04:38:11 +00001442 nargs = PyTuple_GET_SIZE(args);
Christian Heimes380f7f22008-02-28 11:19:05 +00001443 nkeywords = (keywords == NULL) ? 0 : PyDict_Size(keywords);
1444 if (nargs + nkeywords > len) {
1445 PyErr_Format(PyExc_TypeError, "%s%s takes at most %d "
1446 "argument%s (%d given)",
1447 (fname == NULL) ? "function" : fname,
1448 (fname == NULL) ? "" : "()",
1449 len,
1450 (len == 1) ? "" : "s",
1451 nargs + nkeywords);
Guido van Rossumaa354651996-08-19 19:32:04 +00001452 return 0;
1453 }
Tim Petersc2f01122001-10-27 07:25:06 +00001454
Christian Heimes380f7f22008-02-28 11:19:05 +00001455 /* convert tuple args and keyword args in same loop, using kwlist to drive process */
1456 for (i = 0; i < len; i++) {
1457 keyword = kwlist[i];
1458 if (*format == '|') {
1459 min = i;
Guido van Rossumaa354651996-08-19 19:32:04 +00001460 format++;
Christian Heimes380f7f22008-02-28 11:19:05 +00001461 }
1462 if (IS_END_OF_FORMAT(*format)) {
1463 PyErr_Format(PyExc_RuntimeError,
1464 "More keyword list entries (%d) than "
1465 "format specifiers (%d)", len, i);
1466 return cleanreturn(0, freelist);
1467 }
1468 current_arg = NULL;
1469 if (nkeywords) {
1470 current_arg = PyDict_GetItemString(keywords, keyword);
1471 }
1472 if (current_arg) {
1473 --nkeywords;
1474 if (i < nargs) {
1475 /* arg present in tuple and in dict */
1476 PyErr_Format(PyExc_TypeError,
1477 "Argument given by name ('%s') "
1478 "and position (%d)",
1479 keyword, i+1);
1480 return cleanreturn(0, freelist);
1481 }
1482 }
1483 else if (nkeywords && PyErr_Occurred())
1484 return cleanreturn(0, freelist);
1485 else if (i < nargs)
1486 current_arg = PyTuple_GET_ITEM(args, i);
1487
1488 if (current_arg) {
1489 msg = convertitem(current_arg, &format, p_va, flags,
1490 levels, msgbuf, sizeof(msgbuf), &freelist);
1491 if (msg) {
1492 seterror(i+1, msg, levels, fname, custom_msg);
1493 return cleanreturn(0, freelist);
1494 }
1495 continue;
1496 }
1497
1498 if (i < min) {
1499 PyErr_Format(PyExc_TypeError, "Required argument "
1500 "'%s' (pos %d) not found",
1501 keyword, i+1);
1502 return cleanreturn(0, freelist);
1503 }
1504 /* current code reports success when all required args
1505 * fulfilled and no keyword args left, with no further
1506 * validation. XXX Maybe skip this in debug build ?
1507 */
1508 if (!nkeywords)
1509 return cleanreturn(1, freelist);
1510
1511 /* We are into optional args, skip thru to any remaining
1512 * keyword args */
1513 msg = skipitem(&format, p_va, flags);
Guido van Rossumaa354651996-08-19 19:32:04 +00001514 if (msg) {
Christian Heimes380f7f22008-02-28 11:19:05 +00001515 PyErr_Format(PyExc_RuntimeError, "%s: '%s'", msg,
1516 format);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001517 return cleanreturn(0, freelist);
Guido van Rossumaa354651996-08-19 19:32:04 +00001518 }
1519 }
1520
Christian Heimes380f7f22008-02-28 11:19:05 +00001521 if (!IS_END_OF_FORMAT(*format)) {
1522 PyErr_Format(PyExc_RuntimeError,
1523 "more argument specifiers than keyword list entries "
1524 "(remaining format:'%s')", format);
1525 return cleanreturn(0, freelist);
Guido van Rossumaa354651996-08-19 19:32:04 +00001526 }
Tim Petersb054be42001-10-27 05:07:41 +00001527
Guido van Rossumaa354651996-08-19 19:32:04 +00001528 /* make sure there are no extraneous keyword arguments */
Tim Petersc2f01122001-10-27 07:25:06 +00001529 if (nkeywords > 0) {
1530 PyObject *key, *value;
Martin v. Löwis18e16552006-02-15 17:27:45 +00001531 Py_ssize_t pos = 0;
Guido van Rossumaa354651996-08-19 19:32:04 +00001532 while (PyDict_Next(keywords, &pos, &key, &value)) {
Tim Petersc2f01122001-10-27 07:25:06 +00001533 int match = 0;
Guido van Rossum55474762002-04-04 16:22:30 +00001534 char *ks;
Georg Brandld8b690f2008-05-16 17:28:50 +00001535 if (!PyUnicode_Check(key)) {
Guido van Rossum98297ee2007-11-06 21:34:58 +00001536 PyErr_SetString(PyExc_TypeError,
Guido van Rossum55474762002-04-04 16:22:30 +00001537 "keywords must be strings");
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001538 return cleanreturn(0, freelist);
Guido van Rossum55474762002-04-04 16:22:30 +00001539 }
Amaury Forgeot d'Arc39599dc2007-11-22 02:48:12 +00001540 ks = PyUnicode_AsString(key);
Christian Heimes380f7f22008-02-28 11:19:05 +00001541 for (i = 0; i < len; i++) {
Guido van Rossumaa354651996-08-19 19:32:04 +00001542 if (!strcmp(ks, kwlist[i])) {
1543 match = 1;
1544 break;
1545 }
1546 }
1547 if (!match) {
Tim Petersc2f01122001-10-27 07:25:06 +00001548 PyErr_Format(PyExc_TypeError,
1549 "'%s' is an invalid keyword "
1550 "argument for this function",
1551 ks);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001552 return cleanreturn(0, freelist);
Guido van Rossumaa354651996-08-19 19:32:04 +00001553 }
1554 }
1555 }
Tim Petersc2f01122001-10-27 07:25:06 +00001556
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001557 return cleanreturn(1, freelist);
Guido van Rossumaa354651996-08-19 19:32:04 +00001558}
1559
1560
1561static char *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001562skipitem(const char **p_format, va_list *p_va, int flags)
Guido van Rossumaa354651996-08-19 19:32:04 +00001563{
Christian Heimes380f7f22008-02-28 11:19:05 +00001564 const char *format = *p_format;
Guido van Rossumaa354651996-08-19 19:32:04 +00001565 char c = *format++;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001566
Guido van Rossumaa354651996-08-19 19:32:04 +00001567 switch (c) {
Georg Brandl6dd14612005-09-14 19:29:53 +00001568
1569 /* simple codes
1570 * The individual types (second arg of va_arg) are irrelevant */
1571
Guido van Rossumaa354651996-08-19 19:32:04 +00001572 case 'b': /* byte -- very short int */
Jack Jansencc22fbe2000-08-05 21:29:58 +00001573 case 'B': /* byte as bitfield */
Guido van Rossumaa354651996-08-19 19:32:04 +00001574 case 'h': /* short int */
Jack Jansencc22fbe2000-08-05 21:29:58 +00001575 case 'H': /* short int as bitfield */
Guido van Rossumaa354651996-08-19 19:32:04 +00001576 case 'i': /* int */
Georg Brandl6dd14612005-09-14 19:29:53 +00001577 case 'I': /* int sized bitfield */
Guido van Rossumaa354651996-08-19 19:32:04 +00001578 case 'l': /* long int */
Georg Brandl6dd14612005-09-14 19:29:53 +00001579 case 'k': /* long int sized bitfield */
Guido van Rossum3dbba6e1999-01-25 21:48:56 +00001580#ifdef HAVE_LONG_LONG
Georg Brandl6dd14612005-09-14 19:29:53 +00001581 case 'L': /* PY_LONG_LONG */
1582 case 'K': /* PY_LONG_LONG sized bitfield */
Guido van Rossum1a8791e1998-08-04 22:46:29 +00001583#endif
Guido van Rossumaa354651996-08-19 19:32:04 +00001584 case 'f': /* float */
Guido van Rossumaa354651996-08-19 19:32:04 +00001585 case 'd': /* double */
Guido van Rossumaa354651996-08-19 19:32:04 +00001586#ifndef WITHOUT_COMPLEX
1587 case 'D': /* complex double */
Georg Brandl6dd14612005-09-14 19:29:53 +00001588#endif
Guido van Rossumaa354651996-08-19 19:32:04 +00001589 case 'c': /* char */
1590 {
Georg Brandl6dd14612005-09-14 19:29:53 +00001591 (void) va_arg(*p_va, void *);
Guido van Rossumaa354651996-08-19 19:32:04 +00001592 break;
1593 }
Martin v. Löwis18e16552006-02-15 17:27:45 +00001594
1595 case 'n': /* Py_ssize_t */
1596 {
1597 (void) va_arg(*p_va, Py_ssize_t *);
1598 break;
1599 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001600
Georg Brandl6dd14612005-09-14 19:29:53 +00001601 /* string codes */
Guido van Rossum98297ee2007-11-06 21:34:58 +00001602
Georg Brandl6dd14612005-09-14 19:29:53 +00001603 case 'e': /* string with encoding */
1604 {
1605 (void) va_arg(*p_va, const char *);
1606 if (!(*format == 's' || *format == 't'))
1607 /* after 'e', only 's' and 't' is allowed */
1608 goto err;
1609 format++;
1610 /* explicit fallthrough to string cases */
1611 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001612
Guido van Rossumaa354651996-08-19 19:32:04 +00001613 case 's': /* string */
Georg Brandl6dd14612005-09-14 19:29:53 +00001614 case 'z': /* string or None */
Walter Dörwald612344f2007-05-04 19:28:21 +00001615 case 'y': /* bytes */
Georg Brandl6dd14612005-09-14 19:29:53 +00001616 case 'u': /* unicode string */
Georg Brandl6dd14612005-09-14 19:29:53 +00001617 case 't': /* buffer, read-only */
1618 case 'w': /* buffer, read-write */
Guido van Rossumaa354651996-08-19 19:32:04 +00001619 {
Guido van Rossum80bb9651996-12-05 23:27:02 +00001620 (void) va_arg(*p_va, char **);
Guido van Rossumaa354651996-08-19 19:32:04 +00001621 if (*format == '#') {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001622 if (flags & FLAG_SIZE_T)
1623 (void) va_arg(*p_va, Py_ssize_t *);
1624 else
1625 (void) va_arg(*p_va, int *);
Guido van Rossumaa354651996-08-19 19:32:04 +00001626 format++;
1627 }
1628 break;
1629 }
Georg Brandl6dd14612005-09-14 19:29:53 +00001630
1631 /* object codes */
1632
Guido van Rossumaa354651996-08-19 19:32:04 +00001633 case 'S': /* string object */
Guido van Rossum617dbc42007-05-07 23:57:08 +00001634 case 'Y': /* string object */
Georg Brandl6dd14612005-09-14 19:29:53 +00001635 case 'U': /* unicode string object */
Guido van Rossumaa354651996-08-19 19:32:04 +00001636 {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001637 (void) va_arg(*p_va, PyObject **);
Guido van Rossumaa354651996-08-19 19:32:04 +00001638 break;
1639 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001640
Guido van Rossumaa354651996-08-19 19:32:04 +00001641 case 'O': /* object */
1642 {
Guido van Rossumaa354651996-08-19 19:32:04 +00001643 if (*format == '!') {
1644 format++;
Guido van Rossum79f25d91997-04-29 20:08:16 +00001645 (void) va_arg(*p_va, PyTypeObject*);
1646 (void) va_arg(*p_va, PyObject **);
Guido van Rossumaa354651996-08-19 19:32:04 +00001647 }
1648#if 0
1649/* I don't know what this is for */
1650 else if (*format == '?') {
1651 inquiry pred = va_arg(*p_va, inquiry);
1652 format++;
1653 if ((*pred)(arg)) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001654 (void) va_arg(*p_va, PyObject **);
Guido van Rossumaa354651996-08-19 19:32:04 +00001655 }
1656 }
1657#endif
1658 else if (*format == '&') {
Tim Petersdbd9ba62000-07-09 03:09:57 +00001659 typedef int (*converter)(PyObject *, void *);
Guido van Rossum80bb9651996-12-05 23:27:02 +00001660 (void) va_arg(*p_va, converter);
1661 (void) va_arg(*p_va, void *);
Guido van Rossumaa354651996-08-19 19:32:04 +00001662 format++;
1663 }
1664 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001665 (void) va_arg(*p_va, PyObject **);
Guido van Rossumaa354651996-08-19 19:32:04 +00001666 }
1667 break;
1668 }
Guido van Rossum98297ee2007-11-06 21:34:58 +00001669
Christian Heimes380f7f22008-02-28 11:19:05 +00001670 case '(': /* bypass tuple, not handled at all previously */
1671 {
1672 char *msg;
1673 for (;;) {
1674 if (*format==')')
1675 break;
1676 if (IS_END_OF_FORMAT(*format))
1677 return "Unmatched left paren in format "
1678 "string";
1679 msg = skipitem(&format, p_va, flags);
1680 if (msg)
1681 return msg;
1682 }
1683 format++;
1684 break;
1685 }
1686
1687 case ')':
1688 return "Unmatched right paren in format string";
1689
Guido van Rossumaa354651996-08-19 19:32:04 +00001690 default:
Georg Brandl6dd14612005-09-14 19:29:53 +00001691err:
Guido van Rossumaa354651996-08-19 19:32:04 +00001692 return "impossible<bad format char>";
Guido van Rossum98297ee2007-11-06 21:34:58 +00001693
Guido van Rossumaa354651996-08-19 19:32:04 +00001694 }
Georg Brandl6dd14612005-09-14 19:29:53 +00001695
Guido van Rossumaa354651996-08-19 19:32:04 +00001696 *p_format = format;
1697 return NULL;
1698}
Fred Drakee4616e62001-10-23 21:09:29 +00001699
1700
1701int
Martin v. Löwis76246742006-03-01 04:06:10 +00001702PyArg_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, ...)
Fred Drakee4616e62001-10-23 21:09:29 +00001703{
Martin v. Löwis76246742006-03-01 04:06:10 +00001704 Py_ssize_t i, l;
Fred Drakee4616e62001-10-23 21:09:29 +00001705 PyObject **o;
1706 va_list vargs;
1707
1708#ifdef HAVE_STDARG_PROTOTYPES
1709 va_start(vargs, max);
1710#else
1711 va_start(vargs);
1712#endif
1713
1714 assert(min >= 0);
1715 assert(min <= max);
1716 if (!PyTuple_Check(args)) {
1717 PyErr_SetString(PyExc_SystemError,
1718 "PyArg_UnpackTuple() argument list is not a tuple");
1719 return 0;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001720 }
Fred Drakee4616e62001-10-23 21:09:29 +00001721 l = PyTuple_GET_SIZE(args);
1722 if (l < min) {
1723 if (name != NULL)
1724 PyErr_Format(
1725 PyExc_TypeError,
Guido van Rossum98297ee2007-11-06 21:34:58 +00001726 "%s expected %s%zd arguments, got %zd",
Fred Drakee4616e62001-10-23 21:09:29 +00001727 name, (min == max ? "" : "at least "), min, l);
1728 else
1729 PyErr_Format(
1730 PyExc_TypeError,
Thomas Wouters572a9f32006-03-01 05:38:39 +00001731 "unpacked tuple should have %s%zd elements,"
Guido van Rossum98297ee2007-11-06 21:34:58 +00001732 " but has %zd",
Fred Drakee4616e62001-10-23 21:09:29 +00001733 (min == max ? "" : "at least "), min, l);
1734 va_end(vargs);
1735 return 0;
1736 }
1737 if (l > max) {
1738 if (name != NULL)
1739 PyErr_Format(
1740 PyExc_TypeError,
Guido van Rossum98297ee2007-11-06 21:34:58 +00001741 "%s expected %s%zd arguments, got %zd",
Fred Drakee4616e62001-10-23 21:09:29 +00001742 name, (min == max ? "" : "at most "), max, l);
1743 else
1744 PyErr_Format(
1745 PyExc_TypeError,
Thomas Wouters572a9f32006-03-01 05:38:39 +00001746 "unpacked tuple should have %s%zd elements,"
Guido van Rossum98297ee2007-11-06 21:34:58 +00001747 " but has %zd",
Fred Drakee4616e62001-10-23 21:09:29 +00001748 (min == max ? "" : "at most "), max, l);
1749 va_end(vargs);
1750 return 0;
1751 }
1752 for (i = 0; i < l; i++) {
1753 o = va_arg(vargs, PyObject **);
1754 *o = PyTuple_GET_ITEM(args, i);
1755 }
1756 va_end(vargs);
1757 return 1;
1758}
Georg Brandl02c42872005-08-26 06:42:30 +00001759
1760
1761/* For type constructors that don't take keyword args
1762 *
Guido van Rossum98297ee2007-11-06 21:34:58 +00001763 * Sets a TypeError and returns 0 if the kwds dict is
Thomas Wouters89f507f2006-12-13 04:49:30 +00001764 * not empty, returns 1 otherwise
Georg Brandl02c42872005-08-26 06:42:30 +00001765 */
1766int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001767_PyArg_NoKeywords(const char *funcname, PyObject *kw)
Georg Brandl02c42872005-08-26 06:42:30 +00001768{
1769 if (kw == NULL)
1770 return 1;
1771 if (!PyDict_CheckExact(kw)) {
1772 PyErr_BadInternalCall();
1773 return 0;
1774 }
1775 if (PyDict_Size(kw) == 0)
1776 return 1;
Guido van Rossum98297ee2007-11-06 21:34:58 +00001777
1778 PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",
Georg Brandl02c42872005-08-26 06:42:30 +00001779 funcname);
1780 return 0;
1781}
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001782#ifdef __cplusplus
1783};
1784#endif