* Python/{modsupport.c,getargs.c,Makefile.in},
Include/modsupport.h: moved getargs() to its own file and
re-implemented it entirely to support optional arguments, multiple
arguments without surrounding parentheses
(when called as newgetargs()), and better error messages
diff --git a/Python/getargs.c b/Python/getargs.c
new file mode 100644
index 0000000..605cb01
--- /dev/null
+++ b/Python/getargs.c
@@ -0,0 +1,587 @@
+/***********************************************************
+Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
+Amsterdam, The Netherlands.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* New getargs implementation */
+
+/* XXX There are several unchecked sprintf or strcat calls in this file.
+ XXX The only way these can become a danger is if some C code in the
+ XXX Python source (or in an extension) uses ridiculously long names
+ XXX or riduculously deep nesting in format strings. */
+
+#include "allobjects.h"
+
+
+int getargs PROTO((object *, char *, ...));
+int newgetargs PROTO((object *, char *, ...));
+int vgetargs PROTO((object *, char *, va_list));
+
+
+/* Forward */
+static int vgetargs1 PROTO((object *, char *, va_list, int));
+static void seterror PROTO((int, char *, int *, char *, char *));
+static char *convertitem PROTO((object *, char **, va_list *, int *, char *));
+static char *converttuple PROTO((object *, char **, va_list *,
+ int *, char *, int));
+static char *convertsimple PROTO((object *, char **, va_list *, char *));
+static char *convertsimple1 PROTO((object *, char **, va_list *));
+
+
+#ifdef HAVE_STDARG_PROTOTYPES
+/* VARARGS2 */
+int getargs(object *args, char *format, ...)
+#else
+/* VARARGS */
+int getargs(va_alist) va_dcl
+#endif
+{
+ int retval;
+ va_list va;
+#ifdef HAVE_STDARG_PROTOTYPES
+
+ va_start(va, format);
+#else
+ object *args;
+ char *format;
+
+ va_start(va);
+ args = va_arg(va, object *);
+ format = va_arg(va, char *);
+#endif
+ retval = vgetargs1(args, format, va, 1);
+ va_end(va);
+ return retval;
+}
+
+
+#ifdef HAVE_STDARG_PROTOTYPES
+/* VARARGS2 */
+int newgetargs(object *args, char *format, ...)
+#else
+/* VARARGS */
+int newgetargs(va_alist) va_dcl
+#endif
+{
+ int retval;
+ va_list va;
+#ifdef HAVE_STDARG_PROTOTYPES
+
+ va_start(va, format);
+#else
+ object *args;
+ char *format;
+
+ va_start(va);
+ args = va_arg(va, object *);
+ format = va_arg(va, char *);
+#endif
+ retval = vgetargs1(args, format, va, 0);
+ va_end(va);
+ return retval;
+}
+
+
+int
+vgetargs(args, format, va)
+ object *args;
+ char *format;
+ va_list va;
+{
+ return vgetargs1(args, format, va, 0);
+}
+
+
+static int
+vgetargs1(args, format, va, compat)
+ object *args;
+ char *format;
+ va_list va;
+ int compat;
+{
+ char msgbuf[256];
+ int levels[32];
+ char *fname = NULL;
+ char *message = NULL;
+ int min = -1;
+ int max = 0;
+ int level = 0;
+ char *formatsave = format;
+ int i, len;
+ char *msg;
+
+ for (;;) {
+ int c = *format++;
+ if (c == '(' /* ')' */) {
+ if (level == 0)
+ max++;
+ level++;
+ }
+ else if (/* '(' */ c == ')') {
+ if (level == 0)
+ fatal(/* '(' */
+ "excess ')' in getargs format");
+ else
+ level--;
+ }
+ else if (c == '\0')
+ break;
+ else if (c == ':') {
+ fname = format;
+ break;
+ }
+ else if (c == ';') {
+ message = format;
+ break;
+ }
+ else if (level != 0)
+ ; /* Pass */
+ else if (isalpha(c))
+ max++;
+ else if (c == '|')
+ min = max;
+ }
+
+ if (level != 0)
+ fatal(/* '(' */ "missing ')' in getargs format");
+
+ if (min < 0)
+ min = max;
+
+ format = formatsave;
+
+ if (compat) {
+ if (max == 0) {
+ if (args == NULL)
+ return 1;
+ sprintf(msgbuf, "%s requires no arguments",
+ fname==NULL ? "function" : fname);
+ err_setstr(TypeError, msgbuf);
+ return 0;
+ }
+ else if (min == 1 && max == 1) {
+ msg = convertitem(args, &format, &va, levels, msgbuf);
+ if (msg == NULL)
+ return 1;
+ seterror(levels[0], msg, levels+1, fname, message);
+ return 0;
+ }
+ else {
+ err_setstr(SystemError,
+ "old style getargs format uses new features");
+ return 0;
+ }
+ }
+
+ if (!is_tupleobject(args)) {
+ err_setstr(SystemError,
+ "new style getargs format but argument is not a tuple");
+ return 0;
+ }
+
+ len = gettuplesize(args);
+
+ if (len < min || max < len) {
+ if (message == NULL) {
+ sprintf(msgbuf,
+ "%s requires %s %d argument%s; %d given",
+ fname==NULL ? "function" : fname,
+ min==max ? "exactly"
+ : len < min ? "at least" : "at most",
+ len < min ? min : max,
+ (len < min ? min : max) == 1 ? "" : "s",
+ len);
+ message = msgbuf;
+ }
+ err_setstr(TypeError, message);
+ return 0;
+ }
+
+ for (i = 0; i < len; i++) {
+ if (*format == '|')
+ format++;
+ msg = convertitem(gettupleitem(args, i), &format, &va,
+ levels, msgbuf);
+ if (msg) {
+ seterror(i+1, msg, levels, fname, message);
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+
+
+static void
+seterror(iarg, msg, levels, fname, message)
+ int iarg;
+ char *msg;
+ int *levels;
+ char *fname;
+ char *message;
+{
+ char buf[256];
+ int i;
+ char *p = buf;
+
+ if (iarg == 0 && message == NULL)
+ message = msg;
+ else if (message == NULL) {
+ if (fname != NULL) {
+ sprintf(p, "%s, ", fname);
+ p += strlen(p);
+ }
+ sprintf(p, "argument %d", iarg);
+ i = 0;
+ p += strlen(p);
+ while (levels[i] > 0) {
+ sprintf(p, ", item %d", levels[i]-1);
+ p += strlen(p);
+ i++;
+ }
+ sprintf(p, ": expected %s found", msg);
+ message = buf;
+ }
+ err_setstr(TypeError, message);
+}
+
+
+/* Convert a tuple argument.
+ On entry, *p_format points to the character _after_ the opening '('.
+ On successful exit, *p_format points to the closing ')'.
+ If successful:
+ *p_format and *p_va are updated,
+ *levels and *msgbuf are untouched,
+ and NULL is returned.
+ If the argument is invalid:
+ *p_format is unchanged,
+ *p_va is undefined,
+ *levels is a 0-terminated list of item numbers,
+ *msgbuf contains an error message, whose format is:
+ "<typename1>, <typename2>", where:
+ <typename1> is the name of the expected type, and
+ <typename2> is the name of the actual type,
+ (so you can surround it by "expected ... found"),
+ and msgbuf is returned.
+*/
+
+static char *
+converttuple(arg, p_format, p_va, levels, msgbuf, toplevel)
+ object *arg;
+ char **p_format;
+ va_list *p_va;
+ int *levels;
+ char *msgbuf;
+ int toplevel;
+{
+ int level = 0;
+ int n = 0;
+ char *format = *p_format;
+ int i;
+
+ for (;;) {
+ int c = *format++;
+ if (c == '(') {
+ if (level == 0)
+ n++;
+ level++;
+ }
+ else if (c == ')') {
+ if (level == 0)
+ break;
+ level--;
+ }
+ else if (c == ':' || c == ';' || c == '\0')
+ break;
+ else if (level == 0 && isalpha(c))
+ n++;
+ }
+
+ if (!is_tupleobject(arg)) {
+ levels[0] = 0;
+ sprintf(msgbuf,
+ toplevel ? "%d arguments, %s" : "%d-tuple, %s",
+ n, arg == None ? "None" : arg->ob_type->tp_name);
+ return msgbuf;
+ }
+
+ if ((i = gettuplesize(arg)) != n) {
+ levels[0] = 0;
+ sprintf(msgbuf,
+ toplevel ? "%d arguments, %d" : "%d-tuple, %d-tuple",
+ n, i);
+ return msgbuf;
+ }
+
+ format = *p_format;
+ for (i = 0; i < n; i++) {
+ char *msg;
+ msg = convertitem(gettupleitem(arg, i), &format, p_va,
+ levels+1, msgbuf);
+ if (msg != NULL) {
+ levels[0] = i+1;
+ return msg;
+ }
+ }
+
+ *p_format = format;
+ return NULL;
+}
+
+
+/* Convert a single item. */
+
+static char *
+convertitem(arg, p_format, p_va, levels, msgbuf)
+ object *arg;
+ char **p_format;
+ va_list *p_va;
+ int *levels;
+ char *msgbuf;
+{
+ char *msg;
+ char *format = *p_format;
+
+ if (*format == '(' /* ')' */) {
+ format++;
+ msg = converttuple(arg, &format, p_va, levels, msgbuf, 0);
+ if (msg == NULL)
+ format++;
+ }
+ else {
+ msg = convertsimple(arg, &format, p_va, msgbuf);
+ if (msg != NULL)
+ levels[0] = 0;
+ }
+ if (msg == NULL)
+ *p_format = format;
+ return msg;
+}
+
+
+/* Convert a non-tuple argument. Adds to convertsimple1 functionality
+ by appending ", <actual argument type>" to error message. */
+
+static char *
+convertsimple(arg, p_format, p_va, msgbuf)
+ object *arg;
+ char **p_format;
+ va_list *p_va;
+ char *msgbuf;
+{
+ char *msg = convertsimple1(arg, p_format, p_va);
+ if (msg != NULL) {
+ sprintf(msgbuf, "%.50s, %.50s", msg,
+ arg == None ? "None" : arg->ob_type->tp_name);
+ msg = msgbuf;
+ }
+ return msg;
+}
+
+
+/* Convert a non-tuple argument. Return NULL if conversion went OK,
+ or a string representing the expected type if the conversion failed.
+ When failing, an exception may or may not have been raised.
+ Don't call if a tuple is expected. */
+
+static char *
+convertsimple1(arg, p_format, p_va)
+ object *arg;
+ char **p_format;
+ va_list *p_va;
+{
+ char *format = *p_format;
+ char c = *format++;
+
+ switch (c) {
+
+ case 'b': /* byte -- very short int */
+ {
+ char *p = va_arg(*p_va, char *);
+ long ival = getintvalue(arg);
+ if (ival == -1 && err_occurred())
+ return "integer<b>";
+ else
+ *p = ival;
+ break;
+ }
+
+ case 'h': /* short int */
+ {
+ short *p = va_arg(*p_va, short *);
+ long ival = getintvalue(arg);
+ if (ival == -1 && err_occurred())
+ return "integer<h>";
+ else
+ *p = ival;
+ break;
+ }
+
+ case 'i': /* int */
+ {
+ int *p = va_arg(*p_va, int *);
+ long ival = getintvalue(arg);
+ if (ival == -1 && err_occurred())
+ return "integer<i>";
+ else
+ *p = ival;
+ break;
+ }
+
+ case 'l': /* long int */
+ {
+ long *p = va_arg(*p_va, long *);
+ long ival = getintvalue(arg);
+ if (ival == -1 && err_occurred())
+ return "integer<l>";
+ else
+ *p = ival;
+ break;
+ }
+
+ case 'f': /* float */
+ {
+ float *p = va_arg(*p_va, float *);
+ double dval = getfloatvalue(arg);
+ if (err_occurred())
+ return "float<f>";
+ else
+ *p = dval;
+ break;
+ }
+
+ case 'd': /* double */
+ {
+ double *p = va_arg(*p_va, double *);
+ double dval = getfloatvalue(arg);
+ if (err_occurred())
+ return "float<d>";
+ else
+ *p = dval;
+ break;
+ }
+
+ case 'c': /* char */
+ {
+ char *p = va_arg(*p_va, char *);
+ if (is_stringobject(arg) && getstringsize(arg) == 1)
+ *p = getstringvalue(arg)[0];
+ else
+ return "char";
+ break;
+ }
+
+ case 's': /* string */
+ {
+ char **p = va_arg(*p_va, char **);
+ if (is_stringobject(arg))
+ *p = getstringvalue(arg);
+ else
+ return "string";
+ if (*format == '#') {
+ int *q = va_arg(*p_va, int *);
+ *q = getstringsize(arg);
+ format++;
+ }
+ else if (strlen(*p) != getstringsize(arg))
+ return "string without null bytes";
+ break;
+ }
+
+ case 'z': /* string, may be NULL (None) */
+ {
+ char **p = va_arg(*p_va, char **);
+ if (arg == None)
+ *p = 0;
+ else if (is_stringobject(arg))
+ *p = getstringvalue(arg);
+ else
+ return "None or string";
+ if (*format == '#') {
+ int *q = va_arg(*p_va, int *);
+ if (arg == None)
+ *q = 0;
+ else
+ *q = getstringsize(arg);
+ format++;
+ }
+ else if (*p != NULL && strlen(*p) != getstringsize(arg))
+ return "None or string without null bytes";
+ break;
+ }
+
+ case 'S': /* string object */
+ {
+ object **p = va_arg(*p_va, object **);
+ if (is_stringobject(arg))
+ *p = arg;
+ else
+ return "string";
+ break;
+ }
+
+ case 'O': /* object */
+ {
+ typeobject *type;
+ object **p;
+ if (*format == '!') {
+ format++;
+ type = va_arg(*p_va, typeobject*);
+ if (arg->ob_type != type)
+ return type->tp_name;
+ else {
+ p = va_arg(*p_va, object **);
+ *p = arg;
+ }
+ }
+ else if (*format == '?') {
+ inquiry pred = va_arg(*p_va, inquiry);
+ format++;
+ if ((*pred)(arg)) {
+ p = va_arg(*p_va, object **);
+ *p = arg;
+ }
+ }
+ else if (*format == '&') {
+ typedef int (*converter) PROTO((object *, void *));
+ converter convert = va_arg(*p_va, converter);
+ void *addr = va_arg(*p_va, void *);
+ format++;
+ if (! (*convert)(arg, addr))
+ return "";
+ }
+ else {
+ p = va_arg(*p_va, object **);
+ *p = arg;
+ }
+ break;
+ }
+
+ default:
+ return "impossible<bad format char>";
+
+ }
+
+ *p_format = format;
+ return NULL;
+}