blob: b0715ba33dabcc10147182c30626fcc9378b28fb [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
10extern "C" {
11#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 *);
Martin v. Löwis18e16552006-02-15 17:27:45 +000040static char *convertitem(PyObject *, const char **, va_list *, int, int *,
41 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 Rossumfe3f1a21994-09-29 09:42:55 +000057
58 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;
69
70 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 Rossumfe3f1a21994-09-29 09:42:55 +000082
83 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;
94
95 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 }
157 if(PyList_Append(*freelist, cobj)) {
158 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{
169 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++;
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000209 break;
210 case ')':
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000211 if (level == 0)
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000212 Py_FatalError("excess ')' in getargs format");
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000213 else
214 level--;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000215 break;
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000216 case '\0':
217 endfmt = 1;
218 break;
219 case ':':
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000220 fname = format;
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000221 endfmt = 1;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000222 break;
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000223 case ';':
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000224 message = format;
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000225 endfmt = 1;
226 break;
227 default:
228 if (level == 0) {
229 if (c == 'O')
230 max++;
Neal Norwitz30b5c5d2005-12-19 06:05:18 +0000231 else if (isalpha(Py_CHARMASK(c))) {
Jeremy Hylton25916bd2001-05-29 17:46:19 +0000232 if (c != 'e') /* skip encoded */
233 max++;
234 } else if (c == '|')
235 min = max;
236 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000237 break;
238 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000239 }
240
241 if (level != 0)
Guido van Rossum79f25d91997-04-29 20:08:16 +0000242 Py_FatalError(/* '(' */ "missing ')' in getargs format");
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000243
244 if (min < 0)
245 min = max;
246
247 format = formatsave;
248
249 if (compat) {
250 if (max == 0) {
251 if (args == NULL)
252 return 1;
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000253 PyOS_snprintf(msgbuf, sizeof(msgbuf),
254 "%.200s%s takes no arguments",
255 fname==NULL ? "function" : fname,
256 fname==NULL ? "" : "()");
Guido van Rossum79f25d91997-04-29 20:08:16 +0000257 PyErr_SetString(PyExc_TypeError, msgbuf);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000258 return 0;
259 }
260 else if (min == 1 && max == 1) {
Guido van Rossum13d0ed11994-11-10 22:35:48 +0000261 if (args == NULL) {
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000262 PyOS_snprintf(msgbuf, sizeof(msgbuf),
263 "%.200s%s takes at least one argument",
264 fname==NULL ? "function" : fname,
265 fname==NULL ? "" : "()");
Guido van Rossum79f25d91997-04-29 20:08:16 +0000266 PyErr_SetString(PyExc_TypeError, msgbuf);
Guido van Rossum13d0ed11994-11-10 22:35:48 +0000267 return 0;
268 }
Martin v. Löwis18e16552006-02-15 17:27:45 +0000269 msg = convertitem(args, &format, p_va, flags, levels,
270 msgbuf, sizeof(msgbuf), &freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000271 if (msg == NULL)
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000272 return cleanreturn(1, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000273 seterror(levels[0], msg, levels+1, fname, message);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000274 return cleanreturn(0, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000275 }
276 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +0000277 PyErr_SetString(PyExc_SystemError,
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000278 "old style getargs format uses new features");
279 return 0;
280 }
281 }
282
Guido van Rossum79f25d91997-04-29 20:08:16 +0000283 if (!PyTuple_Check(args)) {
284 PyErr_SetString(PyExc_SystemError,
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000285 "new style getargs format but argument is not a tuple");
286 return 0;
287 }
288
Jeremy Hylton0f8117f2001-05-18 20:57:38 +0000289 len = PyTuple_GET_SIZE(args);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000290
291 if (len < min || max < len) {
292 if (message == NULL) {
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000293 PyOS_snprintf(msgbuf, sizeof(msgbuf),
294 "%.150s%s takes %s %d argument%s "
Neal Norwitz20dd93f2006-02-19 19:34:15 +0000295 "(%ld given)",
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000296 fname==NULL ? "function" : fname,
297 fname==NULL ? "" : "()",
298 min==max ? "exactly"
299 : len < min ? "at least" : "at most",
300 len < min ? min : max,
301 (len < min ? min : max) == 1 ? "" : "s",
Neal Norwitz9a276172006-02-20 18:57:39 +0000302 Py_SAFE_DOWNCAST(len, Py_ssize_t, long));
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000303 message = msgbuf;
304 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000305 PyErr_SetString(PyExc_TypeError, message);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000306 return 0;
307 }
308
309 for (i = 0; i < len; i++) {
310 if (*format == '|')
311 format++;
Jeremy Hylton0f8117f2001-05-18 20:57:38 +0000312 msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
Martin v. Löwis18e16552006-02-15 17:27:45 +0000313 flags, levels, msgbuf,
314 sizeof(msgbuf), &freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000315 if (msg) {
316 seterror(i+1, msg, levels, fname, message);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000317 return cleanreturn(0, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000318 }
319 }
Guido van Rossum231a41e1997-12-09 20:36:39 +0000320
Neal Norwitz4ac13df2005-12-19 06:10:07 +0000321 if (*format != '\0' && !isalpha(Py_CHARMASK(*format)) &&
Guido van Rossum7d4f68c1997-12-19 04:25:23 +0000322 *format != '(' &&
Guido van Rossum231a41e1997-12-09 20:36:39 +0000323 *format != '|' && *format != ':' && *format != ';') {
324 PyErr_Format(PyExc_SystemError,
Guido van Rossum0d6b49e1998-01-19 22:22:44 +0000325 "bad format string: %.200s", formatsave);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000326 return cleanreturn(0, freelist);
Guido van Rossum231a41e1997-12-09 20:36:39 +0000327 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000328
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000329 return cleanreturn(1, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000330}
331
332
333
334static void
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000335seterror(int iarg, const char *msg, int *levels, const char *fname,
336 const char *message)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000337{
Marc-André Lemburgd4c0a9c2001-11-28 11:47:00 +0000338 char buf[512];
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000339 int i;
340 char *p = buf;
341
Guido van Rossum79f25d91997-04-29 20:08:16 +0000342 if (PyErr_Occurred())
Guido van Rossum64fc6491995-01-21 14:09:37 +0000343 return;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000344 else if (message == NULL) {
345 if (fname != NULL) {
Jeremy Hyltonf16e05e2001-11-28 21:46:59 +0000346 PyOS_snprintf(p, sizeof(buf), "%.200s() ", fname);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000347 p += strlen(p);
348 }
Ka-Ping Yee20579702001-01-15 22:14:16 +0000349 if (iarg != 0) {
Tim Petersfaad5ad2001-12-03 00:43:33 +0000350 PyOS_snprintf(p, sizeof(buf) - (p - buf),
Jeremy Hyltonf16e05e2001-11-28 21:46:59 +0000351 "argument %d", iarg);
Ka-Ping Yee20579702001-01-15 22:14:16 +0000352 i = 0;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000353 p += strlen(p);
Marc-André Lemburgd4c0a9c2001-11-28 11:47:00 +0000354 while (levels[i] > 0 && (int)(p-buf) < 220) {
Jeremy Hyltonf16e05e2001-11-28 21:46:59 +0000355 PyOS_snprintf(p, sizeof(buf) - (buf - p),
356 ", item %d", levels[i]-1);
Ka-Ping Yee20579702001-01-15 22:14:16 +0000357 p += strlen(p);
358 i++;
359 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000360 }
Ka-Ping Yee20579702001-01-15 22:14:16 +0000361 else {
Tim Petersfaad5ad2001-12-03 00:43:33 +0000362 PyOS_snprintf(p, sizeof(buf) - (p - buf), "argument");
Ka-Ping Yee20579702001-01-15 22:14:16 +0000363 p += strlen(p);
364 }
Tim Petersfaad5ad2001-12-03 00:43:33 +0000365 PyOS_snprintf(p, sizeof(buf) - (p - buf), " %.256s", msg);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000366 message = buf;
367 }
Guido van Rossum79f25d91997-04-29 20:08:16 +0000368 PyErr_SetString(PyExc_TypeError, message);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000369}
370
371
372/* Convert a tuple argument.
373 On entry, *p_format points to the character _after_ the opening '('.
374 On successful exit, *p_format points to the closing ')'.
375 If successful:
376 *p_format and *p_va are updated,
377 *levels and *msgbuf are untouched,
378 and NULL is returned.
379 If the argument is invalid:
380 *p_format is unchanged,
381 *p_va is undefined,
382 *levels is a 0-terminated list of item numbers,
383 *msgbuf contains an error message, whose format is:
Ka-Ping Yee20579702001-01-15 22:14:16 +0000384 "must be <typename1>, not <typename2>", where:
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000385 <typename1> is the name of the expected type, and
386 <typename2> is the name of the actual type,
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000387 and msgbuf is returned.
388*/
389
390static char *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000391converttuple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
392 int *levels, char *msgbuf, size_t bufsize, int toplevel,
393 PyObject **freelist)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000394{
395 int level = 0;
396 int n = 0;
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000397 const char *format = *p_format;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000398 int i;
399
400 for (;;) {
401 int c = *format++;
402 if (c == '(') {
403 if (level == 0)
404 n++;
405 level++;
406 }
407 else if (c == ')') {
408 if (level == 0)
409 break;
410 level--;
411 }
412 else if (c == ':' || c == ';' || c == '\0')
413 break;
Neal Norwitz30b5c5d2005-12-19 06:05:18 +0000414 else if (level == 0 && isalpha(Py_CHARMASK(c)))
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000415 n++;
416 }
417
Ka-Ping Yee20579702001-01-15 22:14:16 +0000418 if (!PySequence_Check(arg) || PyString_Check(arg)) {
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000419 levels[0] = 0;
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000420 PyOS_snprintf(msgbuf, bufsize,
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000421 toplevel ? "expected %d arguments, not %.50s" :
422 "must be %d-item sequence, not %.50s",
423 n,
424 arg == Py_None ? "None" : arg->ob_type->tp_name);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000425 return msgbuf;
426 }
427
Jeremy Hylton03657cf2000-07-12 13:05:33 +0000428 if ((i = PySequence_Size(arg)) != n) {
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000429 levels[0] = 0;
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000430 PyOS_snprintf(msgbuf, bufsize,
Jeremy Hylton23ae9872001-11-28 20:29:22 +0000431 toplevel ? "expected %d arguments, not %d" :
432 "must be sequence of length %d, not %d",
433 n, i);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000434 return msgbuf;
435 }
Ka-Ping Yee20579702001-01-15 22:14:16 +0000436
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000437 format = *p_format;
438 for (i = 0; i < n; i++) {
439 char *msg;
Guido van Rossum66368cc1999-02-17 23:16:43 +0000440 PyObject *item;
441 item = PySequence_GetItem(arg, i);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000442 msg = convertitem(item, &format, p_va, flags, levels+1,
443 msgbuf, bufsize, freelist);
Guido van Rossum66368cc1999-02-17 23:16:43 +0000444 /* PySequence_GetItem calls tp->sq_item, which INCREFs */
445 Py_XDECREF(item);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000446 if (msg != NULL) {
447 levels[0] = i+1;
448 return msg;
449 }
450 }
Ka-Ping Yee20579702001-01-15 22:14:16 +0000451
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000452 *p_format = format;
453 return NULL;
454}
455
456
457/* Convert a single item. */
458
459static char *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000460convertitem(PyObject *arg, const char **p_format, va_list *p_va, int flags,
461 int *levels, char *msgbuf, size_t bufsize, PyObject **freelist)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000462{
463 char *msg;
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000464 const char *format = *p_format;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000465
466 if (*format == '(' /* ')' */) {
467 format++;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000468 msg = converttuple(arg, &format, p_va, flags, levels, msgbuf,
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000469 bufsize, 0, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000470 if (msg == NULL)
471 format++;
472 }
473 else {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000474 msg = convertsimple(arg, &format, p_va, flags,
475 msgbuf, bufsize, freelist);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000476 if (msg != NULL)
477 levels[0] = 0;
478 }
479 if (msg == NULL)
480 *p_format = format;
481 return msg;
482}
483
484
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000485
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000486#define UNICODE_DEFAULT_ENCODING(arg) \
487 _PyUnicode_AsDefaultEncodedString(arg, NULL)
488
489/* Format an error message generated by convertsimple(). */
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000490
491static char *
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000492converterr(const char *expected, PyObject *arg, char *msgbuf, size_t bufsize)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000493{
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000494 assert(expected != NULL);
495 assert(arg != NULL);
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000496 PyOS_snprintf(msgbuf, bufsize,
497 "must be %.50s, not %.50s", expected,
498 arg == Py_None ? "None" : arg->ob_type->tp_name);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000499 return msgbuf;
500}
501
502#define CONV_UNICODE "(unicode conversion error)"
503
Guido van Rossum45aecf42006-03-15 04:58:47 +0000504/* Explicitly check for float arguments when integers are expected.
505 Return 1 for error, 0 if ok. */
Neil Schemenauer5042da62003-02-04 20:59:40 +0000506static int
507float_argument_error(PyObject *arg)
508{
Guido van Rossum45aecf42006-03-15 04:58:47 +0000509 if (PyFloat_Check(arg)) {
510 PyErr_SetString(PyExc_TypeError,
511 "integer argument expected, got float" );
Neil Schemenauer5042da62003-02-04 20:59:40 +0000512 return 1;
Guido van Rossum45aecf42006-03-15 04:58:47 +0000513 }
Neil Schemenauer5042da62003-02-04 20:59:40 +0000514 else
515 return 0;
516}
517
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000518/* Convert a non-tuple argument. Return NULL if conversion went OK,
519 or a string with a message describing the failure. The message is
520 formatted as "must be <desired type>, not <actual type>".
521 When failing, an exception may or may not have been raised.
Georg Brandl6dd14612005-09-14 19:29:53 +0000522 Don't call if a tuple is expected.
523
524 When you add new format codes, please don't forget poor skipitem() below.
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000525*/
526
527static char *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000528convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags,
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000529 char *msgbuf, size_t bufsize, PyObject **freelist)
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000530{
Martin v. Löwis18e16552006-02-15 17:27:45 +0000531 /* For # codes */
532#define FETCH_SIZE int *q=NULL;Py_ssize_t *q2=NULL;\
533 if (flags & FLAG_SIZE_T) q2=va_arg(*p_va, Py_ssize_t*); \
534 else q=va_arg(*p_va, int*);
535#define STORE_SIZE(s) if (flags & FLAG_SIZE_T) *q2=s; else *q=s;
536#define BUFFER_LEN ((flags & FLAG_SIZE_T) ? *q2:*q)
537
Jeremy Hyltonaf68c872005-12-10 18:50:16 +0000538 const char *format = *p_format;
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000539 char c = *format++;
Walter Dörwalddffda2e2002-11-21 20:23:11 +0000540#ifdef Py_USING_UNICODE
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000541 PyObject *uarg;
Walter Dörwalddffda2e2002-11-21 20:23:11 +0000542#endif
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000543
544 switch (c) {
545
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000546 case 'b': { /* unsigned byte -- very short int */
547 char *p = va_arg(*p_va, char *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000548 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000549 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000550 return converterr("integer<b>", arg, msgbuf, bufsize);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000551 ival = PyInt_AsLong(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000552 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000553 return converterr("integer<b>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000554 else if (ival < 0) {
555 PyErr_SetString(PyExc_OverflowError,
556 "unsigned byte integer is less than minimum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000557 return converterr("integer<b>", arg, msgbuf, bufsize);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000558 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000559 else if (ival > UCHAR_MAX) {
560 PyErr_SetString(PyExc_OverflowError,
561 "unsigned byte integer is greater than maximum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000562 return converterr("integer<b>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000563 }
564 else
565 *p = (unsigned char) ival;
566 break;
567 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000568
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000569 case 'B': {/* byte sized bitfield - both signed and unsigned
570 values allowed */
571 char *p = va_arg(*p_va, char *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000572 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000573 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000574 return converterr("integer<B>", arg, msgbuf, bufsize);
Thomas Hellera4ea6032003-04-17 18:55:45 +0000575 ival = PyInt_AsUnsignedLongMask(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000576 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000577 return converterr("integer<B>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000578 else
579 *p = (unsigned char) ival;
580 break;
581 }
Jack Jansencc22fbe2000-08-05 21:29:58 +0000582
Guido van Rossumfce26e72003-04-18 00:12:30 +0000583 case 'h': {/* signed short int */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000584 short *p = va_arg(*p_va, short *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000585 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000586 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000587 return converterr("integer<h>", arg, msgbuf, bufsize);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000588 ival = PyInt_AsLong(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000589 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000590 return converterr("integer<h>", arg, msgbuf, bufsize);
Guido van Rossumfce26e72003-04-18 00:12:30 +0000591 else if (ival < SHRT_MIN) {
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000592 PyErr_SetString(PyExc_OverflowError,
Guido van Rossumfce26e72003-04-18 00:12:30 +0000593 "signed short integer is less than minimum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000594 return converterr("integer<h>", arg, msgbuf, bufsize);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000595 }
Guido van Rossumfce26e72003-04-18 00:12:30 +0000596 else if (ival > SHRT_MAX) {
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000597 PyErr_SetString(PyExc_OverflowError,
Guido van Rossumfce26e72003-04-18 00:12:30 +0000598 "signed short integer is greater than maximum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000599 return converterr("integer<h>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000600 }
601 else
602 *p = (short) ival;
603 break;
604 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000605
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000606 case 'H': { /* short int sized bitfield, both signed and
607 unsigned allowed */
608 unsigned short *p = va_arg(*p_va, unsigned short *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000609 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000610 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000611 return converterr("integer<H>", arg, msgbuf, bufsize);
Thomas Hellera4ea6032003-04-17 18:55:45 +0000612 ival = PyInt_AsUnsignedLongMask(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000613 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000614 return converterr("integer<H>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000615 else
616 *p = (unsigned short) ival;
617 break;
618 }
Martin v. Löwis18e16552006-02-15 17:27:45 +0000619
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000620 case 'i': {/* signed int */
621 int *p = va_arg(*p_va, int *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000622 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000623 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000624 return converterr("integer<i>", arg, msgbuf, bufsize);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000625 ival = PyInt_AsLong(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000626 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000627 return converterr("integer<i>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000628 else if (ival > INT_MAX) {
629 PyErr_SetString(PyExc_OverflowError,
630 "signed integer is greater than maximum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000631 return converterr("integer<i>", arg, msgbuf, bufsize);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000632 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000633 else if (ival < INT_MIN) {
634 PyErr_SetString(PyExc_OverflowError,
635 "signed integer is less than minimum");
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000636 return converterr("integer<i>", arg, msgbuf, bufsize);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000637 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000638 else
639 *p = ival;
640 break;
641 }
642
Thomas Hellera4ea6032003-04-17 18:55:45 +0000643 case 'I': { /* int sized bitfield, both signed and
644 unsigned allowed */
645 unsigned int *p = va_arg(*p_va, unsigned int *);
646 unsigned int ival;
647 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000648 return converterr("integer<I>", arg, msgbuf, bufsize);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000649 ival = (unsigned int)PyInt_AsUnsignedLongMask(arg);
650 if (ival == (unsigned int)-1 && PyErr_Occurred())
Thomas Hellera4ea6032003-04-17 18:55:45 +0000651 return converterr("integer<I>", arg, msgbuf, bufsize);
652 else
653 *p = ival;
654 break;
655 }
656
Martin v. Löwis18e16552006-02-15 17:27:45 +0000657 case 'n': /* Py_ssize_t */
658#if SIZEOF_SIZE_T != SIZEOF_LONG
659 {
660 Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *);
661 Py_ssize_t ival;
662 if (float_argument_error(arg))
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000663 return converterr("integer<n>", arg, msgbuf, bufsize);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000664 ival = PyInt_AsSsize_t(arg);
665 if (ival == -1 && PyErr_Occurred())
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000666 return converterr("integer<n>", arg, msgbuf, bufsize);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000667 *p = ival;
668 break;
669 }
670#endif
671 /* Fall through from 'n' to 'l' if Py_ssize_t is int */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000672 case 'l': {/* long int */
673 long *p = va_arg(*p_va, long *);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000674 long ival;
Neil Schemenauer5042da62003-02-04 20:59:40 +0000675 if (float_argument_error(arg))
Michael W. Hudson34553382004-08-07 17:57:16 +0000676 return converterr("integer<l>", arg, msgbuf, bufsize);
Neil Schemenauerb808e992003-01-24 22:15:21 +0000677 ival = PyInt_AsLong(arg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000678 if (ival == -1 && PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000679 return converterr("integer<l>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000680 else
681 *p = ival;
682 break;
683 }
Thomas Hellera4ea6032003-04-17 18:55:45 +0000684
685 case 'k': { /* long sized bitfield */
686 unsigned long *p = va_arg(*p_va, unsigned long *);
687 unsigned long ival;
688 if (PyInt_Check(arg))
689 ival = PyInt_AsUnsignedLongMask(arg);
690 else if (PyLong_Check(arg))
691 ival = PyLong_AsUnsignedLongMask(arg);
692 else
693 return converterr("integer<k>", arg, msgbuf, bufsize);
694 *p = ival;
695 break;
696 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000697
Guido van Rossum3dbba6e1999-01-25 21:48:56 +0000698#ifdef HAVE_LONG_LONG
Martin v. Löwisb9a0f912003-03-29 10:06:18 +0000699 case 'L': {/* PY_LONG_LONG */
700 PY_LONG_LONG *p = va_arg( *p_va, PY_LONG_LONG * );
701 PY_LONG_LONG ival = PyLong_AsLongLong( arg );
702 if( ival == (PY_LONG_LONG)-1 && PyErr_Occurred() ) {
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000703 return converterr("long<L>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000704 } else {
705 *p = ival;
Guido van Rossum1a8791e1998-08-04 22:46:29 +0000706 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000707 break;
708 }
Thomas Hellera4ea6032003-04-17 18:55:45 +0000709
710 case 'K': { /* long long sized bitfield */
711 unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *);
712 unsigned PY_LONG_LONG ival;
Thomas Hellera4ea6032003-04-17 18:55:45 +0000713 if (PyInt_Check(arg))
714 ival = PyInt_AsUnsignedLongMask(arg);
715 else if (PyLong_Check(arg))
716 ival = PyLong_AsUnsignedLongLongMask(arg);
717 else
718 return converterr("integer<K>", arg, msgbuf, bufsize);
719 *p = ival;
720 break;
721 }
Guido van Rossum1a8791e1998-08-04 22:46:29 +0000722#endif
723
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000724 case 'f': {/* float */
725 float *p = va_arg(*p_va, float *);
726 double dval = PyFloat_AsDouble(arg);
727 if (PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000728 return converterr("float<f>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000729 else
730 *p = (float) dval;
731 break;
732 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000733
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000734 case 'd': {/* double */
735 double *p = va_arg(*p_va, double *);
736 double dval = PyFloat_AsDouble(arg);
737 if (PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000738 return converterr("float<d>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000739 else
740 *p = dval;
741 break;
742 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000743
Guido van Rossum530956d1996-07-21 02:27:43 +0000744#ifndef WITHOUT_COMPLEX
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000745 case 'D': {/* complex double */
746 Py_complex *p = va_arg(*p_va, Py_complex *);
747 Py_complex cval;
748 cval = PyComplex_AsCComplex(arg);
749 if (PyErr_Occurred())
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000750 return converterr("complex<D>", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000751 else
752 *p = cval;
753 break;
754 }
Guido van Rossum530956d1996-07-21 02:27:43 +0000755#endif /* WITHOUT_COMPLEX */
Guido van Rossum8a5c5d21996-01-12 01:09:56 +0000756
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000757 case 'c': {/* char */
758 char *p = va_arg(*p_va, char *);
759 if (PyString_Check(arg) && PyString_Size(arg) == 1)
Jeremy Hylton0407aea2001-10-10 02:51:57 +0000760 *p = PyString_AS_STRING(arg)[0];
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000761 else
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000762 return converterr("char", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000763 break;
764 }
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000765
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000766 case 's': {/* string */
767 if (*format == '#') {
768 void **p = (void **)va_arg(*p_va, char **);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000769 FETCH_SIZE;
Guido van Rossumfdf95dd1997-05-05 22:15:02 +0000770
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000771 if (PyString_Check(arg)) {
772 *p = PyString_AS_STRING(arg);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000773 STORE_SIZE(PyString_GET_SIZE(arg));
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000774 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000775#ifdef Py_USING_UNICODE
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000776 else if (PyUnicode_Check(arg)) {
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000777 uarg = UNICODE_DEFAULT_ENCODING(arg);
778 if (uarg == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000779 return converterr(CONV_UNICODE,
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000780 arg, msgbuf, bufsize);
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000781 *p = PyString_AS_STRING(uarg);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000782 STORE_SIZE(PyString_GET_SIZE(uarg));
Guido van Rossumfe3f1a21994-09-29 09:42:55 +0000783 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000784#endif
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000785 else { /* any buffer-like object */
786 char *buf;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000787 Py_ssize_t count = convertbuffer(arg, p, &buf);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000788 if (count < 0)
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000789 return converterr(buf, arg, msgbuf, bufsize);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000790 STORE_SIZE(count);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000791 }
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000792 format++;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000793 } else {
794 char **p = va_arg(*p_va, char **);
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000795
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000796 if (PyString_Check(arg))
797 *p = PyString_AS_STRING(arg);
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000798#ifdef Py_USING_UNICODE
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000799 else if (PyUnicode_Check(arg)) {
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000800 uarg = UNICODE_DEFAULT_ENCODING(arg);
801 if (uarg == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000802 return converterr(CONV_UNICODE,
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000803 arg, msgbuf, bufsize);
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000804 *p = PyString_AS_STRING(uarg);
Marc-André Lemburg6f15e572001-05-02 17:16:16 +0000805 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000806#endif
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000807 else
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000808 return converterr("string", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000809 if ((int)strlen(*p) != PyString_Size(arg))
810 return converterr("string without null bytes",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000811 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000812 }
813 break;
814 }
815
816 case 'z': {/* string, may be NULL (None) */
817 if (*format == '#') { /* any buffer-like object */
818 void **p = (void **)va_arg(*p_va, char **);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000819 FETCH_SIZE;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000820
821 if (arg == Py_None) {
822 *p = 0;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000823 STORE_SIZE(0);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000824 }
825 else if (PyString_Check(arg)) {
826 *p = PyString_AS_STRING(arg);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000827 STORE_SIZE(PyString_GET_SIZE(arg));
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000828 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000829#ifdef Py_USING_UNICODE
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000830 else if (PyUnicode_Check(arg)) {
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000831 uarg = UNICODE_DEFAULT_ENCODING(arg);
832 if (uarg == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000833 return converterr(CONV_UNICODE,
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000834 arg, msgbuf, bufsize);
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000835 *p = PyString_AS_STRING(uarg);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000836 STORE_SIZE(PyString_GET_SIZE(uarg));
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000837 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000838#endif
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000839 else { /* any buffer-like object */
840 char *buf;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000841 Py_ssize_t count = convertbuffer(arg, p, &buf);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000842 if (count < 0)
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000843 return converterr(buf, arg, msgbuf, bufsize);
Martin v. Löwis18e16552006-02-15 17:27:45 +0000844 STORE_SIZE(count);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000845 }
846 format++;
847 } else {
848 char **p = va_arg(*p_va, char **);
849
850 if (arg == Py_None)
851 *p = 0;
852 else if (PyString_Check(arg))
Jeremy Hyltona4c8cd72001-10-10 02:51:08 +0000853 *p = PyString_AS_STRING(arg);
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000854#ifdef Py_USING_UNICODE
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);
Jeremy Hylton77b8b672001-09-10 01:54:43 +0000860 *p = PyString_AS_STRING(uarg);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000861 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000862#endif
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000863 else
864 return converterr("string or None",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000865 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000866 if (*format == '#') {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000867 FETCH_SIZE;
Thomas Woutersc3547a32006-03-01 21:31:21 +0000868 assert(0); /* XXX redundant with if-case */
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000869 if (arg == Py_None)
870 *q = 0;
871 else
872 *q = PyString_Size(arg);
873 format++;
874 }
875 else if (*p != NULL &&
876 (int)strlen(*p) != PyString_Size(arg))
877 return converterr(
878 "string without null bytes or None",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000879 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000880 }
881 break;
882 }
883
884 case 'e': {/* encoded string */
885 char **buffer;
886 const char *encoding;
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000887 PyObject *s;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000888 int size, recode_strings;
889
890 /* Get 'e' parameter: the encoding name */
891 encoding = (const char *)va_arg(*p_va, const char *);
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000892#ifdef Py_USING_UNICODE
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000893 if (encoding == NULL)
894 encoding = PyUnicode_GetDefaultEncoding();
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000895#endif
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000896
897 /* Get output buffer parameter:
898 's' (recode all objects via Unicode) or
899 't' (only recode non-string objects)
900 */
901 if (*format == 's')
902 recode_strings = 1;
903 else if (*format == 't')
904 recode_strings = 0;
905 else
906 return converterr(
907 "(unknown parser marker combination)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000908 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000909 buffer = (char **)va_arg(*p_va, char **);
910 format++;
911 if (buffer == NULL)
912 return converterr("(buffer is NULL)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000913 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000914
915 /* Encode object */
916 if (!recode_strings && PyString_Check(arg)) {
917 s = arg;
918 Py_INCREF(s);
919 }
920 else {
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000921#ifdef Py_USING_UNICODE
922 PyObject *u;
923
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000924 /* Convert object to Unicode */
925 u = PyUnicode_FromObject(arg);
926 if (u == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000927 return converterr(
928 "string or unicode or text buffer",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000929 arg, msgbuf, bufsize);
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000930
931 /* Encode object; use default error handling */
932 s = PyUnicode_AsEncodedString(u,
933 encoding,
934 NULL);
935 Py_DECREF(u);
936 if (s == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000937 return converterr("(encoding failed)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000938 arg, msgbuf, bufsize);
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000939 if (!PyString_Check(s)) {
940 Py_DECREF(s);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000941 return converterr(
942 "(encoder failed to return a string)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000943 arg, msgbuf, bufsize);
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000944 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000945#else
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000946 return converterr("string<e>", arg, msgbuf, bufsize);
Martin v. Löwis339d0f72001-08-17 18:39:25 +0000947#endif
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000948 }
949 size = PyString_GET_SIZE(s);
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000950
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000951 /* Write output; output is guaranteed to be 0-terminated */
952 if (*format == '#') {
953 /* Using buffer length parameter '#':
954
955 - if *buffer is NULL, a new buffer of the
956 needed size is allocated and the data
957 copied into it; *buffer is updated to point
958 to the new buffer; the caller is
959 responsible for PyMem_Free()ing it after
960 usage
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000961
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000962 - if *buffer is not NULL, the data is
963 copied to *buffer; *buffer_len has to be
964 set to the size of the buffer on input;
965 buffer overflow is signalled with an error;
966 buffer has to provide enough room for the
967 encoded string plus the trailing 0-byte
968
969 - in both cases, *buffer_len is updated to
970 the size of the buffer /excluding/ the
971 trailing 0-byte
972
973 */
Martin v. Löwis18e16552006-02-15 17:27:45 +0000974 FETCH_SIZE;
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000975
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000976 format++;
Martin v. Löwis18e16552006-02-15 17:27:45 +0000977 if (q == NULL && q2 == NULL) {
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000978 Py_DECREF(s);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000979 return converterr(
980 "(buffer_len is NULL)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000981 arg, msgbuf, bufsize);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000982 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000983 if (*buffer == NULL) {
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000984 *buffer = PyMem_NEW(char, size + 1);
985 if (*buffer == NULL) {
986 Py_DECREF(s);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000987 return converterr(
988 "(memory error)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +0000989 arg, msgbuf, bufsize);
Guido van Rossumd8855fd2000-03-24 22:14:19 +0000990 }
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +0000991 if(addcleanup(*buffer, freelist)) {
992 Py_DECREF(s);
993 return converterr(
994 "(cleanup problem)",
995 arg, msgbuf, bufsize);
996 }
Fred Drake25871c02000-05-03 15:17:02 +0000997 } else {
Martin v. Löwis18e16552006-02-15 17:27:45 +0000998 if (size + 1 > BUFFER_LEN) {
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +0000999 Py_DECREF(s);
1000 return converterr(
1001 "(buffer overflow)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001002 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001003 }
Fred Drake25871c02000-05-03 15:17:02 +00001004 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001005 memcpy(*buffer,
1006 PyString_AS_STRING(s),
1007 size + 1);
Martin v. Löwis18e16552006-02-15 17:27:45 +00001008 STORE_SIZE(size);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001009 } else {
1010 /* Using a 0-terminated buffer:
1011
1012 - the encoded string has to be 0-terminated
1013 for this variant to work; if it is not, an
1014 error raised
Fred Drake25871c02000-05-03 15:17:02 +00001015
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001016 - a new buffer of the needed size is
1017 allocated and the data copied into it;
1018 *buffer is updated to point to the new
1019 buffer; the caller is responsible for
1020 PyMem_Free()ing it after usage
1021
1022 */
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001023 if ((int)strlen(PyString_AS_STRING(s)) != size) {
1024 Py_DECREF(s);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001025 return converterr(
1026 "(encoded string without NULL bytes)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001027 arg, msgbuf, bufsize);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001028 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001029 *buffer = PyMem_NEW(char, size + 1);
1030 if (*buffer == NULL) {
1031 Py_DECREF(s);
1032 return converterr("(memory error)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001033 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001034 }
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001035 if(addcleanup(*buffer, freelist)) {
1036 Py_DECREF(s);
1037 return converterr("(cleanup problem)",
1038 arg, msgbuf, bufsize);
1039 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001040 memcpy(*buffer,
1041 PyString_AS_STRING(s),
1042 size + 1);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00001043 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001044 Py_DECREF(s);
1045 break;
1046 }
1047
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001048#ifdef Py_USING_UNICODE
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001049 case 'u': {/* raw unicode buffer (Py_UNICODE *) */
1050 if (*format == '#') { /* any buffer-like object */
1051 void **p = (void **)va_arg(*p_va, char **);
Martin v. Löwis18e16552006-02-15 17:27:45 +00001052 FETCH_SIZE;
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00001053 if (PyUnicode_Check(arg)) {
1054 *p = PyUnicode_AS_UNICODE(arg);
Martin v. Löwis18e16552006-02-15 17:27:45 +00001055 STORE_SIZE(PyUnicode_GET_SIZE(arg));
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00001056 }
1057 else {
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001058 return converterr("cannot convert raw buffers",
1059 arg, msgbuf, bufsize);
Marc-André Lemburg3e3eacb2002-01-09 16:21:27 +00001060 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001061 format++;
1062 } else {
1063 Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);
Guido van Rossume826ef02000-03-10 23:02:17 +00001064 if (PyUnicode_Check(arg))
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001065 *p = PyUnicode_AS_UNICODE(arg);
1066 else
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001067 return converterr("unicode", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001068 }
1069 break;
1070 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001071#endif
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001072
1073 case 'S': { /* string object */
1074 PyObject **p = va_arg(*p_va, PyObject **);
1075 if (PyString_Check(arg))
1076 *p = arg;
1077 else
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001078 return converterr("string", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001079 break;
1080 }
1081
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001082#ifdef Py_USING_UNICODE
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001083 case 'U': { /* Unicode object */
1084 PyObject **p = va_arg(*p_va, PyObject **);
1085 if (PyUnicode_Check(arg))
1086 *p = arg;
1087 else
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001088 return converterr("unicode", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001089 break;
1090 }
Martin v. Löwis339d0f72001-08-17 18:39:25 +00001091#endif
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001092
1093 case 'O': { /* object */
1094 PyTypeObject *type;
1095 PyObject **p;
1096 if (*format == '!') {
1097 type = va_arg(*p_va, PyTypeObject*);
1098 p = va_arg(*p_va, PyObject **);
1099 format++;
Guido van Rossumcbfc8552001-08-28 16:37:51 +00001100 if (PyType_IsSubtype(arg->ob_type, type))
Guido van Rossume826ef02000-03-10 23:02:17 +00001101 *p = arg;
1102 else
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001103 return converterr(type->tp_name, arg, msgbuf, bufsize);
Guido van Rossumfccfe891998-05-15 22:04:07 +00001104
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001105 }
1106 else if (*format == '?') {
1107 inquiry pred = va_arg(*p_va, inquiry);
1108 p = va_arg(*p_va, PyObject **);
1109 format++;
1110 if ((*pred)(arg))
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00001111 *p = arg;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001112 else
1113 return converterr("(unspecified)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001114 arg, msgbuf, bufsize);
Guido van Rossumfdf95dd1997-05-05 22:15:02 +00001115
Guido van Rossumfdf95dd1997-05-05 22:15:02 +00001116 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001117 else if (*format == '&') {
1118 typedef int (*converter)(PyObject *, void *);
1119 converter convert = va_arg(*p_va, converter);
1120 void *addr = va_arg(*p_va, void *);
1121 format++;
1122 if (! (*convert)(arg, addr))
1123 return converterr("(unspecified)",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001124 arg, msgbuf, bufsize);
Guido van Rossumb317f8a1998-10-08 02:21:21 +00001125 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001126 else {
1127 p = va_arg(*p_va, PyObject **);
1128 *p = arg;
1129 }
1130 break;
1131 }
Guido van Rossumb317f8a1998-10-08 02:21:21 +00001132
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001133
1134 case 'w': { /* memory buffer, read-write access */
1135 void **p = va_arg(*p_va, void **);
1136 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
1137 int count;
1138
1139 if (pb == NULL ||
1140 pb->bf_getwritebuffer == NULL ||
1141 pb->bf_getsegcount == NULL)
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001142 return converterr("read-write buffer", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001143 if ((*pb->bf_getsegcount)(arg, NULL) != 1)
1144 return converterr("single-segment read-write buffer",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001145 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001146 if ((count = pb->bf_getwritebuffer(arg, 0, p)) < 0)
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001147 return converterr("(unspecified)", arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001148 if (*format == '#') {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001149 FETCH_SIZE;
1150 STORE_SIZE(count);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001151 format++;
1152 }
1153 break;
1154 }
1155
1156 case 't': { /* 8-bit character buffer, read-only access */
Martin v. Löwis15e62742006-02-27 16:46:16 +00001157 char **p = va_arg(*p_va, char **);
Jeremy Hylton4819e972001-10-11 14:40:37 +00001158 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001159 int count;
1160
1161 if (*format++ != '#')
1162 return converterr(
1163 "invalid use of 't' format character",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001164 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001165 if (!PyType_HasFeature(arg->ob_type,
Jeremy Hylton4819e972001-10-11 14:40:37 +00001166 Py_TPFLAGS_HAVE_GETCHARBUFFER) ||
1167 pb == NULL || pb->bf_getcharbuffer == NULL ||
1168 pb->bf_getsegcount == NULL)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001169 return converterr(
1170 "string or read-only character buffer",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001171 arg, msgbuf, bufsize);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001172
Jeremy Hylton4819e972001-10-11 14:40:37 +00001173 if (pb->bf_getsegcount(arg, NULL) != 1)
1174 return converterr(
1175 "string or single-segment read-only buffer",
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001176 arg, msgbuf, bufsize);
Jeremy Hylton4819e972001-10-11 14:40:37 +00001177
1178 count = pb->bf_getcharbuffer(arg, 0, p);
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001179 if (count < 0)
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001180 return converterr("(unspecified)", arg, msgbuf, bufsize);
Martin v. Löwis18e16552006-02-15 17:27:45 +00001181 {
1182 FETCH_SIZE;
1183 STORE_SIZE(count);
1184 }
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001185 break;
1186 }
1187
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00001188 default:
Jeremy Hyltonb048b262001-11-28 22:14:37 +00001189 return converterr("impossible<bad format char>", arg, msgbuf, bufsize);
Guido van Rossumfe3f1a21994-09-29 09:42:55 +00001190
1191 }
1192
1193 *p_format = format;
1194 return NULL;
1195}
Guido van Rossumaa354651996-08-19 19:32:04 +00001196
Martin v. Löwis18e16552006-02-15 17:27:45 +00001197static Py_ssize_t
Fred Drake563dfc22001-10-23 14:41:08 +00001198convertbuffer(PyObject *arg, void **p, char **errmsg)
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001199{
1200 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
Martin v. Löwis18e16552006-02-15 17:27:45 +00001201 Py_ssize_t count;
Jeremy Hylton1cb7aa32001-05-29 17:37:05 +00001202 if (pb == NULL ||
1203 pb->bf_getreadbuffer == NULL ||
1204 pb->bf_getsegcount == NULL) {
1205 *errmsg = "string or read-only buffer";
1206 return -1;
1207 }
1208 if ((*pb->bf_getsegcount)(arg, NULL) != 1) {
1209 *errmsg = "string or single-segment read-only buffer";
1210 return -1;
1211 }
1212 if ((count = (*pb->bf_getreadbuffer)(arg, 0, p)) < 0) {
1213 *errmsg = "(unspecified)";
1214 }
1215 return count;
1216}
Guido van Rossumaa354651996-08-19 19:32:04 +00001217
1218/* Support for keyword arguments donated by
1219 Geoff Philbrick <philbric@delphi.hks.com> */
1220
Tim Petersf8cd3e82001-10-27 04:26:57 +00001221/* Return false (0) for error, else true. */
Fred Drake563dfc22001-10-23 14:41:08 +00001222int
1223PyArg_ParseTupleAndKeywords(PyObject *args,
1224 PyObject *keywords,
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001225 const char *format,
Martin v. Löwis15e62742006-02-27 16:46:16 +00001226 char **kwlist, ...)
Guido van Rossumaa354651996-08-19 19:32:04 +00001227{
1228 int retval;
1229 va_list va;
Tim Peters45772cd2001-10-27 03:58:40 +00001230
1231 if ((args == NULL || !PyTuple_Check(args)) ||
1232 (keywords != NULL && !PyDict_Check(keywords)) ||
1233 format == NULL ||
1234 kwlist == NULL)
1235 {
1236 PyErr_BadInternalCall();
Tim Petersf8cd3e82001-10-27 04:26:57 +00001237 return 0;
Tim Peters45772cd2001-10-27 03:58:40 +00001238 }
1239
Guido van Rossumaa354651996-08-19 19:32:04 +00001240 va_start(va, kwlist);
Martin v. Löwis18e16552006-02-15 17:27:45 +00001241 retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0);
1242 va_end(va);
1243 return retval;
1244}
1245
1246int
1247_PyArg_ParseTupleAndKeywords_SizeT(PyObject *args,
1248 PyObject *keywords,
1249 const char *format,
Martin v. Löwis15e62742006-02-27 16:46:16 +00001250 char **kwlist, ...)
Martin v. Löwis18e16552006-02-15 17:27:45 +00001251{
1252 int retval;
1253 va_list va;
1254
1255 if ((args == NULL || !PyTuple_Check(args)) ||
1256 (keywords != NULL && !PyDict_Check(keywords)) ||
1257 format == NULL ||
1258 kwlist == NULL)
1259 {
1260 PyErr_BadInternalCall();
1261 return 0;
1262 }
1263
1264 va_start(va, kwlist);
1265 retval = vgetargskeywords(args, keywords, format,
1266 kwlist, &va, FLAG_SIZE_T);
Guido van Rossumaa354651996-08-19 19:32:04 +00001267 va_end(va);
1268 return retval;
1269}
1270
1271
Brett Cannon711e7d92004-07-10 22:20:32 +00001272int
1273PyArg_VaParseTupleAndKeywords(PyObject *args,
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001274 PyObject *keywords,
1275 const char *format,
Martin v. Löwis15e62742006-02-27 16:46:16 +00001276 char **kwlist, va_list va)
Brett Cannon711e7d92004-07-10 22:20:32 +00001277{
1278 int retval;
1279 va_list lva;
1280
1281 if ((args == NULL || !PyTuple_Check(args)) ||
1282 (keywords != NULL && !PyDict_Check(keywords)) ||
1283 format == NULL ||
1284 kwlist == NULL)
1285 {
1286 PyErr_BadInternalCall();
1287 return 0;
1288 }
1289
1290#ifdef VA_LIST_IS_ARRAY
1291 memcpy(lva, va, sizeof(va_list));
1292#else
1293#ifdef __va_copy
1294 __va_copy(lva, va);
1295#else
1296 lva = va;
1297#endif
1298#endif
1299
Martin v. Löwis18e16552006-02-15 17:27:45 +00001300 retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0);
1301 return retval;
1302}
1303
1304int
1305_PyArg_VaParseTupleAndKeywords_SizeT(PyObject *args,
1306 PyObject *keywords,
1307 const char *format,
Martin v. Löwis15e62742006-02-27 16:46:16 +00001308 char **kwlist, va_list va)
Martin v. Löwis18e16552006-02-15 17:27:45 +00001309{
1310 int retval;
1311 va_list lva;
1312
1313 if ((args == NULL || !PyTuple_Check(args)) ||
1314 (keywords != NULL && !PyDict_Check(keywords)) ||
1315 format == NULL ||
1316 kwlist == NULL)
1317 {
1318 PyErr_BadInternalCall();
1319 return 0;
1320 }
1321
1322#ifdef VA_LIST_IS_ARRAY
1323 memcpy(lva, va, sizeof(va_list));
1324#else
1325#ifdef __va_copy
1326 __va_copy(lva, va);
1327#else
1328 lva = va;
1329#endif
1330#endif
1331
1332 retval = vgetargskeywords(args, keywords, format,
1333 kwlist, &lva, FLAG_SIZE_T);
Brett Cannon711e7d92004-07-10 22:20:32 +00001334 return retval;
1335}
1336
1337
Guido van Rossumaa354651996-08-19 19:32:04 +00001338static int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001339vgetargskeywords(PyObject *args, PyObject *keywords, const char *format,
Martin v. Löwis15e62742006-02-27 16:46:16 +00001340 char **kwlist, va_list *p_va, int flags)
Guido van Rossumaa354651996-08-19 19:32:04 +00001341{
Tim Petersdc5eff92001-10-27 06:53:00 +00001342 char msgbuf[512];
Guido van Rossumaa354651996-08-19 19:32:04 +00001343 int levels[32];
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001344 const char *fname, *message;
Tim Petersf8cd3e82001-10-27 04:26:57 +00001345 int min, max;
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001346 const char *formatsave;
Tim Petersb639d492001-10-27 07:00:56 +00001347 int i, len, nargs, nkeywords;
Martin v. Löwis15e62742006-02-27 16:46:16 +00001348 const char *msg;
1349 char **p;
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001350 PyObject *freelist = NULL;
Tim Petersf4331c12001-10-27 00:17:34 +00001351
Tim Peters45772cd2001-10-27 03:58:40 +00001352 assert(args != NULL && PyTuple_Check(args));
1353 assert(keywords == NULL || PyDict_Check(keywords));
1354 assert(format != NULL);
1355 assert(kwlist != NULL);
1356 assert(p_va != NULL);
1357
Tim Petersf8cd3e82001-10-27 04:26:57 +00001358 /* Search the format:
1359 message <- error msg, if any (else NULL).
Tim Peterscffed4b2001-11-29 03:26:37 +00001360 fname <- routine name, if any (else NULL).
Tim Petersf8cd3e82001-10-27 04:26:57 +00001361 min <- # of required arguments, or -1 if all are required.
1362 max <- most arguments (required + optional).
Tim Peters62d48e12001-10-27 06:42:16 +00001363 Check that kwlist has a non-NULL entry for each arg.
Tim Petersf8cd3e82001-10-27 04:26:57 +00001364 Raise error if a tuple arg spec is found.
1365 */
1366 fname = message = NULL;
Tim Peters6fb26352001-10-27 04:38:11 +00001367 formatsave = format;
Tim Peters62d48e12001-10-27 06:42:16 +00001368 p = kwlist;
Tim Petersf8cd3e82001-10-27 04:26:57 +00001369 min = -1;
1370 max = 0;
1371 while ((i = *format++) != '\0') {
Neal Norwitz30b5c5d2005-12-19 06:05:18 +00001372 if (isalpha(Py_CHARMASK(i)) && i != 'e') {
Tim Petersf8cd3e82001-10-27 04:26:57 +00001373 max++;
Tim Peters62d48e12001-10-27 06:42:16 +00001374 if (*p == NULL) {
Tim Peterscffed4b2001-11-29 03:26:37 +00001375 PyErr_SetString(PyExc_RuntimeError,
1376 "more argument specifiers than "
1377 "keyword list entries");
Tim Peters62d48e12001-10-27 06:42:16 +00001378 return 0;
1379 }
1380 p++;
1381 }
Tim Petersf8cd3e82001-10-27 04:26:57 +00001382 else if (i == '|')
1383 min = max;
1384 else if (i == ':') {
1385 fname = format;
1386 break;
1387 }
1388 else if (i == ';') {
1389 message = format;
1390 break;
1391 }
1392 else if (i == '(') {
Tim Peterscffed4b2001-11-29 03:26:37 +00001393 PyErr_SetString(PyExc_RuntimeError,
1394 "tuple found in format when using keyword "
1395 "arguments");
Guido van Rossumaa354651996-08-19 19:32:04 +00001396 return 0;
1397 }
Tim Peters62d48e12001-10-27 06:42:16 +00001398 }
1399 format = formatsave;
1400 if (*p != NULL) {
Tim Peterscffed4b2001-11-29 03:26:37 +00001401 PyErr_SetString(PyExc_RuntimeError,
1402 "more keyword list entries than "
1403 "argument specifiers");
Tim Peters62d48e12001-10-27 06:42:16 +00001404 return 0;
1405 }
Tim Petersf8cd3e82001-10-27 04:26:57 +00001406 if (min < 0) {
1407 /* All arguments are required. */
Guido van Rossumaa354651996-08-19 19:32:04 +00001408 min = max;
Tim Petersf8cd3e82001-10-27 04:26:57 +00001409 }
Tim Petersf8cd3e82001-10-27 04:26:57 +00001410
Tim Peters6fb26352001-10-27 04:38:11 +00001411 nargs = PyTuple_GET_SIZE(args);
Tim Petersb0872fc2001-10-27 04:45:34 +00001412 nkeywords = keywords == NULL ? 0 : PyDict_Size(keywords);
Tim Petersf8cd3e82001-10-27 04:26:57 +00001413
Guido van Rossumaa354651996-08-19 19:32:04 +00001414 /* make sure there are no duplicate values for an argument;
1415 its not clear when to use the term "keyword argument vs.
1416 keyword parameter in messages */
Tim Petersb054be42001-10-27 05:07:41 +00001417 if (nkeywords > 0) {
Tim Peters6fb26352001-10-27 04:38:11 +00001418 for (i = 0; i < nargs; i++) {
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001419 const char *thiskw = kwlist[i];
Tim Petersa9f47392001-10-27 00:46:09 +00001420 if (thiskw == NULL)
1421 break;
Tim Peters077f5742001-10-27 05:50:39 +00001422 if (PyDict_GetItemString(keywords, thiskw)) {
Tim Petersb054be42001-10-27 05:07:41 +00001423 PyErr_Format(PyExc_TypeError,
1424 "keyword parameter '%s' was given "
1425 "by position and by name",
Tim Petersa9f47392001-10-27 00:46:09 +00001426 thiskw);
Guido van Rossumaa354651996-08-19 19:32:04 +00001427 return 0;
1428 }
Tim Peters0af49162001-10-27 06:14:32 +00001429 else if (PyErr_Occurred())
1430 return 0;
Guido van Rossumaa354651996-08-19 19:32:04 +00001431 }
1432 }
Tim Peters61dde632001-10-27 05:30:17 +00001433
Guido van Rossumaa354651996-08-19 19:32:04 +00001434 /* required arguments missing from args can be supplied by keyword
Georg Brandld7048172006-01-20 17:53:27 +00001435 arguments; set len to the number of positional arguments, and,
Tim Peters62d48e12001-10-27 06:42:16 +00001436 if that's less than the minimum required, add in the number of
1437 required arguments that are supplied by keywords */
Tim Peters6fb26352001-10-27 04:38:11 +00001438 len = nargs;
Tim Peters62d48e12001-10-27 06:42:16 +00001439 if (nkeywords > 0 && nargs < min) {
Tim Peters6fb26352001-10-27 04:38:11 +00001440 for (i = nargs; i < min; i++) {
Tim Peters077f5742001-10-27 05:50:39 +00001441 if (PyDict_GetItemString(keywords, kwlist[i]))
Guido van Rossumaa354651996-08-19 19:32:04 +00001442 len++;
Tim Peters0af49162001-10-27 06:14:32 +00001443 else if (PyErr_Occurred())
1444 return 0;
Guido van Rossumaa354651996-08-19 19:32:04 +00001445 }
1446 }
Tim Peters0af49162001-10-27 06:14:32 +00001447
Guido van Rossumaa354651996-08-19 19:32:04 +00001448 /* make sure we got an acceptable number of arguments; the message
1449 is a little confusing with keywords since keyword arguments
1450 which are supplied, but don't match the required arguments
Michael W. Hudson5253c302005-03-30 16:41:55 +00001451 are not included in the "%d given" part of the message
1452 XXX and this isn't a bug!? */
Guido van Rossumaa354651996-08-19 19:32:04 +00001453 if (len < min || max < len) {
1454 if (message == NULL) {
Jeremy Hylton23ae9872001-11-28 20:29:22 +00001455 PyOS_snprintf(msgbuf, sizeof(msgbuf),
1456 "%.200s%s takes %s %d argument%s "
1457 "(%d given)",
1458 fname==NULL ? "function" : fname,
1459 fname==NULL ? "" : "()",
1460 min==max ? "exactly"
1461 : len < min ? "at least" : "at most",
1462 len < min ? min : max,
1463 (len < min ? min : max) == 1 ? "" : "s",
1464 len);
Guido van Rossumaa354651996-08-19 19:32:04 +00001465 message = msgbuf;
1466 }
1467 PyErr_SetString(PyExc_TypeError, message);
1468 return 0;
1469 }
Tim Petersc2f01122001-10-27 07:25:06 +00001470
1471 /* convert the positional arguments */
Tim Peters6fb26352001-10-27 04:38:11 +00001472 for (i = 0; i < nargs; i++) {
Guido van Rossumaa354651996-08-19 19:32:04 +00001473 if (*format == '|')
1474 format++;
Jeremy Hylton0f8117f2001-05-18 20:57:38 +00001475 msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,
Martin v. Löwis18e16552006-02-15 17:27:45 +00001476 flags, levels, msgbuf, sizeof(msgbuf),
1477 &freelist);
Guido van Rossumaa354651996-08-19 19:32:04 +00001478 if (msg) {
1479 seterror(i+1, msg, levels, fname, message);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001480 return cleanreturn(0, freelist);
Guido van Rossumaa354651996-08-19 19:32:04 +00001481 }
1482 }
1483
Tim Petersc2f01122001-10-27 07:25:06 +00001484 /* handle no keyword parameters in call */
Tim Petersb054be42001-10-27 05:07:41 +00001485 if (nkeywords == 0)
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001486 return cleanreturn(1, freelist);
Tim Petersb054be42001-10-27 05:07:41 +00001487
Guido van Rossumaa354651996-08-19 19:32:04 +00001488 /* convert the keyword arguments; this uses the format
1489 string where it was left after processing args */
Tim Petersb639d492001-10-27 07:00:56 +00001490 for (i = nargs; i < max; i++) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001491 PyObject *item;
Guido van Rossumaa354651996-08-19 19:32:04 +00001492 if (*format == '|')
1493 format++;
Tim Peters077f5742001-10-27 05:50:39 +00001494 item = PyDict_GetItemString(keywords, kwlist[i]);
Guido van Rossum80bb9651996-12-05 23:27:02 +00001495 if (item != NULL) {
Tim Peters077f5742001-10-27 05:50:39 +00001496 Py_INCREF(item);
Martin v. Löwis18e16552006-02-15 17:27:45 +00001497 msg = convertitem(item, &format, p_va, flags, levels,
1498 msgbuf, sizeof(msgbuf), &freelist);
Tim Peters077f5742001-10-27 05:50:39 +00001499 Py_DECREF(item);
Guido van Rossumaa354651996-08-19 19:32:04 +00001500 if (msg) {
1501 seterror(i+1, msg, levels, fname, message);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001502 return cleanreturn(0, freelist);
Guido van Rossumaa354651996-08-19 19:32:04 +00001503 }
Tim Petersc2f01122001-10-27 07:25:06 +00001504 --nkeywords;
1505 if (nkeywords == 0)
1506 break;
Guido van Rossumaa354651996-08-19 19:32:04 +00001507 }
Tim Peters0af49162001-10-27 06:14:32 +00001508 else if (PyErr_Occurred())
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001509 return cleanreturn(0, freelist);
Guido van Rossumaa354651996-08-19 19:32:04 +00001510 else {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001511 msg = skipitem(&format, p_va, flags);
Guido van Rossumaa354651996-08-19 19:32:04 +00001512 if (msg) {
1513 seterror(i+1, msg, levels, fname, message);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001514 return cleanreturn(0, freelist);
Guido van Rossumaa354651996-08-19 19:32:04 +00001515 }
1516 }
1517 }
Tim Petersb054be42001-10-27 05:07:41 +00001518
Guido van Rossumaa354651996-08-19 19:32:04 +00001519 /* make sure there are no extraneous keyword arguments */
Tim Petersc2f01122001-10-27 07:25:06 +00001520 if (nkeywords > 0) {
1521 PyObject *key, *value;
Martin v. Löwis18e16552006-02-15 17:27:45 +00001522 Py_ssize_t pos = 0;
Guido van Rossumaa354651996-08-19 19:32:04 +00001523 while (PyDict_Next(keywords, &pos, &key, &value)) {
Tim Petersc2f01122001-10-27 07:25:06 +00001524 int match = 0;
Guido van Rossum55474762002-04-04 16:22:30 +00001525 char *ks;
1526 if (!PyString_Check(key)) {
1527 PyErr_SetString(PyExc_TypeError,
1528 "keywords must be strings");
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001529 return cleanreturn(0, freelist);
Guido van Rossum55474762002-04-04 16:22:30 +00001530 }
1531 ks = PyString_AsString(key);
Tim Petersb639d492001-10-27 07:00:56 +00001532 for (i = 0; i < max; i++) {
Guido van Rossumaa354651996-08-19 19:32:04 +00001533 if (!strcmp(ks, kwlist[i])) {
1534 match = 1;
1535 break;
1536 }
1537 }
1538 if (!match) {
Tim Petersc2f01122001-10-27 07:25:06 +00001539 PyErr_Format(PyExc_TypeError,
1540 "'%s' is an invalid keyword "
1541 "argument for this function",
1542 ks);
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001543 return cleanreturn(0, freelist);
Guido van Rossumaa354651996-08-19 19:32:04 +00001544 }
1545 }
1546 }
Tim Petersc2f01122001-10-27 07:25:06 +00001547
Martin v. Löwise6bbb4d2003-05-03 10:00:22 +00001548 return cleanreturn(1, freelist);
Guido van Rossumaa354651996-08-19 19:32:04 +00001549}
1550
1551
1552static char *
Martin v. Löwis18e16552006-02-15 17:27:45 +00001553skipitem(const char **p_format, va_list *p_va, int flags)
Guido van Rossumaa354651996-08-19 19:32:04 +00001554{
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001555 const char *format = *p_format;
Guido van Rossumaa354651996-08-19 19:32:04 +00001556 char c = *format++;
1557
1558 switch (c) {
Georg Brandl6dd14612005-09-14 19:29:53 +00001559
1560 /* simple codes
1561 * The individual types (second arg of va_arg) are irrelevant */
1562
Guido van Rossumaa354651996-08-19 19:32:04 +00001563 case 'b': /* byte -- very short int */
Jack Jansencc22fbe2000-08-05 21:29:58 +00001564 case 'B': /* byte as bitfield */
Guido van Rossumaa354651996-08-19 19:32:04 +00001565 case 'h': /* short int */
Jack Jansencc22fbe2000-08-05 21:29:58 +00001566 case 'H': /* short int as bitfield */
Guido van Rossumaa354651996-08-19 19:32:04 +00001567 case 'i': /* int */
Georg Brandl6dd14612005-09-14 19:29:53 +00001568 case 'I': /* int sized bitfield */
Guido van Rossumaa354651996-08-19 19:32:04 +00001569 case 'l': /* long int */
Georg Brandl6dd14612005-09-14 19:29:53 +00001570 case 'k': /* long int sized bitfield */
Guido van Rossum3dbba6e1999-01-25 21:48:56 +00001571#ifdef HAVE_LONG_LONG
Georg Brandl6dd14612005-09-14 19:29:53 +00001572 case 'L': /* PY_LONG_LONG */
1573 case 'K': /* PY_LONG_LONG sized bitfield */
Guido van Rossum1a8791e1998-08-04 22:46:29 +00001574#endif
Guido van Rossumaa354651996-08-19 19:32:04 +00001575 case 'f': /* float */
Guido van Rossumaa354651996-08-19 19:32:04 +00001576 case 'd': /* double */
Guido van Rossumaa354651996-08-19 19:32:04 +00001577#ifndef WITHOUT_COMPLEX
1578 case 'D': /* complex double */
Georg Brandl6dd14612005-09-14 19:29:53 +00001579#endif
Guido van Rossumaa354651996-08-19 19:32:04 +00001580 case 'c': /* char */
1581 {
Georg Brandl6dd14612005-09-14 19:29:53 +00001582 (void) va_arg(*p_va, void *);
Guido van Rossumaa354651996-08-19 19:32:04 +00001583 break;
1584 }
Martin v. Löwis18e16552006-02-15 17:27:45 +00001585
1586 case 'n': /* Py_ssize_t */
1587 {
1588 (void) va_arg(*p_va, Py_ssize_t *);
1589 break;
1590 }
Guido van Rossumaa354651996-08-19 19:32:04 +00001591
Georg Brandl6dd14612005-09-14 19:29:53 +00001592 /* string codes */
1593
1594 case 'e': /* string with encoding */
1595 {
1596 (void) va_arg(*p_va, const char *);
1597 if (!(*format == 's' || *format == 't'))
1598 /* after 'e', only 's' and 't' is allowed */
1599 goto err;
1600 format++;
1601 /* explicit fallthrough to string cases */
1602 }
1603
Guido van Rossumaa354651996-08-19 19:32:04 +00001604 case 's': /* string */
Georg Brandl6dd14612005-09-14 19:29:53 +00001605 case 'z': /* string or None */
1606#ifdef Py_USING_UNICODE
1607 case 'u': /* unicode string */
1608#endif
1609 case 't': /* buffer, read-only */
1610 case 'w': /* buffer, read-write */
Guido van Rossumaa354651996-08-19 19:32:04 +00001611 {
Guido van Rossum80bb9651996-12-05 23:27:02 +00001612 (void) va_arg(*p_va, char **);
Guido van Rossumaa354651996-08-19 19:32:04 +00001613 if (*format == '#') {
Martin v. Löwis18e16552006-02-15 17:27:45 +00001614 if (flags & FLAG_SIZE_T)
1615 (void) va_arg(*p_va, Py_ssize_t *);
1616 else
1617 (void) va_arg(*p_va, int *);
Guido van Rossumaa354651996-08-19 19:32:04 +00001618 format++;
1619 }
1620 break;
1621 }
Georg Brandl6dd14612005-09-14 19:29:53 +00001622
1623 /* object codes */
1624
Guido van Rossumaa354651996-08-19 19:32:04 +00001625 case 'S': /* string object */
Georg Brandl6dd14612005-09-14 19:29:53 +00001626#ifdef Py_USING_UNICODE
1627 case 'U': /* unicode string object */
1628#endif
Guido van Rossumaa354651996-08-19 19:32:04 +00001629 {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001630 (void) va_arg(*p_va, PyObject **);
Guido van Rossumaa354651996-08-19 19:32:04 +00001631 break;
1632 }
1633
1634 case 'O': /* object */
1635 {
Guido van Rossumaa354651996-08-19 19:32:04 +00001636 if (*format == '!') {
1637 format++;
Guido van Rossum79f25d91997-04-29 20:08:16 +00001638 (void) va_arg(*p_va, PyTypeObject*);
1639 (void) va_arg(*p_va, PyObject **);
Guido van Rossumaa354651996-08-19 19:32:04 +00001640 }
1641#if 0
1642/* I don't know what this is for */
1643 else if (*format == '?') {
1644 inquiry pred = va_arg(*p_va, inquiry);
1645 format++;
1646 if ((*pred)(arg)) {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001647 (void) va_arg(*p_va, PyObject **);
Guido van Rossumaa354651996-08-19 19:32:04 +00001648 }
1649 }
1650#endif
1651 else if (*format == '&') {
Tim Petersdbd9ba62000-07-09 03:09:57 +00001652 typedef int (*converter)(PyObject *, void *);
Guido van Rossum80bb9651996-12-05 23:27:02 +00001653 (void) va_arg(*p_va, converter);
1654 (void) va_arg(*p_va, void *);
Guido van Rossumaa354651996-08-19 19:32:04 +00001655 format++;
1656 }
1657 else {
Guido van Rossum79f25d91997-04-29 20:08:16 +00001658 (void) va_arg(*p_va, PyObject **);
Guido van Rossumaa354651996-08-19 19:32:04 +00001659 }
1660 break;
1661 }
1662
1663 default:
Georg Brandl6dd14612005-09-14 19:29:53 +00001664err:
Guido van Rossumaa354651996-08-19 19:32:04 +00001665 return "impossible<bad format char>";
1666
1667 }
Georg Brandl6dd14612005-09-14 19:29:53 +00001668
1669 /* The "(...)" format code for tuples is not handled here because
1670 * it is not allowed with keyword args. */
Guido van Rossumaa354651996-08-19 19:32:04 +00001671
1672 *p_format = format;
1673 return NULL;
1674}
Fred Drakee4616e62001-10-23 21:09:29 +00001675
1676
1677int
Martin v. Löwis76246742006-03-01 04:06:10 +00001678PyArg_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, ...)
Fred Drakee4616e62001-10-23 21:09:29 +00001679{
Martin v. Löwis76246742006-03-01 04:06:10 +00001680 Py_ssize_t i, l;
Fred Drakee4616e62001-10-23 21:09:29 +00001681 PyObject **o;
1682 va_list vargs;
1683
1684#ifdef HAVE_STDARG_PROTOTYPES
1685 va_start(vargs, max);
1686#else
1687 va_start(vargs);
1688#endif
1689
1690 assert(min >= 0);
1691 assert(min <= max);
1692 if (!PyTuple_Check(args)) {
1693 PyErr_SetString(PyExc_SystemError,
1694 "PyArg_UnpackTuple() argument list is not a tuple");
1695 return 0;
1696 }
1697 l = PyTuple_GET_SIZE(args);
1698 if (l < min) {
1699 if (name != NULL)
1700 PyErr_Format(
1701 PyExc_TypeError,
Thomas Wouters572a9f32006-03-01 05:38:39 +00001702 "%s expected %s%zd arguments, got %zd",
Fred Drakee4616e62001-10-23 21:09:29 +00001703 name, (min == max ? "" : "at least "), min, l);
1704 else
1705 PyErr_Format(
1706 PyExc_TypeError,
Thomas Wouters572a9f32006-03-01 05:38:39 +00001707 "unpacked tuple should have %s%zd elements,"
1708 " but has %zd",
Fred Drakee4616e62001-10-23 21:09:29 +00001709 (min == max ? "" : "at least "), min, l);
1710 va_end(vargs);
1711 return 0;
1712 }
1713 if (l > max) {
1714 if (name != NULL)
1715 PyErr_Format(
1716 PyExc_TypeError,
Thomas Wouters572a9f32006-03-01 05:38:39 +00001717 "%s expected %s%zd arguments, got %zd",
Fred Drakee4616e62001-10-23 21:09:29 +00001718 name, (min == max ? "" : "at most "), max, l);
1719 else
1720 PyErr_Format(
1721 PyExc_TypeError,
Thomas Wouters572a9f32006-03-01 05:38:39 +00001722 "unpacked tuple should have %s%zd elements,"
1723 " but has %zd",
Fred Drakee4616e62001-10-23 21:09:29 +00001724 (min == max ? "" : "at most "), max, l);
1725 va_end(vargs);
1726 return 0;
1727 }
1728 for (i = 0; i < l; i++) {
1729 o = va_arg(vargs, PyObject **);
1730 *o = PyTuple_GET_ITEM(args, i);
1731 }
1732 va_end(vargs);
1733 return 1;
1734}
Georg Brandl02c42872005-08-26 06:42:30 +00001735
1736
1737/* For type constructors that don't take keyword args
1738 *
1739 * Sets a TypeError and returns 0 if the kwds dict is
1740 * not emtpy, returns 1 otherwise
1741 */
1742int
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001743_PyArg_NoKeywords(const char *funcname, PyObject *kw)
Georg Brandl02c42872005-08-26 06:42:30 +00001744{
1745 if (kw == NULL)
1746 return 1;
1747 if (!PyDict_CheckExact(kw)) {
1748 PyErr_BadInternalCall();
1749 return 0;
1750 }
1751 if (PyDict_Size(kw) == 0)
1752 return 1;
1753
1754 PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",
1755 funcname);
1756 return 0;
1757}
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001758#ifdef __cplusplus
1759};
1760#endif