home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / py2s152.zip / Python / getargs.c < prev    next >
C/C++ Source or Header  |  1999-06-27  |  26KB  |  1,131 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its
  8. documentation for any purpose and without fee is hereby granted,
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI or Corporation for National Research Initiatives or
  13. CNRI not be used in advertising or publicity pertaining to
  14. distribution of the software without specific, written prior
  15. permission.
  16.  
  17. While CWI is the initial source for this software, a modified version
  18. is made available by the Corporation for National Research Initiatives
  19. (CNRI) at the Internet address ftp://ftp.python.org.
  20.  
  21. STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22. REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23. MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24. CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26. PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27. TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28. PERFORMANCE OF THIS SOFTWARE.
  29.  
  30. ******************************************************************/
  31.  
  32. /* New getargs implementation */
  33.  
  34. /* XXX There are several unchecked sprintf or strcat calls in this file.
  35.    XXX The only way these can become a danger is if some C code in the
  36.    XXX Python source (or in an extension) uses ridiculously long names
  37.    XXX or riduculously deep nesting in format strings. */
  38.  
  39. #include "Python.h"
  40.  
  41. #include <ctype.h>
  42.  
  43.  
  44. int PyArg_Parse Py_PROTO((PyObject *, char *, ...));
  45. int PyArg_ParseTuple Py_PROTO((PyObject *, char *, ...));
  46. int PyArg_VaParse Py_PROTO((PyObject *, char *, va_list));
  47.  
  48. int PyArg_ParseTupleAndKeywords Py_PROTO((PyObject *, PyObject *,
  49.                        char *, char **, ...));
  50.  
  51. /* Forward */
  52. static int vgetargs1 Py_PROTO((PyObject *, char *, va_list *, int));
  53. static void seterror Py_PROTO((int, char *, int *, char *, char *));
  54. static char *convertitem Py_PROTO((PyObject *, char **, va_list *,
  55.                    int *, char *));
  56. static char *converttuple Py_PROTO((PyObject *, char **, va_list *,
  57.                  int *, char *, int));
  58. static char *convertsimple Py_PROTO((PyObject *, char **, va_list *, char *));
  59. static char *convertsimple1 Py_PROTO((PyObject *, char **, va_list *));
  60.  
  61. static int vgetargskeywords Py_PROTO((PyObject *, PyObject *,
  62.                    char *, char **, va_list *));
  63. static char *skipitem Py_PROTO((char **, va_list *));
  64.  
  65. #ifdef HAVE_STDARG_PROTOTYPES
  66. /* VARARGS2 */
  67. int PyArg_Parse(PyObject *args, char *format, ...)
  68. #else
  69. /* VARARGS */
  70. int PyArg_Parse(va_alist) va_dcl
  71. #endif
  72. {
  73.     int retval;
  74.     va_list va;
  75. #ifdef HAVE_STDARG_PROTOTYPES
  76.     
  77.     va_start(va, format);
  78. #else
  79.     PyObject *args;
  80.     char *format;
  81.     
  82.     va_start(va);
  83.     args = va_arg(va, PyObject *);
  84.     format = va_arg(va, char *);
  85. #endif
  86.     retval = vgetargs1(args, format, &va, 1);
  87.     va_end(va);
  88.     return retval;
  89. }
  90.  
  91.  
  92. #ifdef HAVE_STDARG_PROTOTYPES
  93. /* VARARGS2 */
  94. int PyArg_ParseTuple(PyObject *args, char *format, ...)
  95. #else
  96. /* VARARGS */
  97. int PyArg_ParseTuple(va_alist) va_dcl
  98. #endif
  99. {
  100.     int retval;
  101.     va_list va;
  102. #ifdef HAVE_STDARG_PROTOTYPES
  103.     
  104.     va_start(va, format);
  105. #else
  106.     PyObject *args;
  107.     char *format;
  108.     
  109.     va_start(va);
  110.     args = va_arg(va, PyObject *);
  111.     format = va_arg(va, char *);
  112. #endif
  113.     retval = vgetargs1(args, format, &va, 0);
  114.     va_end(va);
  115.     return retval;
  116. }
  117.  
  118.  
  119. int
  120. PyArg_VaParse(args, format, va)
  121.     PyObject *args;
  122.     char *format;
  123.     va_list va;
  124. {
  125.     va_list lva;
  126.  
  127. #ifdef VA_LIST_IS_ARRAY
  128.     memcpy(lva, va, sizeof(va_list));
  129. #else
  130.     lva = va;
  131. #endif
  132.  
  133.     return vgetargs1(args, format, &lva, 0);
  134. }
  135.  
  136.  
  137. static int
  138. vgetargs1(args, format, p_va, compat)
  139.     PyObject *args;
  140.     char *format;
  141.     va_list *p_va;
  142.     int compat;
  143. {
  144.     char msgbuf[256];
  145.     int levels[32];
  146.     char *fname = NULL;
  147.     char *message = NULL;
  148.     int min = -1;
  149.     int max = 0;
  150.     int level = 0;
  151.     char *formatsave = format;
  152.     int i, len;
  153.     char *msg;
  154.     
  155.     for (;;) {
  156.         int c = *format++;
  157.         if (c == '(' /* ')' */) {
  158.             if (level == 0)
  159.                 max++;
  160.             level++;
  161.         }
  162.         else if (/* '(' */ c == ')') {
  163.             if (level == 0)
  164.                 Py_FatalError(/* '(' */
  165.                       "excess ')' in getargs format");
  166.             else
  167.                 level--;
  168.         }
  169.         else if (c == '\0')
  170.             break;
  171.         else if (c == ':') {
  172.             fname = format;
  173.             break;
  174.         }
  175.         else if (c == ';') {
  176.             message = format;
  177.             break;
  178.         }
  179.         else if (level != 0)
  180.             ; /* Pass */
  181.         else if (isalpha(c))
  182.             max++;
  183.         else if (c == '|')
  184.             min = max;
  185.     }
  186.     
  187.     if (level != 0)
  188.         Py_FatalError(/* '(' */ "missing ')' in getargs format");
  189.     
  190.     if (min < 0)
  191.         min = max;
  192.     
  193.     format = formatsave;
  194.     
  195.     if (compat) {
  196.         if (max == 0) {
  197.             if (args == NULL)
  198.                 return 1;
  199.             sprintf(msgbuf, "%s requires no arguments",
  200.                 fname==NULL ? "function" : fname);
  201.             PyErr_SetString(PyExc_TypeError, msgbuf);
  202.             return 0;
  203.         }
  204.         else if (min == 1 && max == 1) {
  205.             if (args == NULL) {
  206.                 sprintf(msgbuf,
  207.                     "%s requires at least one argument",
  208.                     fname==NULL ? "function" : fname);
  209.                 PyErr_SetString(PyExc_TypeError, msgbuf);
  210.                 return 0;
  211.             }
  212.             msg = convertitem(args, &format, p_va, levels, msgbuf);
  213.             if (msg == NULL)
  214.                 return 1;
  215.             seterror(levels[0], msg, levels+1, fname, message);
  216.             return 0;
  217.         }
  218.         else {
  219.             PyErr_SetString(PyExc_SystemError,
  220.                 "old style getargs format uses new features");
  221.             return 0;
  222.         }
  223.     }
  224.     
  225.     if (!PyTuple_Check(args)) {
  226.         PyErr_SetString(PyExc_SystemError,
  227.             "new style getargs format but argument is not a tuple");
  228.         return 0;
  229.     }
  230.     
  231.     len = PyTuple_Size(args);
  232.     
  233.     if (len < min || max < len) {
  234.         if (message == NULL) {
  235.             sprintf(msgbuf,
  236.                 "%s requires %s %d argument%s; %d given",
  237.                 fname==NULL ? "function" : fname,
  238.                 min==max ? "exactly"
  239.                          : len < min ? "at least" : "at most",
  240.                 len < min ? min : max,
  241.                 (len < min ? min : max) == 1 ? "" : "s",
  242.                 len);
  243.             message = msgbuf;
  244.         }
  245.         PyErr_SetString(PyExc_TypeError, message);
  246.         return 0;
  247.     }
  248.     
  249.     for (i = 0; i < len; i++) {
  250.         if (*format == '|')
  251.             format++;
  252.         msg = convertitem(PyTuple_GetItem(args, i), &format, p_va,
  253.                  levels, msgbuf);
  254.         if (msg) {
  255.             seterror(i+1, msg, levels, fname, message);
  256.             return 0;
  257.         }
  258.     }
  259.  
  260.     if (*format != '\0' && !isalpha((int)(*format)) &&
  261.         *format != '(' &&
  262.         *format != '|' && *format != ':' && *format != ';') {
  263.         PyErr_Format(PyExc_SystemError,
  264.                  "bad format string: %.200s", formatsave);
  265.         return 0;
  266.     }
  267.     
  268.     return 1;
  269. }
  270.  
  271.  
  272.  
  273. static void
  274. seterror(iarg, msg, levels, fname, message)
  275.     int iarg;
  276.     char *msg;
  277.     int *levels;
  278.     char *fname;
  279.     char *message;
  280. {
  281.     char buf[256];
  282.     int i;
  283.     char *p = buf;
  284.  
  285.     if (PyErr_Occurred())
  286.         return;
  287.     if (iarg == 0 && message == NULL)
  288.         message = msg;
  289.     else if (message == NULL) {
  290.         if (fname != NULL) {
  291.             sprintf(p, "%s, ", fname);
  292.             p += strlen(p);
  293.         }
  294.         sprintf(p, "argument %d", iarg);
  295.         i = 0;
  296.         p += strlen(p);
  297.         while (levels[i] > 0) {
  298.             sprintf(p, ", item %d", levels[i]-1);
  299.             p += strlen(p);
  300.             i++;
  301.         }
  302.         sprintf(p, ": expected %s found", msg);
  303.         message = buf;
  304.     }
  305.     PyErr_SetString(PyExc_TypeError, message);
  306. }
  307.  
  308.  
  309. /* Convert a tuple argument.
  310.    On entry, *p_format points to the character _after_ the opening '('.
  311.    On successful exit, *p_format points to the closing ')'.
  312.    If successful:
  313.       *p_format and *p_va are updated,
  314.       *levels and *msgbuf are untouched,
  315.       and NULL is returned.
  316.    If the argument is invalid:
  317.       *p_format is unchanged,
  318.       *p_va is undefined,
  319.       *levels is a 0-terminated list of item numbers,
  320.       *msgbuf contains an error message, whose format is:
  321.          "<typename1>, <typename2>", where:
  322.             <typename1> is the name of the expected type, and
  323.             <typename2> is the name of the actual type,
  324.          (so you can surround it by "expected ... found"),
  325.       and msgbuf is returned.
  326. */
  327.  
  328. static char *
  329. converttuple(arg, p_format, p_va, levels, msgbuf, toplevel)
  330.     PyObject *arg;
  331.     char **p_format;
  332.     va_list *p_va;
  333.     int *levels;
  334.     char *msgbuf;
  335.     int toplevel;
  336. {
  337.     int level = 0;
  338.     int n = 0;
  339.     char *format = *p_format;
  340.     int i;
  341.     
  342.     for (;;) {
  343.         int c = *format++;
  344.         if (c == '(') {
  345.             if (level == 0)
  346.                 n++;
  347.             level++;
  348.         }
  349.         else if (c == ')') {
  350.             if (level == 0)
  351.                 break;
  352.             level--;
  353.         }
  354.         else if (c == ':' || c == ';' || c == '\0')
  355.             break;
  356.         else if (level == 0 && isalpha(c))
  357.             n++;
  358.     }
  359.     
  360.     if (!PySequence_Check(arg)) {
  361.         levels[0] = 0;
  362.         sprintf(msgbuf,
  363.             toplevel ? "%d arguments, %s" : "%d-sequence, %s",
  364.             n, arg == Py_None ? "None" : arg->ob_type->tp_name);
  365.         return msgbuf;
  366.     }
  367.     
  368.     if ((i = PySequence_Length(arg)) != n) {
  369.         levels[0] = 0;
  370.         sprintf(msgbuf,
  371.             toplevel ? "%d arguments, %d" : "%d-sequence, %d-sequence",
  372.             n, i);
  373.         return msgbuf;
  374.     }
  375.     
  376.     format = *p_format;
  377.     for (i = 0; i < n; i++) {
  378.         char *msg;
  379.         PyObject *item;
  380.         item = PySequence_GetItem(arg, i);
  381.         msg = convertitem(item, &format, p_va, levels+1, msgbuf);
  382.         /* PySequence_GetItem calls tp->sq_item, which INCREFs */
  383.         Py_XDECREF(item);
  384.         if (msg != NULL) {
  385.             levels[0] = i+1;
  386.             return msg;
  387.         }
  388.     }
  389.     
  390.     *p_format = format;
  391.     return NULL;
  392. }
  393.  
  394.  
  395. /* Convert a single item. */
  396.  
  397. static char *
  398. convertitem(arg, p_format, p_va, levels, msgbuf)
  399.     PyObject *arg;
  400.     char **p_format;
  401.     va_list *p_va;
  402.     int *levels;
  403.     char *msgbuf;
  404. {
  405.     char *msg;
  406.     char *format = *p_format;
  407.     
  408.     if (*format == '(' /* ')' */) {
  409.         format++;
  410.         msg = converttuple(arg, &format, p_va, levels, msgbuf, 0);
  411.         if (msg == NULL)
  412.             format++;
  413.     }
  414.     else {
  415.         msg = convertsimple(arg, &format, p_va, msgbuf);
  416.         if (msg != NULL)
  417.             levels[0] = 0;
  418.     }
  419.     if (msg == NULL)
  420.         *p_format = format;
  421.     return msg;
  422. }
  423.  
  424.  
  425. /* Convert a non-tuple argument.  Adds to convertsimple1 functionality
  426.    by appending ", <actual argument type>" to error message. */
  427.  
  428. static char *
  429. convertsimple(arg, p_format, p_va, msgbuf)
  430.     PyObject *arg;
  431.     char **p_format;
  432.     va_list *p_va;
  433.     char *msgbuf;
  434. {
  435.     char *msg = convertsimple1(arg, p_format, p_va);
  436.     if (msg != NULL) {
  437.         sprintf(msgbuf, "%.50s, %.50s", msg,
  438.             arg == Py_None ? "None" : arg->ob_type->tp_name);
  439.         msg = msgbuf;
  440.     }
  441.     return msg;
  442. }
  443.  
  444.  
  445. /* Convert a non-tuple argument.  Return NULL if conversion went OK,
  446.    or a string representing the expected type if the conversion failed.
  447.    When failing, an exception may or may not have been raised.
  448.    Don't call if a tuple is expected. */
  449.  
  450. static char *
  451. convertsimple1(arg, p_format, p_va)
  452.     PyObject *arg;
  453.     char **p_format;
  454.     va_list *p_va;
  455. {
  456.     char *format = *p_format;
  457.     char c = *format++;
  458.     
  459.     switch (c) {
  460.     
  461.     case 'b': /* byte -- very short int */
  462.         {
  463.             char *p = va_arg(*p_va, char *);
  464.             long ival = PyInt_AsLong(arg);
  465.             if (ival == -1 && PyErr_Occurred())
  466.                 return "integer<b>";
  467.             else
  468.                 *p = (char) ival;
  469.             break;
  470.         }
  471.     
  472.     case 'h': /* short int */
  473.         {
  474.             short *p = va_arg(*p_va, short *);
  475.             long ival = PyInt_AsLong(arg);
  476.             if (ival == -1 && PyErr_Occurred())
  477.                 return "integer<h>";
  478.             else
  479.                 *p = (short) ival;
  480.             break;
  481.         }
  482.     
  483.     case 'i': /* int */
  484.         {
  485.             int *p = va_arg(*p_va, int *);
  486.             long ival = PyInt_AsLong(arg);
  487.             if (ival == -1 && PyErr_Occurred())
  488.                 return "integer<i>";
  489.             else
  490.                 *p = ival;
  491.             break;
  492.         }
  493.     
  494.     case 'l': /* long int */
  495.         {
  496.             long *p = va_arg(*p_va, long *);
  497.             long ival = PyInt_AsLong(arg);
  498.             if (ival == -1 && PyErr_Occurred())
  499.                 return "integer<l>";
  500.             else
  501.                 *p = ival;
  502.             break;
  503.         }
  504.     
  505. #ifdef HAVE_LONG_LONG
  506.     case 'L': /* LONG_LONG */
  507.         {
  508.             LONG_LONG *p = va_arg( *p_va, LONG_LONG * );
  509.             LONG_LONG ival = PyLong_AsLongLong( arg );
  510.             if( ival == (LONG_LONG)-1 && PyErr_Occurred() ) {
  511.                 return "long<L>";
  512.             } else {
  513.                 *p = ival;
  514.             }
  515.             break;
  516.         }
  517. #endif
  518.     
  519.     case 'f': /* float */
  520.         {
  521.             float *p = va_arg(*p_va, float *);
  522.             double dval = PyFloat_AsDouble(arg);
  523.             if (PyErr_Occurred())
  524.                 return "float<f>";
  525.             else
  526.                 *p = (float) dval;
  527.             break;
  528.         }
  529.     
  530.     case 'd': /* double */
  531.         {
  532.             double *p = va_arg(*p_va, double *);
  533.             double dval = PyFloat_AsDouble(arg);
  534.             if (PyErr_Occurred())
  535.                 return "float<d>";
  536.             else
  537.                 *p = dval;
  538.             break;
  539.         }
  540.     
  541. #ifndef WITHOUT_COMPLEX
  542.     case 'D': /* complex double */
  543.         {
  544.             Py_complex *p = va_arg(*p_va, Py_complex *);
  545.             Py_complex cval;
  546.             cval = PyComplex_AsCComplex(arg);
  547.             if (PyErr_Occurred())
  548.                 return "complex<D>";
  549.             else
  550.                 *p = cval;
  551.             break;
  552.         }
  553. #endif /* WITHOUT_COMPLEX */
  554.     
  555.     case 'c': /* char */
  556.         {
  557.             char *p = va_arg(*p_va, char *);
  558.             if (PyString_Check(arg) && PyString_Size(arg) == 1)
  559.                 *p = PyString_AsString(arg)[0];
  560.             else
  561.                 return "char";
  562.             break;
  563.         }
  564.     
  565.     case 's': /* string */
  566.         {
  567.             if (*format == '#') { /* any buffer-like object */
  568.                     void **p = (void **)va_arg(*p_va, char **);
  569.                     PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
  570.                 int *q = va_arg(*p_va, int *);
  571.                 int count;
  572.  
  573.                 if ( pb == NULL ||
  574.                      pb->bf_getreadbuffer == NULL ||
  575.                      pb->bf_getsegcount == NULL )
  576.                   return "read-only buffer";
  577.                 if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
  578.                   return "single-segment read-only buffer";
  579.                 if ( (count =
  580.                       (*pb->bf_getreadbuffer)(arg, 0, p)) < 0 )
  581.                   return "(unspecified)";
  582.                 *q = count;
  583.                 format++;
  584.             } else {
  585.                     char **p = va_arg(*p_va, char **);
  586.             
  587.                     if (PyString_Check(arg))
  588.                   *p = PyString_AsString(arg);
  589.                 else
  590.                   return "string";
  591.                 if ((int)strlen(*p) != PyString_Size(arg))
  592.                   return "string without null bytes";
  593.             }
  594.             break;
  595.         }
  596.  
  597.     case 'z': /* string, may be NULL (None) */
  598.         {
  599.             if (*format == '#') { /* any buffer-like object */
  600.                     void **p = (void **)va_arg(*p_va, char **);
  601.                     PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
  602.                 int *q = va_arg(*p_va, int *);
  603.                 int count;
  604.  
  605.                 if (arg == Py_None) {
  606.                   *p = 0;
  607.                   *q = 0;
  608.                 } else {
  609.                   if ( pb == NULL ||
  610.                        pb->bf_getreadbuffer == NULL ||
  611.                        pb->bf_getsegcount == NULL )
  612.                     return "read-only buffer";
  613.                   if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
  614.                   return "single-segment read-only buffer";
  615.                   if ( (count = (*pb->bf_getreadbuffer)
  616.                                         (arg, 0, p)) < 0 )
  617.                     return "(unspecified)";
  618.                   *q = count;
  619.                 }
  620.                 format++;
  621.             } else {
  622.                     char **p = va_arg(*p_va, char **);
  623.             
  624.                     if (arg == Py_None)
  625.                   *p = 0;
  626.                 else if (PyString_Check(arg))
  627.                   *p = PyString_AsString(arg);
  628.                 else
  629.                   return "None or string";
  630.                 if (*format == '#') {
  631.                   int *q = va_arg(*p_va, int *);
  632.                   if (arg == Py_None)
  633.                     *q = 0;
  634.                   else
  635.                     *q = PyString_Size(arg);
  636.                   format++;
  637.                 }
  638.                 else if (*p != NULL &&
  639.                      (int)strlen(*p) != PyString_Size(arg))
  640.                   return "None or string without null bytes";
  641.             }
  642.             break;
  643.         }
  644.     
  645.     case 'S': /* string object */
  646.         {
  647.             PyObject **p = va_arg(*p_va, PyObject **);
  648.             if (PyString_Check(arg))
  649.                 *p = arg;
  650.             else
  651.                 return "string";
  652.             break;
  653.         }
  654.     
  655.     case 'O': /* object */
  656.         {
  657.             PyTypeObject *type;
  658.             PyObject **p;
  659.             if (*format == '!') {
  660.                 type = va_arg(*p_va, PyTypeObject*);
  661.                 p = va_arg(*p_va, PyObject **);
  662.                 format++;
  663.                 if (arg->ob_type == type)
  664.                     *p = arg;
  665.                 else
  666.                     return type->tp_name;
  667.  
  668.             }
  669.             else if (*format == '?') {
  670.                 inquiry pred = va_arg(*p_va, inquiry);
  671.                 p = va_arg(*p_va, PyObject **);
  672.                 format++;
  673.                 if ((*pred)(arg)) 
  674.                     *p = arg;
  675.                 else
  676.                          return "(unspecified)";
  677.                 
  678.             }
  679.             else if (*format == '&') {
  680.                 typedef int (*converter)
  681.                     Py_PROTO((PyObject *, void *));
  682.                 converter convert = va_arg(*p_va, converter);
  683.                 void *addr = va_arg(*p_va, void *);
  684.                 format++;
  685.                 if (! (*convert)(arg, addr))
  686.                     return "(unspecified)";
  687.             }
  688.             else {
  689.                 p = va_arg(*p_va, PyObject **);
  690.                 *p = arg;
  691.             }
  692.             break;
  693.         }
  694.         
  695.         
  696.     case 'w': /* memory buffer, read-write access */
  697.         {
  698.             void **p = va_arg(*p_va, void **);
  699.             PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
  700.             int count;
  701.             
  702.             if ( pb == NULL || pb->bf_getwritebuffer == NULL ||
  703.                     pb->bf_getsegcount == NULL )
  704.                 return "read-write buffer";
  705.             if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
  706.                 return "single-segment read-write buffer";
  707.             if ( (count = pb->bf_getwritebuffer(arg, 0, p)) < 0 )
  708.                 return "(unspecified)";
  709.             if (*format == '#') {
  710.                 int *q = va_arg(*p_va, int *);
  711.                 
  712.                 *q = count;
  713.                 format++;
  714.             }
  715.             break;
  716.         }
  717.         
  718.     case 't': /* 8-bit character buffer, read-only access */
  719.         {
  720.             const char **p = va_arg(*p_va, const char **);
  721.             PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
  722.             int count;
  723.  
  724.             if ( *format++ != '#' )
  725.                 return "invalid use of 't' format character";
  726.             if ( !PyType_HasFeature(
  727.                 arg->ob_type,
  728.                 Py_TPFLAGS_HAVE_GETCHARBUFFER) ||
  729.                  pb == NULL ||
  730.                  pb->bf_getcharbuffer == NULL ||
  731.                  pb->bf_getsegcount == NULL )
  732.                 return "read-only character buffer";
  733.             if ( (*pb->bf_getsegcount)(arg, NULL) != 1 )
  734.                 return "single-segment read-only buffer";
  735.             if ( (count = pb->bf_getcharbuffer(arg, 0, p)) < 0 )
  736.                 return "(unspecified)";
  737.  
  738.             *va_arg(*p_va, int *) = count;
  739.  
  740.             break;
  741.         }
  742.         
  743.     
  744.     default:
  745.         return "impossible<bad format char>";
  746.     
  747.     }
  748.     
  749.     *p_format = format;
  750.     return NULL;
  751. }
  752.  
  753.  
  754. /* Support for keyword arguments donated by
  755.    Geoff Philbrick <philbric@delphi.hks.com> */
  756.  
  757. #ifdef HAVE_STDARG_PROTOTYPES
  758. /* VARARGS2 */
  759. int PyArg_ParseTupleAndKeywords(PyObject *args,
  760.                 PyObject *keywords,
  761.                 char *format, 
  762.                 char **kwlist, ...)
  763. #else
  764. /* VARARGS */
  765. int PyArg_ParseTupleAndKeywords(va_alist) va_dcl
  766. #endif
  767. {
  768.     int retval;
  769.     va_list va;
  770. #ifdef HAVE_STDARG_PROTOTYPES
  771.     
  772.     va_start(va, kwlist);
  773. #else
  774.     PyObject *args;
  775.     PyObject *keywords;
  776.     char *format;
  777.     char **kwlist;
  778.     
  779.     va_start(va);
  780.     args = va_arg(va, PyObject *);
  781.     keywords = va_arg(va, PyObject *);
  782.     format = va_arg(va, char *);
  783.     kwlist = va_arg(va, char **);
  784. #endif
  785.     retval = vgetargskeywords(args, keywords, format, kwlist, &va);    
  786.     va_end(va);
  787.     return retval;
  788. }
  789.  
  790.  
  791. static int
  792. vgetargskeywords(args, keywords, format, kwlist, p_va)
  793.     PyObject *args;
  794.     PyObject *keywords;
  795.     char *format;
  796.     char **kwlist;
  797.     va_list *p_va;
  798. {
  799.     char msgbuf[256];
  800.     int levels[32];
  801.     char *fname = NULL;
  802.     char *message = NULL;
  803.     int min = -1;
  804.     int max = 0;
  805.     char *formatsave = format;
  806.     int i, len, tplen, kwlen;
  807.     char *msg, *ks, **p;
  808.     int nkwds, pos, match, converted;
  809.     PyObject *key, *value;
  810.     
  811.     /* nested tuples cannot be parsed when using keyword arguments */
  812.     
  813.     for (;;) {
  814.         int c = *format++;
  815.         if (c == '(') {
  816.             PyErr_SetString(PyExc_SystemError,
  817.               "tuple found in format when using keyword arguments");
  818.             return 0;
  819.         }
  820.         else if (c == '\0')
  821.             break;
  822.         else if (c == ':') {
  823.             fname = format;
  824.             break;
  825.         }
  826.         else if (c == ';') {
  827.             message = format;
  828.             break;
  829.         }
  830.         else if (isalpha(c))
  831.             max++;
  832.         else if (c == '|')
  833.             min = max;
  834.     }    
  835.     
  836.     if (min < 0)
  837.         min = max;
  838.     
  839.     format = formatsave;
  840.     
  841.     if (!PyTuple_Check(args)) {
  842.         PyErr_SetString(PyExc_SystemError,
  843.             "new style getargs format but argument is not a tuple");
  844.         return 0;
  845.     }    
  846.     
  847.     tplen = PyTuple_Size(args);
  848.     
  849.     /* do a cursory check of the keywords just to see how many we got */
  850.        
  851.     if (keywords) {     
  852.         if (!PyDict_Check(keywords)) {
  853.             PyErr_SetString(PyExc_SystemError,
  854.       "non-dictionary object received when keyword dictionary expected");
  855.             return 0;
  856.         }    
  857.         kwlen = PyDict_Size(keywords);
  858.     }
  859.     else {
  860.         kwlen = 0;
  861.     }
  862.             
  863.     /* make sure there are no duplicate values for an argument;
  864.        its not clear when to use the term "keyword argument vs. 
  865.        keyword parameter in messages */
  866.     
  867.     if (keywords) {
  868.         for (i = 0; i < tplen; i++) {
  869.             if (PyMapping_HasKeyString(keywords, kwlist[i])) {
  870.                 sprintf(msgbuf,
  871.                     "keyword parameter %s redefined",
  872.                     kwlist[i]);
  873.                 PyErr_SetString(PyExc_TypeError, msgbuf);
  874.                 return 0;
  875.             }
  876.         }
  877.     }
  878.     PyErr_Clear(); /* I'm not which Py functions set the error string */
  879.         
  880.     /* required arguments missing from args can be supplied by keyword 
  881.        arguments */
  882.     
  883.     len = tplen;
  884.     if (keywords && tplen < min) {
  885.         for (i = tplen; i < min; i++) {
  886.           if (PyMapping_HasKeyString(keywords, kwlist[i])) {
  887.                 len++;
  888.           }
  889.         }
  890.     }
  891.     PyErr_Clear();    
  892.     
  893.     /* make sure we got an acceptable number of arguments; the message
  894.        is a little confusing with keywords since keyword arguments
  895.        which are supplied, but don't match the required arguments
  896.        are not included in the "%d given" part of the message */
  897.  
  898.     if (len < min || max < len) {
  899.         if (message == NULL) {
  900.             sprintf(msgbuf,
  901.                 "%s requires %s %d argument%s; %d given",
  902.                 fname==NULL ? "function" : fname,
  903.                 min==max ? "exactly"
  904.                          : len < min ? "at least" : "at most",
  905.                 len < min ? min : max,
  906.                 (len < min ? min : max) == 1 ? "" : "s",
  907.                 len);
  908.             message = msgbuf;
  909.         }
  910.         PyErr_SetString(PyExc_TypeError, message);
  911.         return 0;
  912.     }
  913.     
  914.     for (i = 0; i < tplen; i++) {
  915.         if (*format == '|')
  916.             format++;
  917.         msg = convertitem(PyTuple_GetItem(args, i), &format, p_va,
  918.                  levels, msgbuf);
  919.         if (msg) {
  920.             seterror(i+1, msg, levels, fname, message);
  921.             return 0;
  922.         }
  923.     }
  924.  
  925.     /* handle no keyword parameters in call  */    
  926.               
  927.     if (!keywords) return 1; 
  928.         
  929.     /* make sure the number of keywords in the keyword list matches the 
  930.        number of items in the format string */
  931.       
  932.     nkwds = 0;
  933.     p =  kwlist;
  934.     for (;;) {
  935.         if (!*(p++)) break;
  936.         nkwds++;
  937.     }
  938.  
  939.     if (nkwds != max) {
  940.         PyErr_SetString(PyExc_SystemError,
  941.       "number of items in format string and keyword list do not match");
  942.         return 0;
  943.     }            
  944.             
  945.     /* convert the keyword arguments; this uses the format 
  946.        string where it was left after processing args */
  947.     
  948.     converted = 0;
  949.     for (i = tplen; i < nkwds; i++) {
  950.         PyObject *item;
  951.         if (*format == '|')
  952.             format++;
  953.         item = PyMapping_GetItemString(keywords, kwlist[i]);
  954.         if (item != NULL) {
  955.             msg = convertitem(item, &format, p_va, levels, msgbuf);
  956.             if (msg) {
  957.                 seterror(i+1, msg, levels, fname, message);
  958.                 return 0;
  959.             }
  960.             converted++;
  961.         }
  962.         else {
  963.             PyErr_Clear();
  964.             msg = skipitem(&format, p_va);
  965.             if (msg) {
  966.                 seterror(i+1, msg, levels, fname, message);
  967.                 return 0;
  968.             }
  969.         }
  970.     }
  971.     
  972.     /* make sure there are no extraneous keyword arguments */
  973.     
  974.     pos = 0;
  975.     if (converted < kwlen) {
  976.         while (PyDict_Next(keywords, &pos, &key, &value)) {
  977.             match = 0;
  978.             ks = PyString_AsString(key);
  979.             for (i = 0; i < nkwds; i++) {
  980.                 if (!strcmp(ks, kwlist[i])) {
  981.                     match = 1;
  982.                     break;
  983.                 }
  984.             }
  985.             if (!match) {
  986.                 sprintf(msgbuf,
  987.                  "%s is an invalid keyword argument for this function",
  988.                     ks);
  989.                 PyErr_SetString(PyExc_TypeError, msgbuf);
  990.                 return 0;
  991.             }
  992.         }
  993.     }
  994.     
  995.     return 1;
  996. }
  997.  
  998.  
  999. static char *
  1000. skipitem(p_format, p_va)
  1001.     char **p_format;
  1002.     va_list *p_va;
  1003. {
  1004.     char *format = *p_format;
  1005.     char c = *format++;
  1006.     
  1007.     switch (c) {
  1008.     
  1009.     case 'b': /* byte -- very short int */
  1010.         {
  1011.             (void) va_arg(*p_va, char *);
  1012.             break;
  1013.         }
  1014.     
  1015.     case 'h': /* short int */
  1016.         {
  1017.             (void) va_arg(*p_va, short *);
  1018.             break;
  1019.         }
  1020.     
  1021.     case 'i': /* int */
  1022.         {
  1023.             (void) va_arg(*p_va, int *);
  1024.             break;
  1025.         }
  1026.     
  1027.     case 'l': /* long int */
  1028.         {
  1029.             (void) va_arg(*p_va, long *);
  1030.             break;
  1031.         }
  1032.     
  1033. #ifdef HAVE_LONG_LONG
  1034.     case 'L': /* LONG_LONG int */
  1035.         {
  1036.             (void) va_arg(*p_va, LONG_LONG *);
  1037.             break;
  1038.         }
  1039. #endif
  1040.     
  1041.     case 'f': /* float */
  1042.         {
  1043.             (void) va_arg(*p_va, float *);
  1044.             break;
  1045.         }
  1046.     
  1047.     case 'd': /* double */
  1048.         {
  1049.             (void) va_arg(*p_va, double *);
  1050.             break;
  1051.         }
  1052.     
  1053. #ifndef WITHOUT_COMPLEX
  1054.     case 'D': /* complex double */
  1055.         {
  1056.             (void) va_arg(*p_va, Py_complex *);
  1057.             break;
  1058.         }
  1059. #endif /* WITHOUT_COMPLEX */
  1060.     
  1061.     case 'c': /* char */
  1062.         {
  1063.             (void) va_arg(*p_va, char *);
  1064.             break;
  1065.         }
  1066.     
  1067.     case 's': /* string */
  1068.         {
  1069.             (void) va_arg(*p_va, char **);
  1070.             if (*format == '#') {
  1071.                 (void) va_arg(*p_va, int *);
  1072.                 format++;
  1073.             }
  1074.             break;
  1075.         }
  1076.     
  1077.     case 'z': /* string */
  1078.         {
  1079.             (void) va_arg(*p_va, char **);
  1080.             if (*format == '#') {
  1081.                 (void) va_arg(*p_va, int *);
  1082.                 format++;
  1083.             }
  1084.             break;
  1085.         }
  1086.     
  1087.     case 'S': /* string object */
  1088.         {
  1089.             (void) va_arg(*p_va, PyObject **);
  1090.             break;
  1091.         }
  1092.     
  1093.     case 'O': /* object */
  1094.         {
  1095.             if (*format == '!') {
  1096.                 format++;
  1097.                 (void) va_arg(*p_va, PyTypeObject*);
  1098.                 (void) va_arg(*p_va, PyObject **);
  1099.             }
  1100. #if 0
  1101. /* I don't know what this is for */
  1102.             else if (*format == '?') {
  1103.                 inquiry pred = va_arg(*p_va, inquiry);
  1104.                 format++;
  1105.                 if ((*pred)(arg)) {
  1106.                     (void) va_arg(*p_va, PyObject **);
  1107.                 }
  1108.             }
  1109. #endif
  1110.             else if (*format == '&') {
  1111.                 typedef int (*converter)
  1112.                     Py_PROTO((PyObject *, void *));
  1113.                 (void) va_arg(*p_va, converter);
  1114.                 (void) va_arg(*p_va, void *);
  1115.                 format++;
  1116.             }
  1117.             else {
  1118.                 (void) va_arg(*p_va, PyObject **);
  1119.             }
  1120.             break;
  1121.         }
  1122.     
  1123.     default:
  1124.         return "impossible<bad format char>";
  1125.     
  1126.     }
  1127.     
  1128.     *p_format = format;
  1129.     return NULL;
  1130. }
  1131.