]> git.proxmox.com Git - mirror_edk2.git/blame - AppPkg/Applications/Python/Python-2.7.10/Python/getargs.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS
[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.10 / Python / getargs.c
CommitLineData
c8042e10
DM		 1\r
2/* New getargs implementation */\r
3\r
4#include "Python.h"\r
5\r
6#include <ctype.h>\r
7\r
8\r
9#ifdef __cplusplus\r
10extern "C" {\r
11#endif\r
12int PyArg_Parse(PyObject *, const char *, ...);\r
13int PyArg_ParseTuple(PyObject *, const char *, ...);\r
14int PyArg_VaParse(PyObject *, const char *, va_list);\r
15\r
16int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,\r
17 const char *, char **, ...);\r
18int PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,\r
19 const char *, char **, va_list);\r
20\r
21#ifdef HAVE_DECLSPEC_DLL\r
22/* Export functions */\r
23PyAPI_FUNC(int) _PyArg_Parse_SizeT(PyObject *, char *, ...);\r
24PyAPI_FUNC(int) _PyArg_ParseTuple_SizeT(PyObject *, char *, ...);\r
25PyAPI_FUNC(int) _PyArg_ParseTupleAndKeywords_SizeT(PyObject *, PyObject *,\r
26 const char *, char **, ...);\r
27PyAPI_FUNC(PyObject *) _Py_BuildValue_SizeT(const char *, ...);\r
28PyAPI_FUNC(int) _PyArg_VaParse_SizeT(PyObject *, char *, va_list);\r
29PyAPI_FUNC(int) _PyArg_VaParseTupleAndKeywords_SizeT(PyObject *, PyObject *,\r
30 const char *, char **, va_list);\r
31#endif\r
32\r
33#define FLAG_COMPAT 1\r
34#define FLAG_SIZE_T 2\r
35\r
36\r
37/* Forward */\r
38static int vgetargs1(PyObject *, const char *, va_list *, int);\r
39static void seterror(int, const char *, int *, const char *, const char *);\r
40static char *convertitem(PyObject *, const char **, va_list *, int, int *,\r
41 char *, size_t, PyObject **);\r
42static char *converttuple(PyObject *, const char **, va_list *, int,\r
43 int *, char *, size_t, int, PyObject **);\r
44static char *convertsimple(PyObject *, const char **, va_list *, int, char *,\r
45 size_t, PyObject **);\r
46static Py_ssize_t convertbuffer(PyObject *, void **p, char **);\r
47static int getbuffer(PyObject *, Py_buffer *, char**);\r
48\r
49static int vgetargskeywords(PyObject *, PyObject *,\r
50 const char *, char **, va_list *, int);\r
51static char *skipitem(const char **, va_list *, int);\r
52\r
53int\r
54PyArg_Parse(PyObject *args, const char *format, ...)\r
55{\r
56 int retval;\r
57 va_list va;\r
58\r
59 va_start(va, format);\r
60 retval = vgetargs1(args, format, &va, FLAG_COMPAT);\r
61 va_end(va);\r
62 return retval;\r
63}\r
64\r
65int\r
66_PyArg_Parse_SizeT(PyObject *args, char *format, ...)\r
67{\r
68 int retval;\r
69 va_list va;\r
70\r
71 va_start(va, format);\r
72 retval = vgetargs1(args, format, &va, FLAG_COMPAT|FLAG_SIZE_T);\r
73 va_end(va);\r
74 return retval;\r
75}\r
76\r
77\r
78int\r
79PyArg_ParseTuple(PyObject *args, const char *format, ...)\r
80{\r
81 int retval;\r
82 va_list va;\r
83\r
84 va_start(va, format);\r
85 retval = vgetargs1(args, format, &va, 0);\r
86 va_end(va);\r
87 return retval;\r
88}\r
89\r
90int\r
91_PyArg_ParseTuple_SizeT(PyObject *args, char *format, ...)\r
92{\r
93 int retval;\r
94 va_list va;\r
95\r
96 va_start(va, format);\r
97 retval = vgetargs1(args, format, &va, FLAG_SIZE_T);\r
98 va_end(va);\r
99 return retval;\r
100}\r
101\r
102\r
103int\r
104PyArg_VaParse(PyObject *args, const char *format, va_list va)\r
105{\r
106 va_list lva;\r
107\r
108#ifdef VA_LIST_IS_ARRAY\r
109 memcpy(lva, va, sizeof(va_list));\r
110#else\r
111#ifdef __va_copy\r
112 __va_copy(lva, va);\r
113#else\r
114 lva = va;\r
115#endif\r
116#endif\r
117\r
118 return vgetargs1(args, format, &lva, 0);\r
119}\r
120\r
121int\r
122_PyArg_VaParse_SizeT(PyObject *args, char *format, va_list va)\r
123{\r
124 va_list lva;\r
125\r
126#ifdef VA_LIST_IS_ARRAY\r
127 memcpy(lva, va, sizeof(va_list));\r
128#else\r
129#ifdef __va_copy\r
130 __va_copy(lva, va);\r
131#else\r
132 lva = va;\r
133#endif\r
134#endif\r
135\r
136 return vgetargs1(args, format, &lva, FLAG_SIZE_T);\r
137}\r
138\r
139\r
140/* Handle cleanup of allocated memory in case of exception */\r
141\r
142#define GETARGS_CAPSULE_NAME_CLEANUP_PTR "getargs.cleanup_ptr"\r
143#define GETARGS_CAPSULE_NAME_CLEANUP_BUFFER "getargs.cleanup_buffer"\r
144\r
145static void\r
146cleanup_ptr(PyObject *self)\r
147{\r
148 void *ptr = PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_PTR);\r
149 if (ptr) {\r
150 PyMem_FREE(ptr);\r
151 }\r
152}\r
153\r
154static void\r
155cleanup_buffer(PyObject *self)\r
156{\r
157 Py_buffer *ptr = (Py_buffer *)PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_BUFFER);\r
158 if (ptr) {\r
159 PyBuffer_Release(ptr);\r
160 }\r
161}\r
162\r
163static int\r
164addcleanup(void *ptr, PyObject **freelist, PyCapsule_Destructor destr)\r
165{\r
166 PyObject *cobj;\r
167 const char *name;\r
168\r
169 if (!*freelist) {\r
170 *freelist = PyList_New(0);\r
171 if (!*freelist) {\r
172 destr(ptr);\r
173 return -1;\r
174 }\r
175 }\r
176\r
177 if (destr == cleanup_ptr) {\r
178 name = GETARGS_CAPSULE_NAME_CLEANUP_PTR;\r
179 } else if (destr == cleanup_buffer) {\r
180 name = GETARGS_CAPSULE_NAME_CLEANUP_BUFFER;\r
181 } else {\r
182 return -1;\r
183 }\r
184 cobj = PyCapsule_New(ptr, name, destr);\r
185 if (!cobj) {\r
186 destr(ptr);\r
187 return -1;\r
188 }\r
189 if (PyList_Append(*freelist, cobj)) {\r
190 Py_DECREF(cobj);\r
191 return -1;\r
192 }\r
193 Py_DECREF(cobj);\r
194 return 0;\r
195}\r
196\r
197static int\r
198cleanreturn(int retval, PyObject *freelist)\r
199{\r
200 if (freelist && retval != 0) {\r
201 /* We were successful, reset the destructors so that they\r
202 don't get called. */\r
203 Py_ssize_t len = PyList_GET_SIZE(freelist), i;\r
204 for (i = 0; i < len; i++)\r
205 PyCapsule_SetDestructor(PyList_GET_ITEM(freelist, i), NULL);\r
206 }\r
207 Py_XDECREF(freelist);\r
208 return retval;\r
209}\r
210\r
211\r
212static int\r
213vgetargs1(PyObject *args, const char *format, va_list *p_va, int flags)\r
214{\r
215 char msgbuf[256];\r
216 int levels[32];\r
217 const char *fname = NULL;\r
218 const char *message = NULL;\r
219 int min = -1;\r
220 int max = 0;\r
221 int level = 0;\r
222 int endfmt = 0;\r
223 const char *formatsave = format;\r
224 Py_ssize_t i, len;\r
225 char *msg;\r
226 PyObject *freelist = NULL;\r
227 int compat = flags & FLAG_COMPAT;\r
228\r
229 assert(compat || (args != (PyObject*)NULL));\r
230 flags = flags & ~FLAG_COMPAT;\r
231\r
232 while (endfmt == 0) {\r
233 int c = *format++;\r
234 switch (c) {\r
235 case '(':\r
236 if (level == 0)\r
237 max++;\r
238 level++;\r
239 if (level >= 30)\r
240 Py_FatalError("too many tuple nesting levels "\r
241 "in argument format string");\r
242 break;\r
243 case ')':\r
244 if (level == 0)\r
245 Py_FatalError("excess ')' in getargs format");\r
246 else\r
247 level--;\r
248 break;\r
249 case '\0':\r
250 endfmt = 1;\r
251 break;\r
252 case ':':\r
253 fname = format;\r
254 endfmt = 1;\r
255 break;\r
256 case ';':\r
257 message = format;\r
258 endfmt = 1;\r
259 break;\r
260 default:\r
261 if (level == 0) {\r
262 if (c == 'O')\r
263 max++;\r
264 else if (isalpha(Py_CHARMASK(c))) {\r
265 if (c != 'e') /* skip encoded */\r
266 max++;\r
267 } else if (c == '|')\r
268 min = max;\r
269 }\r
270 break;\r
271 }\r
272 }\r
273\r
274 if (level != 0)\r
275 Py_FatalError(/* '(' */ "missing ')' in getargs format");\r
276\r
277 if (min < 0)\r
278 min = max;\r
279\r
280 format = formatsave;\r
281\r
282 if (compat) {\r
283 if (max == 0) {\r
284 if (args == NULL)\r
285 return 1;\r
286 PyOS_snprintf(msgbuf, sizeof(msgbuf),\r
287 "%.200s%s takes no arguments",\r
288 fname==NULL ? "function" : fname,\r
289 fname==NULL ? "" : "()");\r
290 PyErr_SetString(PyExc_TypeError, msgbuf);\r
291 return 0;\r
292 }\r
293 else if (min == 1 && max == 1) {\r
294 if (args == NULL) {\r
295 PyOS_snprintf(msgbuf, sizeof(msgbuf),\r
296 "%.200s%s takes at least one argument",\r
297 fname==NULL ? "function" : fname,\r
298 fname==NULL ? "" : "()");\r
299 PyErr_SetString(PyExc_TypeError, msgbuf);\r
300 return 0;\r
301 }\r
302 msg = convertitem(args, &format, p_va, flags, levels,\r
303 msgbuf, sizeof(msgbuf), &freelist);\r
304 if (msg == NULL)\r
305 return cleanreturn(1, freelist);\r
306 seterror(levels[0], msg, levels+1, fname, message);\r
307 return cleanreturn(0, freelist);\r
308 }\r
309 else {\r
310 PyErr_SetString(PyExc_SystemError,\r
311 "old style getargs format uses new features");\r
312 return 0;\r
313 }\r
314 }\r
315\r
316 if (!PyTuple_Check(args)) {\r
317 PyErr_SetString(PyExc_SystemError,\r
318 "new style getargs format but argument is not a tuple");\r
319 return 0;\r
320 }\r
321\r
322 len = PyTuple_GET_SIZE(args);\r
323\r
324 if (len < min || max < len) {\r
325 if (message == NULL) {\r
326 PyOS_snprintf(msgbuf, sizeof(msgbuf),\r
327 "%.150s%s takes %s %d argument%s "\r
328 "(%ld given)",\r
329 fname==NULL ? "function" : fname,\r
330 fname==NULL ? "" : "()",\r
331 min==max ? "exactly"\r
332 : len < min ? "at least" : "at most",\r
333 len < min ? min : max,\r
334 (len < min ? min : max) == 1 ? "" : "s",\r
335 Py_SAFE_DOWNCAST(len, Py_ssize_t, long));\r
336 message = msgbuf;\r
337 }\r
338 PyErr_SetString(PyExc_TypeError, message);\r
339 return 0;\r
340 }\r
341\r
342 for (i = 0; i < len; i++) {\r
343 if (*format == '|')\r
344 format++;\r
345 msg = convertitem(PyTuple_GET_ITEM(args, i), &format, p_va,\r
346 flags, levels, msgbuf,\r
347 sizeof(msgbuf), &freelist);\r
348 if (msg) {\r
349 seterror(i+1, msg, levels, fname, msg);\r
350 return cleanreturn(0, freelist);\r
351 }\r
352 }\r
353\r
354 if (*format != '\0' && !isalpha(Py_CHARMASK(*format)) &&\r
355 *format != '(' &&\r
356 *format != '|' && *format != ':' && *format != ';') {\r
357 PyErr_Format(PyExc_SystemError,\r
358 "bad format string: %.200s", formatsave);\r
359 return cleanreturn(0, freelist);\r
360 }\r
361\r
362 return cleanreturn(1, freelist);\r
363}\r
364\r
365\r
366\r
367static void\r
368seterror(int iarg, const char *msg, int *levels, const char *fname,\r
369 const char *message)\r
370{\r
371 char buf[512];\r
372 int i;\r
373 char *p = buf;\r
374\r
375 if (PyErr_Occurred())\r
376 return;\r
377 else if (message == NULL) {\r
378 if (fname != NULL) {\r
379 PyOS_snprintf(p, sizeof(buf), "%.200s() ", fname);\r
380 p += strlen(p);\r
381 }\r
382 if (iarg != 0) {\r
383 PyOS_snprintf(p, sizeof(buf) - (p - buf),\r
384 "argument %d", iarg);\r
385 i = 0;\r
386 p += strlen(p);\r
387 while (levels[i] > 0 && i < 32 && (int)(p-buf) < 220) {\r
388 PyOS_snprintf(p, sizeof(buf) - (p - buf),\r
389 ", item %d", levels[i]-1);\r
390 p += strlen(p);\r
391 i++;\r
392 }\r
393 }\r
394 else {\r
395 PyOS_snprintf(p, sizeof(buf) - (p - buf), "argument");\r
396 p += strlen(p);\r
397 }\r
398 PyOS_snprintf(p, sizeof(buf) - (p - buf), " %.256s", msg);\r
399 message = buf;\r
400 }\r
401 PyErr_SetString(PyExc_TypeError, message);\r
402}\r
403\r
404\r
405/* Convert a tuple argument.\r
406 On entry, *p_format points to the character _after_ the opening '('.\r
407 On successful exit, *p_format points to the closing ')'.\r
408 If successful:\r
409 *p_format and *p_va are updated,\r
410 *levels and *msgbuf are untouched,\r
411 and NULL is returned.\r
412 If the argument is invalid:\r
413 *p_format is unchanged,\r
414 *p_va is undefined,\r
415 *levels is a 0-terminated list of item numbers,\r
416 *msgbuf contains an error message, whose format is:\r
417 "must be <typename1>, not <typename2>", where:\r
418 <typename1> is the name of the expected type, and\r
419 <typename2> is the name of the actual type,\r
420 and msgbuf is returned.\r
421*/\r
422\r
423static char *\r
424converttuple(PyObject *arg, const char **p_format, va_list *p_va, int flags,\r
425 int *levels, char *msgbuf, size_t bufsize, int toplevel,\r
426 PyObject **freelist)\r
427{\r
428 int level = 0;\r
429 int n = 0;\r
430 const char *format = *p_format;\r
431 int i;\r
432\r
433 for (;;) {\r
434 int c = *format++;\r
435 if (c == '(') {\r
436 if (level == 0)\r
437 n++;\r
438 level++;\r
439 }\r
440 else if (c == ')') {\r
441 if (level == 0)\r
442 break;\r
443 level--;\r
444 }\r
445 else if (c == ':' || c == ';' || c == '\0')\r
446 break;\r
447 else if (level == 0 && isalpha(Py_CHARMASK(c)))\r
448 n++;\r
449 }\r
450\r
451 if (!PySequence_Check(arg) || PyString_Check(arg)) {\r
452 levels[0] = 0;\r
453 PyOS_snprintf(msgbuf, bufsize,\r
454 toplevel ? "expected %d arguments, not %.50s" :\r
455 "must be %d-item sequence, not %.50s",\r
456 n,\r
457 arg == Py_None ? "None" : arg->ob_type->tp_name);\r
458 return msgbuf;\r
459 }\r
460\r
461 if ((i = PySequence_Size(arg)) != n) {\r
462 levels[0] = 0;\r
463 PyOS_snprintf(msgbuf, bufsize,\r
464 toplevel ? "expected %d arguments, not %d" :\r
465 "must be sequence of length %d, not %d",\r
466 n, i);\r
467 return msgbuf;\r
468 }\r
469\r
470 format = *p_format;\r
471 for (i = 0; i < n; i++) {\r
472 char *msg;\r
473 PyObject *item;\r
474 item = PySequence_GetItem(arg, i);\r
475 if (item == NULL) {\r
476 PyErr_Clear();\r
477 levels[0] = i+1;\r
478 levels[1] = 0;\r
479 strncpy(msgbuf, "is not retrievable", bufsize);\r
480 return msgbuf;\r
481 }\r
482 msg = convertitem(item, &format, p_va, flags, levels+1,\r
483 msgbuf, bufsize, freelist);\r
484 /* PySequence_GetItem calls tp->sq_item, which INCREFs */\r
485 Py_XDECREF(item);\r
486 if (msg != NULL) {\r
487 levels[0] = i+1;\r
488 return msg;\r
489 }\r
490 }\r
491\r
492 *p_format = format;\r
493 return NULL;\r
494}\r
495\r
496\r
497/* Convert a single item. */\r
498\r
499static char *\r
500convertitem(PyObject *arg, const char **p_format, va_list *p_va, int flags,\r
501 int *levels, char *msgbuf, size_t bufsize, PyObject **freelist)\r
502{\r
503 char *msg;\r
504 const char *format = *p_format;\r
505\r
506 if (*format == '(' /* ')' */) {\r
507 format++;\r
508 msg = converttuple(arg, &format, p_va, flags, levels, msgbuf,\r
509 bufsize, 0, freelist);\r
510 if (msg == NULL)\r
511 format++;\r
512 }\r
513 else {\r
514 msg = convertsimple(arg, &format, p_va, flags,\r
515 msgbuf, bufsize, freelist);\r
516 if (msg != NULL)\r
517 levels[0] = 0;\r
518 }\r
519 if (msg == NULL)\r
520 *p_format = format;\r
521 return msg;\r
522}\r
523\r
524\r
525\r
526#define UNICODE_DEFAULT_ENCODING(arg) \\r
527 _PyUnicode_AsDefaultEncodedString(arg, NULL)\r
528\r
529/* Format an error message generated by convertsimple(). */\r
530\r
531static char *\r
532converterr(const char *expected, PyObject *arg, char *msgbuf, size_t bufsize)\r
533{\r
534 assert(expected != NULL);\r
535 assert(arg != NULL);\r
536 PyOS_snprintf(msgbuf, bufsize,\r
537 "must be %.50s, not %.50s", expected,\r
538 arg == Py_None ? "None" : arg->ob_type->tp_name);\r
539 return msgbuf;\r
540}\r
541\r
542#define CONV_UNICODE "(unicode conversion error)"\r
543\r
544/* explicitly check for float arguments when integers are expected. For now\r
545 * signal a warning. Returns true if an exception was raised. */\r
546static int\r
547float_argument_warning(PyObject *arg)\r
548{\r
549 if (PyFloat_Check(arg) &&\r
550 PyErr_Warn(PyExc_DeprecationWarning,\r
551 "integer argument expected, got float" ))\r
552 return 1;\r
553 else\r
554 return 0;\r
555}\r
556\r
557/* explicitly check for float arguments when integers are expected. Raises\r
558 TypeError and returns true for float arguments. */\r
559static int\r
560float_argument_error(PyObject *arg)\r
561{\r
562 if (PyFloat_Check(arg)) {\r
563 PyErr_SetString(PyExc_TypeError,\r
564 "integer argument expected, got float");\r
565 return 1;\r
566 }\r
567 else\r
568 return 0;\r
569}\r
570\r
571/* Convert a non-tuple argument. Return NULL if conversion went OK,\r
572 or a string with a message describing the failure. The message is\r
573 formatted as "must be <desired type>, not <actual type>".\r
574 When failing, an exception may or may not have been raised.\r
575 Don't call if a tuple is expected.\r
576\r
577 When you add new format codes, please don't forget poor skipitem() below.\r
578*/\r
579\r
580static char *\r
581convertsimple(PyObject *arg, const char **p_format, va_list *p_va, int flags,\r
582 char *msgbuf, size_t bufsize, PyObject **freelist)\r
583{\r
584 /* For # codes */\r
585#define FETCH_SIZE int *q=NULL;Py_ssize_t *q2=NULL;\\r
586 if (flags & FLAG_SIZE_T) q2=va_arg(*p_va, Py_ssize_t*); \\r
587 else q=va_arg(*p_va, int*);\r
588#define STORE_SIZE(s) \\r
589 if (flags & FLAG_SIZE_T) \\r
590 *q2=s; \\r
591 else { \\r
592 if (INT_MAX < s) { \\r
593 PyErr_SetString(PyExc_OverflowError, \\r
594 "size does not fit in an int"); \\r
595 return converterr("", arg, msgbuf, bufsize); \\r
596 } \\r
597 *q=s; \\r
598 }\r
599#define BUFFER_LEN ((flags & FLAG_SIZE_T) ? *q2:*q)\r
600\r
601 const char *format = *p_format;\r
602 char c = *format++;\r
603#ifdef Py_USING_UNICODE\r
604 PyObject *uarg;\r
605#endif\r
606\r
607 switch (c) {\r
608\r
609 case 'b': { /* unsigned byte -- very short int */\r
610 char *p = va_arg(*p_va, char *);\r
611 long ival;\r
612 if (float_argument_error(arg))\r
613 return converterr("integer<b>", arg, msgbuf, bufsize);\r
614 ival = PyInt_AsLong(arg);\r
615 if (ival == -1 && PyErr_Occurred())\r
616 return converterr("integer<b>", arg, msgbuf, bufsize);\r
617 else if (ival < 0) {\r
618 PyErr_SetString(PyExc_OverflowError,\r
619 "unsigned byte integer is less than minimum");\r
620 return converterr("integer<b>", arg, msgbuf, bufsize);\r
621 }\r
622 else if (ival > UCHAR_MAX) {\r
623 PyErr_SetString(PyExc_OverflowError,\r
624 "unsigned byte integer is greater than maximum");\r
625 return converterr("integer<b>", arg, msgbuf, bufsize);\r
626 }\r
627 else\r
628 *p = (unsigned char) ival;\r
629 break;\r
630 }\r
631\r
632 case 'B': {/* byte sized bitfield - both signed and unsigned\r
633 values allowed */\r
634 char *p = va_arg(*p_va, char *);\r
635 long ival;\r
636 if (float_argument_error(arg))\r
637 return converterr("integer<B>", arg, msgbuf, bufsize);\r
638 ival = PyInt_AsUnsignedLongMask(arg);\r
639 if (ival == -1 && PyErr_Occurred())\r
640 return converterr("integer<B>", arg, msgbuf, bufsize);\r
641 else\r
642 *p = (unsigned char) ival;\r
643 break;\r
644 }\r
645\r
646 case 'h': {/* signed short int */\r
647 short *p = va_arg(*p_va, short *);\r
648 long ival;\r
649 if (float_argument_error(arg))\r
650 return converterr("integer<h>", arg, msgbuf, bufsize);\r
651 ival = PyInt_AsLong(arg);\r
652 if (ival == -1 && PyErr_Occurred())\r
653 return converterr("integer<h>", arg, msgbuf, bufsize);\r
654 else if (ival < SHRT_MIN) {\r
655 PyErr_SetString(PyExc_OverflowError,\r
656 "signed short integer is less than minimum");\r
657 return converterr("integer<h>", arg, msgbuf, bufsize);\r
658 }\r
659 else if (ival > SHRT_MAX) {\r
660 PyErr_SetString(PyExc_OverflowError,\r
661 "signed short integer is greater than maximum");\r
662 return converterr("integer<h>", arg, msgbuf, bufsize);\r
663 }\r
664 else\r
665 *p = (short) ival;\r
666 break;\r
667 }\r
668\r
669 case 'H': { /* short int sized bitfield, both signed and\r
670 unsigned allowed */\r
671 unsigned short *p = va_arg(*p_va, unsigned short *);\r
672 long ival;\r
673 if (float_argument_error(arg))\r
674 return converterr("integer<H>", arg, msgbuf, bufsize);\r
675 ival = PyInt_AsUnsignedLongMask(arg);\r
676 if (ival == -1 && PyErr_Occurred())\r
677 return converterr("integer<H>", arg, msgbuf, bufsize);\r
678 else\r
679 *p = (unsigned short) ival;\r
680 break;\r
681 }\r
682\r
683 case 'i': {/* signed int */\r
684 int *p = va_arg(*p_va, int *);\r
685 long ival;\r
686 if (float_argument_error(arg))\r
687 return converterr("integer<i>", arg, msgbuf, bufsize);\r
688 ival = PyInt_AsLong(arg);\r
689 if (ival == -1 && PyErr_Occurred())\r
690 return converterr("integer<i>", arg, msgbuf, bufsize);\r
691 else if (ival > INT_MAX) {\r
692 PyErr_SetString(PyExc_OverflowError,\r
693 "signed integer is greater than maximum");\r
694 return converterr("integer<i>", arg, msgbuf, bufsize);\r
695 }\r
696 else if (ival < INT_MIN) {\r
697 PyErr_SetString(PyExc_OverflowError,\r
698 "signed integer is less than minimum");\r
699 return converterr("integer<i>", arg, msgbuf, bufsize);\r
700 }\r
701 else\r
702 *p = ival;\r
703 break;\r
704 }\r
705\r
706 case 'I': { /* int sized bitfield, both signed and\r
707 unsigned allowed */\r
708 unsigned int *p = va_arg(*p_va, unsigned int *);\r
709 unsigned int ival;\r
710 if (float_argument_error(arg))\r
711 return converterr("integer<I>", arg, msgbuf, bufsize);\r
712 ival = (unsigned int)PyInt_AsUnsignedLongMask(arg);\r
713 if (ival == (unsigned int)-1 && PyErr_Occurred())\r
714 return converterr("integer<I>", arg, msgbuf, bufsize);\r
715 else\r
716 *p = ival;\r
717 break;\r
718 }\r
719\r
720 case 'n': /* Py_ssize_t */\r
721#if SIZEOF_SIZE_T != SIZEOF_LONG\r
722 {\r
723 Py_ssize_t *p = va_arg(*p_va, Py_ssize_t *);\r
724 Py_ssize_t ival;\r
725 if (float_argument_error(arg))\r
726 return converterr("integer<n>", arg, msgbuf, bufsize);\r
727 ival = PyInt_AsSsize_t(arg);\r
728 if (ival == -1 && PyErr_Occurred())\r
729 return converterr("integer<n>", arg, msgbuf, bufsize);\r
730 *p = ival;\r
731 break;\r
732 }\r
733#endif\r
734 /* Fall through from 'n' to 'l' if Py_ssize_t is int */\r
735 case 'l': {/* long int */\r
736 long *p = va_arg(*p_va, long *);\r
737 long ival;\r
738 if (float_argument_error(arg))\r
739 return converterr("integer<l>", arg, msgbuf, bufsize);\r
740 ival = PyInt_AsLong(arg);\r
741 if (ival == -1 && PyErr_Occurred())\r
742 return converterr("integer<l>", arg, msgbuf, bufsize);\r
743 else\r
744 *p = ival;\r
745 break;\r
746 }\r
747\r
748 case 'k': { /* long sized bitfield */\r
749 unsigned long *p = va_arg(*p_va, unsigned long *);\r
750 unsigned long ival;\r
751 if (PyInt_Check(arg))\r
752 ival = PyInt_AsUnsignedLongMask(arg);\r
753 else if (PyLong_Check(arg))\r
754 ival = PyLong_AsUnsignedLongMask(arg);\r
755 else\r
756 return converterr("integer<k>", arg, msgbuf, bufsize);\r
757 *p = ival;\r
758 break;\r
759 }\r
760\r
761#ifdef HAVE_LONG_LONG\r
762 case 'L': {/* PY_LONG_LONG */\r
763 PY_LONG_LONG *p = va_arg( *p_va, PY_LONG_LONG * );\r
764 PY_LONG_LONG ival;\r
765 if (float_argument_warning(arg))\r
766 return converterr("long<L>", arg, msgbuf, bufsize);\r
767 ival = PyLong_AsLongLong(arg);\r
768 if (ival == (PY_LONG_LONG)-1 && PyErr_Occurred() ) {\r
769 return converterr("long<L>", arg, msgbuf, bufsize);\r
770 } else {\r
771 *p = ival;\r
772 }\r
773 break;\r
774 }\r
775\r
776 case 'K': { /* long long sized bitfield */\r
777 unsigned PY_LONG_LONG *p = va_arg(*p_va, unsigned PY_LONG_LONG *);\r
778 unsigned PY_LONG_LONG ival;\r
779 if (PyInt_Check(arg))\r
780 ival = PyInt_AsUnsignedLongMask(arg);\r
781 else if (PyLong_Check(arg))\r
782 ival = PyLong_AsUnsignedLongLongMask(arg);\r
783 else\r
784 return converterr("integer<K>", arg, msgbuf, bufsize);\r
785 *p = ival;\r
786 break;\r
787 }\r
788#endif\r
789\r
790 case 'f': {/* float */\r
791 float *p = va_arg(*p_va, float *);\r
792 double dval = PyFloat_AsDouble(arg);\r
793 if (PyErr_Occurred())\r
794 return converterr("float<f>", arg, msgbuf, bufsize);\r
795 else\r
796 *p = (float) dval;\r
797 break;\r
798 }\r
799\r
800 case 'd': {/* double */\r
801 double *p = va_arg(*p_va, double *);\r
802 double dval = PyFloat_AsDouble(arg);\r
803 if (PyErr_Occurred())\r
804 return converterr("float<d>", arg, msgbuf, bufsize);\r
805 else\r
806 *p = dval;\r
807 break;\r
808 }\r
809\r
810#ifndef WITHOUT_COMPLEX\r
811 case 'D': {/* complex double */\r
812 Py_complex *p = va_arg(*p_va, Py_complex *);\r
813 Py_complex cval;\r
814 cval = PyComplex_AsCComplex(arg);\r
815 if (PyErr_Occurred())\r
816 return converterr("complex<D>", arg, msgbuf, bufsize);\r
817 else\r
818 *p = cval;\r
819 break;\r
820 }\r
821#endif /* WITHOUT_COMPLEX */\r
822\r
823 case 'c': {/* char */\r
824 char *p = va_arg(*p_va, char *);\r
825 if (PyString_Check(arg) && PyString_Size(arg) == 1)\r
826 *p = PyString_AS_STRING(arg)[0];\r
827 else\r
828 return converterr("char", arg, msgbuf, bufsize);\r
829 break;\r
830 }\r
831\r
832 case 's': {/* string */\r
833 if (*format == '*') {\r
834 Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);\r
835\r
836 if (PyString_Check(arg)) {\r
837 PyBuffer_FillInfo(p, arg,\r
838 PyString_AS_STRING(arg), PyString_GET_SIZE(arg),\r
839 1, 0);\r
840 }\r
841#ifdef Py_USING_UNICODE\r
842 else if (PyUnicode_Check(arg)) {\r
843 uarg = UNICODE_DEFAULT_ENCODING(arg);\r
844 if (uarg == NULL)\r
845 return converterr(CONV_UNICODE,\r
846 arg, msgbuf, bufsize);\r
847 PyBuffer_FillInfo(p, arg,\r
848 PyString_AS_STRING(uarg), PyString_GET_SIZE(uarg),\r
849 1, 0);\r
850 }\r
851#endif\r
852 else { /* any buffer-like object */\r
853 char *buf;\r
854 if (getbuffer(arg, p, &buf) < 0)\r
855 return converterr(buf, arg, msgbuf, bufsize);\r
856 }\r
857 if (addcleanup(p, freelist, cleanup_buffer)) {\r
858 return converterr(\r
859 "(cleanup problem)",\r
860 arg, msgbuf, bufsize);\r
861 }\r
862 format++;\r
863 } else if (*format == '#') {\r
864 void **p = (void **)va_arg(*p_va, char **);\r
865 FETCH_SIZE;\r
866\r
867 if (PyString_Check(arg)) {\r
868 *p = PyString_AS_STRING(arg);\r
869 STORE_SIZE(PyString_GET_SIZE(arg));\r
870 }\r
871#ifdef Py_USING_UNICODE\r
872 else if (PyUnicode_Check(arg)) {\r
873 uarg = UNICODE_DEFAULT_ENCODING(arg);\r
874 if (uarg == NULL)\r
875 return converterr(CONV_UNICODE,\r
876 arg, msgbuf, bufsize);\r
877 *p = PyString_AS_STRING(uarg);\r
878 STORE_SIZE(PyString_GET_SIZE(uarg));\r
879 }\r
880#endif\r
881 else { /* any buffer-like object */\r
882 char *buf;\r
883 Py_ssize_t count = convertbuffer(arg, p, &buf);\r
884 if (count < 0)\r
885 return converterr(buf, arg, msgbuf, bufsize);\r
886 STORE_SIZE(count);\r
887 }\r
888 format++;\r
889 } else {\r
890 char **p = va_arg(*p_va, char **);\r
891\r
892 if (PyString_Check(arg))\r
893 *p = PyString_AS_STRING(arg);\r
894#ifdef Py_USING_UNICODE\r
895 else if (PyUnicode_Check(arg)) {\r
896 uarg = UNICODE_DEFAULT_ENCODING(arg);\r
897 if (uarg == NULL)\r
898 return converterr(CONV_UNICODE,\r
899 arg, msgbuf, bufsize);\r
900 *p = PyString_AS_STRING(uarg);\r
901 }\r
902#endif\r
903 else\r
904 return converterr("string", arg, msgbuf, bufsize);\r
905 if ((Py_ssize_t)strlen(*p) != PyString_Size(arg))\r
906 return converterr("string without null bytes",\r
907 arg, msgbuf, bufsize);\r
908 }\r
909 break;\r
910 }\r
911\r
912 case 'z': {/* string, may be NULL (None) */\r
913 if (*format == '*') {\r
914 Py_buffer *p = (Py_buffer *)va_arg(*p_va, Py_buffer *);\r
915\r
916 if (arg == Py_None)\r
917 PyBuffer_FillInfo(p, NULL, NULL, 0, 1, 0);\r
918 else if (PyString_Check(arg)) {\r
919 PyBuffer_FillInfo(p, arg,\r
920 PyString_AS_STRING(arg), PyString_GET_SIZE(arg),\r
921 1, 0);\r
922 }\r
923#ifdef Py_USING_UNICODE\r
924 else if (PyUnicode_Check(arg)) {\r
925 uarg = UNICODE_DEFAULT_ENCODING(arg);\r
926 if (uarg == NULL)\r
927 return converterr(CONV_UNICODE,\r
928 arg, msgbuf, bufsize);\r
929 PyBuffer_FillInfo(p, arg,\r
930 PyString_AS_STRING(uarg), PyString_GET_SIZE(uarg),\r
931 1, 0);\r
932 }\r
933#endif\r
934 else { /* any buffer-like object */\r
935 char *buf;\r
936 if (getbuffer(arg, p, &buf) < 0)\r
937 return converterr(buf, arg, msgbuf, bufsize);\r
938 }\r
939 if (addcleanup(p, freelist, cleanup_buffer)) {\r
940 return converterr(\r
941 "(cleanup problem)",\r
942 arg, msgbuf, bufsize);\r
943 }\r
944 format++;\r
945 } else if (*format == '#') { /* any buffer-like object */\r
946 void **p = (void **)va_arg(*p_va, char **);\r
947 FETCH_SIZE;\r
948\r
949 if (arg == Py_None) {\r
950 *p = 0;\r
951 STORE_SIZE(0);\r
952 }\r
953 else if (PyString_Check(arg)) {\r
954 *p = PyString_AS_STRING(arg);\r
955 STORE_SIZE(PyString_GET_SIZE(arg));\r
956 }\r
957#ifdef Py_USING_UNICODE\r
958 else if (PyUnicode_Check(arg)) {\r
959 uarg = UNICODE_DEFAULT_ENCODING(arg);\r
960 if (uarg == NULL)\r
961 return converterr(CONV_UNICODE,\r
962 arg, msgbuf, bufsize);\r
963 *p = PyString_AS_STRING(uarg);\r
964 STORE_SIZE(PyString_GET_SIZE(uarg));\r
965 }\r
966#endif\r
967 else { /* any buffer-like object */\r
968 char *buf;\r
969 Py_ssize_t count = convertbuffer(arg, p, &buf);\r
970 if (count < 0)\r
971 return converterr(buf, arg, msgbuf, bufsize);\r
972 STORE_SIZE(count);\r
973 }\r
974 format++;\r
975 } else {\r
976 char **p = va_arg(*p_va, char **);\r
977\r
978 if (arg == Py_None)\r
979 *p = 0;\r
980 else if (PyString_Check(arg))\r
981 *p = PyString_AS_STRING(arg);\r
982#ifdef Py_USING_UNICODE\r
983 else if (PyUnicode_Check(arg)) {\r
984 uarg = UNICODE_DEFAULT_ENCODING(arg);\r
985 if (uarg == NULL)\r
986 return converterr(CONV_UNICODE,\r
987 arg, msgbuf, bufsize);\r
988 *p = PyString_AS_STRING(uarg);\r
989 }\r
990#endif\r
991 else\r
992 return converterr("string or None",\r
993 arg, msgbuf, bufsize);\r
994 if (*format == '#') {\r
995 FETCH_SIZE;\r
996 assert(0); /* XXX redundant with if-case */\r
997 if (arg == Py_None) {\r
998 STORE_SIZE(0);\r
999 } else {\r
1000 STORE_SIZE(PyString_Size(arg));\r
1001 }\r
1002 format++;\r
1003 }\r
1004 else if (*p != NULL &&\r
1005 (Py_ssize_t)strlen(*p) != PyString_Size(arg))\r
1006 return converterr(\r
1007 "string without null bytes or None",\r
1008 arg, msgbuf, bufsize);\r
1009 }\r
1010 break;\r
1011 }\r
1012\r
1013 case 'e': {/* encoded string */\r
1014 char **buffer;\r
1015 const char *encoding;\r
1016 PyObject *s;\r
1017 Py_ssize_t size;\r
1018 int recode_strings;\r
1019\r
1020 /* Get 'e' parameter: the encoding name */\r
1021 encoding = (const char *)va_arg(*p_va, const char *);\r
1022#ifdef Py_USING_UNICODE\r
1023 if (encoding == NULL)\r
1024 encoding = PyUnicode_GetDefaultEncoding();\r
1025#endif\r
1026\r
1027 /* Get output buffer parameter:\r
1028 's' (recode all objects via Unicode) or\r
1029 't' (only recode non-string objects)\r
1030 */\r
1031 if (*format == 's')\r
1032 recode_strings = 1;\r
1033 else if (*format == 't')\r
1034 recode_strings = 0;\r
1035 else\r
1036 return converterr(\r
1037 "(unknown parser marker combination)",\r
1038 arg, msgbuf, bufsize);\r
1039 buffer = (char **)va_arg(*p_va, char **);\r
1040 format++;\r
1041 if (buffer == NULL)\r
1042 return converterr("(buffer is NULL)",\r
1043 arg, msgbuf, bufsize);\r
1044\r
1045 /* Encode object */\r
1046 if (!recode_strings && PyString_Check(arg)) {\r
1047 s = arg;\r
1048 Py_INCREF(s);\r
1049 }\r
1050 else {\r
1051#ifdef Py_USING_UNICODE\r
1052 PyObject *u;\r
1053\r
1054 /* Convert object to Unicode */\r
1055 u = PyUnicode_FromObject(arg);\r
1056 if (u == NULL)\r
1057 return converterr(\r
1058 "string or unicode or text buffer",\r
1059 arg, msgbuf, bufsize);\r
1060\r
1061 /* Encode object; use default error handling */\r
1062 s = PyUnicode_AsEncodedString(u,\r
1063 encoding,\r
1064 NULL);\r
1065 Py_DECREF(u);\r
1066 if (s == NULL)\r
1067 return converterr("(encoding failed)",\r
1068 arg, msgbuf, bufsize);\r
1069 if (!PyString_Check(s)) {\r
1070 Py_DECREF(s);\r
1071 return converterr(\r
1072 "(encoder failed to return a string)",\r
1073 arg, msgbuf, bufsize);\r
1074 }\r
1075#else\r
1076 return converterr("string<e>", arg, msgbuf, bufsize);\r
1077#endif\r
1078 }\r
1079 size = PyString_GET_SIZE(s);\r
1080\r
1081 /* Write output; output is guaranteed to be 0-terminated */\r
1082 if (*format == '#') {\r
1083 /* Using buffer length parameter '#':\r
1084\r
1085 - if *buffer is NULL, a new buffer of the\r
1086 needed size is allocated and the data\r
1087 copied into it; *buffer is updated to point\r
1088 to the new buffer; the caller is\r
1089 responsible for PyMem_Free()ing it after\r
1090 usage\r
1091\r
1092 - if *buffer is not NULL, the data is\r
1093 copied to *buffer; *buffer_len has to be\r
1094 set to the size of the buffer on input;\r
1095 buffer overflow is signalled with an error;\r
1096 buffer has to provide enough room for the\r
1097 encoded string plus the trailing 0-byte\r
1098\r
1099 - in both cases, *buffer_len is updated to\r
1100 the size of the buffer /excluding/ the\r
1101 trailing 0-byte\r
1102\r
1103 */\r
1104 FETCH_SIZE;\r
1105\r
1106 format++;\r
1107 if (q == NULL && q2 == NULL) {\r
1108 Py_DECREF(s);\r
1109 return converterr(\r
1110 "(buffer_len is NULL)",\r
1111 arg, msgbuf, bufsize);\r
1112 }\r
1113 if (*buffer == NULL) {\r
1114 *buffer = PyMem_NEW(char, size + 1);\r
1115 if (*buffer == NULL) {\r
1116 Py_DECREF(s);\r
1117 return converterr(\r
1118 "(memory error)",\r
1119 arg, msgbuf, bufsize);\r
1120 }\r
1121 if (addcleanup(*buffer, freelist, cleanup_ptr)) {\r
1122 Py_DECREF(s);\r
1123 return converterr(\r
1124 "(cleanup problem)",\r
1125 arg, msgbuf, bufsize);\r
1126 }\r
1127 } else {\r
1128 if (size + 1 > BUFFER_LEN) {\r
1129 Py_DECREF(s);\r
1130 return converterr(\r
1131 "(buffer overflow)",\r
1132 arg, msgbuf, bufsize);\r
1133 }\r
1134 }\r
1135 memcpy(*buffer,\r
1136 PyString_AS_STRING(s),\r
1137 size + 1);\r
1138 STORE_SIZE(size);\r
1139 } else {\r
1140 /* Using a 0-terminated buffer:\r
1141\r
1142 - the encoded string has to be 0-terminated\r
1143 for this variant to work; if it is not, an\r
1144 error raised\r
1145\r
1146 - a new buffer of the needed size is\r
1147 allocated and the data copied into it;\r
1148 *buffer is updated to point to the new\r
1149 buffer; the caller is responsible for\r
1150 PyMem_Free()ing it after usage\r
1151\r
1152 */\r
1153 if ((Py_ssize_t)strlen(PyString_AS_STRING(s))\r
1154 != size) {\r
1155 Py_DECREF(s);\r
1156 return converterr(\r
1157 "encoded string without NULL bytes",\r
1158 arg, msgbuf, bufsize);\r
1159 }\r
1160 *buffer = PyMem_NEW(char, size + 1);\r
1161 if (*buffer == NULL) {\r
1162 Py_DECREF(s);\r
1163 return converterr("(memory error)",\r
1164 arg, msgbuf, bufsize);\r
1165 }\r
1166 if (addcleanup(*buffer, freelist, cleanup_ptr)) {\r
1167 Py_DECREF(s);\r
1168 return converterr("(cleanup problem)",\r
1169 arg, msgbuf, bufsize);\r
1170 }\r
1171 memcpy(*buffer,\r
1172 PyString_AS_STRING(s),\r
1173 size + 1);\r
1174 }\r
1175 Py_DECREF(s);\r
1176 break;\r
1177 }\r
1178\r
1179#ifdef Py_USING_UNICODE\r
1180 case 'u': {/* raw unicode buffer (Py_UNICODE *) */\r
1181 if (*format == '#') { /* any buffer-like object */\r
1182 void **p = (void **)va_arg(*p_va, char **);\r
1183 FETCH_SIZE;\r
1184 if (PyUnicode_Check(arg)) {\r
1185 *p = PyUnicode_AS_UNICODE(arg);\r
1186 STORE_SIZE(PyUnicode_GET_SIZE(arg));\r
1187 }\r
1188 else {\r
1189 return converterr("cannot convert raw buffers",\r
1190 arg, msgbuf, bufsize);\r
1191 }\r
1192 format++;\r
1193 } else {\r
1194 Py_UNICODE **p = va_arg(*p_va, Py_UNICODE **);\r
1195 if (PyUnicode_Check(arg))\r
1196 *p = PyUnicode_AS_UNICODE(arg);\r
1197 else\r
1198 return converterr("unicode", arg, msgbuf, bufsize);\r
1199 }\r
1200 break;\r
1201 }\r
1202#endif\r
1203\r
1204 case 'S': { /* string object */\r
1205 PyObject **p = va_arg(*p_va, PyObject **);\r
1206 if (PyString_Check(arg))\r
1207 *p = arg;\r
1208 else\r
1209 return converterr("string", arg, msgbuf, bufsize);\r
1210 break;\r
1211 }\r
1212\r
1213#ifdef Py_USING_UNICODE\r
1214 case 'U': { /* Unicode object */\r
1215 PyObject **p = va_arg(*p_va, PyObject **);\r
1216 if (PyUnicode_Check(arg))\r
1217 *p = arg;\r
1218 else\r
1219 return converterr("unicode", arg, msgbuf, bufsize);\r
1220 break;\r
1221 }\r
1222#endif\r
1223\r
1224 case 'O': { /* object */\r
1225 PyTypeObject *type;\r
1226 PyObject **p;\r
1227 if (*format == '!') {\r
1228 type = va_arg(*p_va, PyTypeObject*);\r
1229 p = va_arg(*p_va, PyObject **);\r
1230 format++;\r
1231 if (PyType_IsSubtype(arg->ob_type, type))\r
1232 *p = arg;\r
1233 else\r
1234 return converterr(type->tp_name, arg, msgbuf, bufsize);\r
1235\r
1236 }\r
1237 else if (*format == '?') {\r
1238 inquiry pred = va_arg(*p_va, inquiry);\r
1239 p = va_arg(*p_va, PyObject **);\r
1240 format++;\r
1241 if ((*pred)(arg))\r
1242 *p = arg;\r
1243 else\r
1244 return converterr("(unspecified)",\r
1245 arg, msgbuf, bufsize);\r
1246\r
1247 }\r
1248 else if (*format == '&') {\r
1249 typedef int (*converter)(PyObject *, void *);\r
1250 converter convert = va_arg(*p_va, converter);\r
1251 void *addr = va_arg(*p_va, void *);\r
1252 format++;\r
1253 if (! (*convert)(arg, addr))\r
1254 return converterr("(unspecified)",\r
1255 arg, msgbuf, bufsize);\r
1256 }\r
1257 else {\r
1258 p = va_arg(*p_va, PyObject **);\r
1259 *p = arg;\r
1260 }\r
1261 break;\r
1262 }\r
1263\r
1264\r
1265 case 'w': { /* memory buffer, read-write access */\r
1266 void **p = va_arg(*p_va, void **);\r
1267 void *res;\r
1268 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;\r
1269 Py_ssize_t count;\r
1270\r
1271 if (pb && pb->bf_releasebuffer && *format != '*')\r
1272 /* Buffer must be released, yet caller does not use\r
1273 the Py_buffer protocol. */\r
1274 return converterr("pinned buffer", arg, msgbuf, bufsize);\r
1275\r
1276 if (pb && pb->bf_getbuffer && *format == '*') {\r
1277 /* Caller is interested in Py_buffer, and the object\r
1278 supports it directly. */\r
1279 format++;\r
1280 if (pb->bf_getbuffer(arg, (Py_buffer*)p, PyBUF_WRITABLE) < 0) {\r
1281 PyErr_Clear();\r
1282 return converterr("read-write buffer", arg, msgbuf, bufsize);\r
1283 }\r
1284 if (addcleanup(p, freelist, cleanup_buffer)) {\r
1285 return converterr(\r
1286 "(cleanup problem)",\r
1287 arg, msgbuf, bufsize);\r
1288 }\r
1289 if (!PyBuffer_IsContiguous((Py_buffer*)p, 'C'))\r
1290 return converterr("contiguous buffer", arg, msgbuf, bufsize);\r
1291 break;\r
1292 }\r
1293\r
1294 if (pb == NULL ||\r
1295 pb->bf_getwritebuffer == NULL ||\r
1296 pb->bf_getsegcount == NULL)\r
1297 return converterr("read-write buffer", arg, msgbuf, bufsize);\r
1298 if ((*pb->bf_getsegcount)(arg, NULL) != 1)\r
1299 return converterr("single-segment read-write buffer",\r
1300 arg, msgbuf, bufsize);\r
1301 if ((count = pb->bf_getwritebuffer(arg, 0, &res)) < 0)\r
1302 return converterr("(unspecified)", arg, msgbuf, bufsize);\r
1303 if (*format == '*') {\r
1304 PyBuffer_FillInfo((Py_buffer*)p, arg, res, count, 1, 0);\r
1305 format++;\r
1306 }\r
1307 else {\r
1308 *p = res;\r
1309 if (*format == '#') {\r
1310 FETCH_SIZE;\r
1311 STORE_SIZE(count);\r
1312 format++;\r
1313 }\r
1314 }\r
1315 break;\r
1316 }\r
1317\r
1318 case 't': { /* 8-bit character buffer, read-only access */\r
1319 char **p = va_arg(*p_va, char **);\r
1320 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;\r
1321 Py_ssize_t count;\r
1322\r
1323 if (*format++ != '#')\r
1324 return converterr(\r
1325 "invalid use of 't' format character",\r
1326 arg, msgbuf, bufsize);\r
1327 if (!PyType_HasFeature(arg->ob_type,\r
1328 Py_TPFLAGS_HAVE_GETCHARBUFFER) ||\r
1329 pb == NULL || pb->bf_getcharbuffer == NULL ||\r
1330 pb->bf_getsegcount == NULL)\r
1331 return converterr(\r
1332 "string or read-only character buffer",\r
1333 arg, msgbuf, bufsize);\r
1334\r
1335 if (pb->bf_getsegcount(arg, NULL) != 1)\r
1336 return converterr(\r
1337 "string or single-segment read-only buffer",\r
1338 arg, msgbuf, bufsize);\r
1339\r
1340 if (pb->bf_releasebuffer)\r
1341 return converterr(\r
1342 "string or pinned buffer",\r
1343 arg, msgbuf, bufsize);\r
1344\r
1345 count = pb->bf_getcharbuffer(arg, 0, p);\r
1346 if (count < 0)\r
1347 return converterr("(unspecified)", arg, msgbuf, bufsize);\r
1348 {\r
1349 FETCH_SIZE;\r
1350 STORE_SIZE(count);\r
1351 }\r
1352 break;\r
1353 }\r
1354\r
1355 default:\r
1356 return converterr("impossible<bad format char>", arg, msgbuf, bufsize);\r
1357\r
1358 }\r
1359\r
1360 *p_format = format;\r
1361 return NULL;\r
1362}\r
1363\r
1364static Py_ssize_t\r
1365convertbuffer(PyObject *arg, void **p, char **errmsg)\r
1366{\r
1367 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;\r
1368 Py_ssize_t count;\r
1369 if (pb == NULL ||\r
1370 pb->bf_getreadbuffer == NULL ||\r
1371 pb->bf_getsegcount == NULL ||\r
1372 pb->bf_releasebuffer != NULL) {\r
1373 *errmsg = "string or read-only buffer";\r
1374 return -1;\r
1375 }\r
1376 if ((*pb->bf_getsegcount)(arg, NULL) != 1) {\r
1377 *errmsg = "string or single-segment read-only buffer";\r
1378 return -1;\r
1379 }\r
1380 if ((count = (*pb->bf_getreadbuffer)(arg, 0, p)) < 0) {\r
1381 *errmsg = "(unspecified)";\r
1382 }\r
1383 return count;\r
1384}\r
1385\r
1386static int\r
1387getbuffer(PyObject *arg, Py_buffer *view, char **errmsg)\r
1388{\r
1389 void *buf;\r
1390 Py_ssize_t count;\r
1391 PyBufferProcs *pb = arg->ob_type->tp_as_buffer;\r
1392 if (pb == NULL) {\r
1393 *errmsg = "string or buffer";\r
1394 return -1;\r
1395 }\r
1396 if (pb->bf_getbuffer) {\r
1397 if (pb->bf_getbuffer(arg, view, 0) < 0) {\r
1398 *errmsg = "convertible to a buffer";\r
1399 return -1;\r
1400 }\r
1401 if (!PyBuffer_IsContiguous(view, 'C')) {\r
1402 *errmsg = "contiguous buffer";\r
1403 return -1;\r
1404 }\r
1405 return 0;\r
1406 }\r
1407\r
1408 count = convertbuffer(arg, &buf, errmsg);\r
1409 if (count < 0) {\r
1410 *errmsg = "convertible to a buffer";\r
1411 return count;\r
1412 }\r
1413 PyBuffer_FillInfo(view, arg, buf, count, 1, 0);\r
1414 return 0;\r
1415}\r
1416\r
1417/* Support for keyword arguments donated by\r
1418 Geoff Philbrick <philbric@delphi.hks.com> */\r
1419\r
1420/* Return false (0) for error, else true. */\r
1421int\r
1422PyArg_ParseTupleAndKeywords(PyObject *args,\r
1423 PyObject *keywords,\r
1424 const char *format,\r
1425 char **kwlist, ...)\r
1426{\r
1427 int retval;\r
1428 va_list va;\r
1429\r
1430 if ((args == NULL || !PyTuple_Check(args)) ||\r
1431 (keywords != NULL && !PyDict_Check(keywords)) ||\r
1432 format == NULL ||\r
1433 kwlist == NULL)\r
1434 {\r
1435 PyErr_BadInternalCall();\r
1436 return 0;\r
1437 }\r
1438\r
1439 va_start(va, kwlist);\r
1440 retval = vgetargskeywords(args, keywords, format, kwlist, &va, 0);\r
1441 va_end(va);\r
1442 return retval;\r
1443}\r
1444\r
1445int\r
1446_PyArg_ParseTupleAndKeywords_SizeT(PyObject *args,\r
1447 PyObject *keywords,\r
1448 const char *format,\r
1449 char **kwlist, ...)\r
1450{\r
1451 int retval;\r
1452 va_list va;\r
1453\r
1454 if ((args == NULL || !PyTuple_Check(args)) ||\r
1455 (keywords != NULL && !PyDict_Check(keywords)) ||\r
1456 format == NULL ||\r
1457 kwlist == NULL)\r
1458 {\r
1459 PyErr_BadInternalCall();\r
1460 return 0;\r
1461 }\r
1462\r
1463 va_start(va, kwlist);\r
1464 retval = vgetargskeywords(args, keywords, format,\r
1465 kwlist, &va, FLAG_SIZE_T);\r
1466 va_end(va);\r
1467 return retval;\r
1468}\r
1469\r
1470\r
1471int\r
1472PyArg_VaParseTupleAndKeywords(PyObject *args,\r
1473 PyObject *keywords,\r
1474 const char *format,\r
1475 char **kwlist, va_list va)\r
1476{\r
1477 int retval;\r
1478 va_list lva;\r
1479\r
1480 if ((args == NULL || !PyTuple_Check(args)) ||\r
1481 (keywords != NULL && !PyDict_Check(keywords)) ||\r
1482 format == NULL ||\r
1483 kwlist == NULL)\r
1484 {\r
1485 PyErr_BadInternalCall();\r
1486 return 0;\r
1487 }\r
1488\r
1489#ifdef VA_LIST_IS_ARRAY\r
1490 memcpy(lva, va, sizeof(va_list));\r
1491#else\r
1492#ifdef __va_copy\r
1493 __va_copy(lva, va);\r
1494#else\r
1495 lva = va;\r
1496#endif\r
1497#endif\r
1498\r
1499 retval = vgetargskeywords(args, keywords, format, kwlist, &lva, 0);\r
1500 return retval;\r
1501}\r
1502\r
1503int\r
1504_PyArg_VaParseTupleAndKeywords_SizeT(PyObject *args,\r
1505 PyObject *keywords,\r
1506 const char *format,\r
1507 char **kwlist, va_list va)\r
1508{\r
1509 int retval;\r
1510 va_list lva;\r
1511\r
1512 if ((args == NULL || !PyTuple_Check(args)) ||\r
1513 (keywords != NULL && !PyDict_Check(keywords)) ||\r
1514 format == NULL ||\r
1515 kwlist == NULL)\r
1516 {\r
1517 PyErr_BadInternalCall();\r
1518 return 0;\r
1519 }\r
1520\r
1521#ifdef VA_LIST_IS_ARRAY\r
1522 memcpy(lva, va, sizeof(va_list));\r
1523#else\r
1524#ifdef __va_copy\r
1525 __va_copy(lva, va);\r
1526#else\r
1527 lva = va;\r
1528#endif\r
1529#endif\r
1530\r
1531 retval = vgetargskeywords(args, keywords, format,\r
1532 kwlist, &lva, FLAG_SIZE_T);\r
1533 return retval;\r
1534}\r
1535\r
1536#define IS_END_OF_FORMAT(c) (c == '\0' || c == ';' || c == ':')\r
1537\r
1538static int\r
1539vgetargskeywords(PyObject *args, PyObject *keywords, const char *format,\r
1540 char **kwlist, va_list *p_va, int flags)\r
1541{\r
1542 char msgbuf[512];\r
1543 int levels[32];\r
1544 const char *fname, *msg, *custom_msg, *keyword;\r
1545 int min = INT_MAX;\r
1546 int i, len, nargs, nkeywords;\r
1547 PyObject *freelist = NULL, *current_arg;\r
1548\r
1549 assert(args != NULL && PyTuple_Check(args));\r
1550 assert(keywords == NULL || PyDict_Check(keywords));\r
1551 assert(format != NULL);\r
1552 assert(kwlist != NULL);\r
1553 assert(p_va != NULL);\r
1554\r
1555 /* grab the function name or custom error msg first (mutually exclusive) */\r
1556 fname = strchr(format, ':');\r
1557 if (fname) {\r
1558 fname++;\r
1559 custom_msg = NULL;\r
1560 }\r
1561 else {\r
1562 custom_msg = strchr(format,';');\r
1563 if (custom_msg)\r
1564 custom_msg++;\r
1565 }\r
1566\r
1567 /* scan kwlist and get greatest possible nbr of args */\r
1568 for (len=0; kwlist[len]; len++)\r
1569 continue;\r
1570\r
1571 nargs = PyTuple_GET_SIZE(args);\r
1572 nkeywords = (keywords == NULL) ? 0 : PyDict_Size(keywords);\r
1573 if (nargs + nkeywords > len) {\r
1574 PyErr_Format(PyExc_TypeError, "%s%s takes at most %d "\r
1575 "argument%s (%d given)",\r
1576 (fname == NULL) ? "function" : fname,\r
1577 (fname == NULL) ? "" : "()",\r
1578 len,\r
1579 (len == 1) ? "" : "s",\r
1580 nargs + nkeywords);\r
1581 return 0;\r
1582 }\r
1583\r
1584 /* convert tuple args and keyword args in same loop, using kwlist to drive process */\r
1585 for (i = 0; i < len; i++) {\r
1586 keyword = kwlist[i];\r
1587 if (*format == '|') {\r
1588 min = i;\r
1589 format++;\r
1590 }\r
1591 if (IS_END_OF_FORMAT(*format)) {\r
1592 PyErr_Format(PyExc_RuntimeError,\r
1593 "More keyword list entries (%d) than "\r
1594 "format specifiers (%d)", len, i);\r
1595 return cleanreturn(0, freelist);\r
1596 }\r
1597 current_arg = NULL;\r
1598 if (nkeywords) {\r
1599 current_arg = PyDict_GetItemString(keywords, keyword);\r
1600 }\r
1601 if (current_arg) {\r
1602 --nkeywords;\r
1603 if (i < nargs) {\r
1604 /* arg present in tuple and in dict */\r
1605 PyErr_Format(PyExc_TypeError,\r
1606 "Argument given by name ('%s') "\r
1607 "and position (%d)",\r
1608 keyword, i+1);\r
1609 return cleanreturn(0, freelist);\r
1610 }\r
1611 }\r
1612 else if (nkeywords && PyErr_Occurred())\r
1613 return cleanreturn(0, freelist);\r
1614 else if (i < nargs)\r
1615 current_arg = PyTuple_GET_ITEM(args, i);\r
1616\r
1617 if (current_arg) {\r
1618 msg = convertitem(current_arg, &format, p_va, flags,\r
1619 levels, msgbuf, sizeof(msgbuf), &freelist);\r
1620 if (msg) {\r
1621 seterror(i+1, msg, levels, fname, custom_msg);\r
1622 return cleanreturn(0, freelist);\r
1623 }\r
1624 continue;\r
1625 }\r
1626\r
1627 if (i < min) {\r
1628 PyErr_Format(PyExc_TypeError, "Required argument "\r
1629 "'%s' (pos %d) not found",\r
1630 keyword, i+1);\r
1631 return cleanreturn(0, freelist);\r
1632 }\r
1633 /* current code reports success when all required args\r
1634 * fulfilled and no keyword args left, with no further\r
1635 * validation. XXX Maybe skip this in debug build ?\r
1636 */\r
1637 if (!nkeywords)\r
1638 return cleanreturn(1, freelist);\r
1639\r
1640 /* We are into optional args, skip thru to any remaining\r
1641 * keyword args */\r
1642 msg = skipitem(&format, p_va, flags);\r
1643 if (msg) {\r
1644 PyErr_Format(PyExc_RuntimeError, "%s: '%s'", msg,\r
1645 format);\r
1646 return cleanreturn(0, freelist);\r
1647 }\r
1648 }\r
1649\r
1650 if (!IS_END_OF_FORMAT(*format) && *format != '|') {\r
1651 PyErr_Format(PyExc_RuntimeError,\r
1652 "more argument specifiers than keyword list entries "\r
1653 "(remaining format:'%s')", format);\r
1654 return cleanreturn(0, freelist);\r
1655 }\r
1656\r
1657 /* make sure there are no extraneous keyword arguments */\r
1658 if (nkeywords > 0) {\r
1659 PyObject *key, *value;\r
1660 Py_ssize_t pos = 0;\r
1661 while (PyDict_Next(keywords, &pos, &key, &value)) {\r
1662 int match = 0;\r
1663 char *ks;\r
1664 if (!PyString_Check(key)) {\r
1665 PyErr_SetString(PyExc_TypeError,\r
1666 "keywords must be strings");\r
1667 return cleanreturn(0, freelist);\r
1668 }\r
1669 ks = PyString_AsString(key);\r
1670 for (i = 0; i < len; i++) {\r
1671 if (!strcmp(ks, kwlist[i])) {\r
1672 match = 1;\r
1673 break;\r
1674 }\r
1675 }\r
1676 if (!match) {\r
1677 PyErr_Format(PyExc_TypeError,\r
1678 "'%s' is an invalid keyword "\r
1679 "argument for this function",\r
1680 ks);\r
1681 return cleanreturn(0, freelist);\r
1682 }\r
1683 }\r
1684 }\r
1685\r
1686 return cleanreturn(1, freelist);\r
1687}\r
1688\r
1689\r
1690static char *\r
1691skipitem(const char **p_format, va_list *p_va, int flags)\r
1692{\r
1693 const char *format = *p_format;\r
1694 char c = *format++;\r
1695\r
1696 switch (c) {\r
1697\r
1698 /* simple codes\r
1699 * The individual types (second arg of va_arg) are irrelevant */\r
1700\r
1701 case 'b': /* byte -- very short int */\r
1702 case 'B': /* byte as bitfield */\r
1703 case 'h': /* short int */\r
1704 case 'H': /* short int as bitfield */\r
1705 case 'i': /* int */\r
1706 case 'I': /* int sized bitfield */\r
1707 case 'l': /* long int */\r
1708 case 'k': /* long int sized bitfield */\r
1709#ifdef HAVE_LONG_LONG\r
1710 case 'L': /* PY_LONG_LONG */\r
1711 case 'K': /* PY_LONG_LONG sized bitfield */\r
1712#endif\r
1713 case 'f': /* float */\r
1714 case 'd': /* double */\r
1715#ifndef WITHOUT_COMPLEX\r
1716 case 'D': /* complex double */\r
1717#endif\r
1718 case 'c': /* char */\r
1719 {\r
1720 (void) va_arg(*p_va, void *);\r
1721 break;\r
1722 }\r
1723\r
1724 case 'n': /* Py_ssize_t */\r
1725 {\r
1726 (void) va_arg(*p_va, Py_ssize_t *);\r
1727 break;\r
1728 }\r
1729\r
1730 /* string codes */\r
1731\r
1732 case 'e': /* string with encoding */\r
1733 {\r
1734 (void) va_arg(*p_va, const char *);\r
1735 if (!(*format == 's' || *format == 't'))\r
1736 /* after 'e', only 's' and 't' is allowed */\r
1737 goto err;\r
1738 format++;\r
1739 /* explicit fallthrough to string cases */\r
1740 }\r
1741\r
1742 case 's': /* string */\r
1743 case 'z': /* string or None */\r
1744#ifdef Py_USING_UNICODE\r
1745 case 'u': /* unicode string */\r
1746#endif\r
1747 case 't': /* buffer, read-only */\r
1748 case 'w': /* buffer, read-write */\r
1749 {\r
1750 (void) va_arg(*p_va, char **);\r
1751 if (*format == '#') {\r
1752 if (flags & FLAG_SIZE_T)\r
1753 (void) va_arg(*p_va, Py_ssize_t *);\r
1754 else\r
1755 (void) va_arg(*p_va, int *);\r
1756 format++;\r
1757 } else if ((c == 's' || c == 'z') && *format == '*') {\r
1758 format++;\r
1759 }\r
1760 break;\r
1761 }\r
1762\r
1763 /* object codes */\r
1764\r
1765 case 'S': /* string object */\r
1766#ifdef Py_USING_UNICODE\r
1767 case 'U': /* unicode string object */\r
1768#endif\r
1769 {\r
1770 (void) va_arg(*p_va, PyObject **);\r
1771 break;\r
1772 }\r
1773\r
1774 case 'O': /* object */\r
1775 {\r
1776 if (*format == '!') {\r
1777 format++;\r
1778 (void) va_arg(*p_va, PyTypeObject*);\r
1779 (void) va_arg(*p_va, PyObject **);\r
1780 }\r
1781 else if (*format == '&') {\r
1782 typedef int (*converter)(PyObject *, void *);\r
1783 (void) va_arg(*p_va, converter);\r
1784 (void) va_arg(*p_va, void *);\r
1785 format++;\r
1786 }\r
1787 else {\r
1788 (void) va_arg(*p_va, PyObject **);\r
1789 }\r
1790 break;\r
1791 }\r
1792\r
1793 case '(': /* bypass tuple, not handled at all previously */\r
1794 {\r
1795 char *msg;\r
1796 for (;;) {\r
1797 if (*format==')')\r
1798 break;\r
1799 if (IS_END_OF_FORMAT(*format))\r
1800 return "Unmatched left paren in format "\r
1801 "string";\r
1802 msg = skipitem(&format, p_va, flags);\r
1803 if (msg)\r
1804 return msg;\r
1805 }\r
1806 format++;\r
1807 break;\r
1808 }\r
1809\r
1810 case ')':\r
1811 return "Unmatched right paren in format string";\r
1812\r
1813 default:\r
1814err:\r
1815 return "impossible<bad format char>";\r
1816\r
1817 }\r
1818\r
1819 *p_format = format;\r
1820 return NULL;\r
1821}\r
1822\r
1823\r
1824int\r
1825PyArg_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, ...)\r
1826{\r
1827 Py_ssize_t i, l;\r
1828 PyObject **o;\r
1829 va_list vargs;\r
1830\r
1831#ifdef HAVE_STDARG_PROTOTYPES\r
1832 va_start(vargs, max);\r
1833#else\r
1834 va_start(vargs);\r
1835#endif\r
1836\r
1837 assert(min >= 0);\r
1838 assert(min <= max);\r
1839 if (!PyTuple_Check(args)) {\r
1840 va_end(vargs);\r
1841 PyErr_SetString(PyExc_SystemError,\r
1842 "PyArg_UnpackTuple() argument list is not a tuple");\r
1843 return 0;\r
1844 }\r
1845 l = PyTuple_GET_SIZE(args);\r
1846 if (l < min) {\r
1847 if (name != NULL)\r
1848 PyErr_Format(\r
1849 PyExc_TypeError,\r
1850 "%s expected %s%zd arguments, got %zd",\r
1851 name, (min == max ? "" : "at least "), min, l);\r
1852 else\r
1853 PyErr_Format(\r
1854 PyExc_TypeError,\r
1855 "unpacked tuple should have %s%zd elements,"\r
1856 " but has %zd",\r
1857 (min == max ? "" : "at least "), min, l);\r
1858 va_end(vargs);\r
1859 return 0;\r
1860 }\r
1861 if (l > max) {\r
1862 if (name != NULL)\r
1863 PyErr_Format(\r
1864 PyExc_TypeError,\r
1865 "%s expected %s%zd arguments, got %zd",\r
1866 name, (min == max ? "" : "at most "), max, l);\r
1867 else\r
1868 PyErr_Format(\r
1869 PyExc_TypeError,\r
1870 "unpacked tuple should have %s%zd elements,"\r
1871 " but has %zd",\r
1872 (min == max ? "" : "at most "), max, l);\r
1873 va_end(vargs);\r
1874 return 0;\r
1875 }\r
1876 for (i = 0; i < l; i++) {\r
1877 o = va_arg(vargs, PyObject **);\r
1878 *o = PyTuple_GET_ITEM(args, i);\r
1879 }\r
1880 va_end(vargs);\r
1881 return 1;\r
1882}\r
1883\r
1884\r
1885/* For type constructors that don't take keyword args\r
1886 *\r
1887 * Sets a TypeError and returns 0 if the kwds dict is\r
1888 * not empty, returns 1 otherwise\r
1889 */\r
1890int\r
1891_PyArg_NoKeywords(const char *funcname, PyObject *kw)\r
1892{\r
1893 if (kw == NULL)\r
1894 return 1;\r
1895 if (!PyDict_CheckExact(kw)) {\r
1896 PyErr_BadInternalCall();\r
1897 return 0;\r
1898 }\r
1899 if (PyDict_Size(kw) == 0)\r
1900 return 1;\r
1901\r
1902 PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",\r
1903 funcname);\r
1904 return 0;\r
1905}\r
1906#ifdef __cplusplus\r
1907};\r
1908#endif\r
EFI Development Kit II mirror for PVE