/Python/getargs.c

http://unladen-swallow.googlecode.com/ · C · 1871 lines · 1578 code · 179 blank · 114 comment · 484 complexity · c12cb689e1fe7654bf93054bb6554d2e MD5 · raw file

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