Modules/cgensupport.c

   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 /* Functions used by cgen output */
  33
  34 #include "Python.h"
  35 #include "cgensupport.h"
  36
  37
  38 /* Functions to extract arguments.
  39    These needs to know the total number of arguments supplied,
  40    since the argument list is a tuple only of there is more than
  41    one argument. */
  42
  43 int
  44 PyArg_GetObject(args, nargs, i, p_arg)
  45         register PyObject *args;
  46         int nargs, i;
  47         PyObject **p_arg;
  48 {
  49         if (nargs != 1) {
  50                 if (args == NULL || !PyTuple_Check(args) ||
  51                                 nargs != PyTuple_Size(args) ||
  52                                 i < 0 || i >= nargs) {
  53                         return PyErr_BadArgument();
  54                 }
  55                 else {
  56                         args = PyTuple_GetItem(args, i);
  57                 }
  58         }
  59         if (args == NULL) {
  60                 return PyErr_BadArgument();
  61         }
  62         *p_arg = args;
  63         return 1;
  64 }
  65
  66 int
  67 PyArg_GetLong(args, nargs, i, p_arg)
  68         register PyObject *args;
  69         int nargs, i;
  70         long *p_arg;
  71 {
  72         if (nargs != 1) {
  73                 if (args == NULL || !PyTuple_Check(args) ||
  74                                 nargs != PyTuple_Size(args) ||
  75                                 i < 0 || i >= nargs) {
  76                         return PyErr_BadArgument();
  77                 }
  78                 args = PyTuple_GetItem(args, i);
  79         }
  80         if (args == NULL || !PyInt_Check(args)) {
  81                 return PyErr_BadArgument();
  82         }
  83         *p_arg = PyInt_AsLong(args);
  84         return 1;
  85 }
  86
  87 int
  88 PyArg_GetShort(args, nargs, i, p_arg)
  89         register PyObject *args;
  90         int nargs, i;
  91         short *p_arg;
  92 {
  93         long x;
  94         if (!PyArg_GetLong(args, nargs, i, &x))
  95                 return 0;
  96         *p_arg = (short) x;
  97         return 1;
  98 }
  99
 100 static int
 101 extractdouble(v, p_arg)
 102         register PyObject *v;
 103         double *p_arg;
 104 {
 105         if (v == NULL) {
 106                 /* Fall through to error return at end of function */
 107         }
 108         else if (PyFloat_Check(v)) {
 109                 *p_arg = PyFloat_AS_DOUBLE((PyFloatObject *)v);
 110                 return 1;
 111         }
 112         else if (PyInt_Check(v)) {
 113                 *p_arg = PyInt_AS_LONG((PyIntObject *)v);
 114                 return 1;
 115         }
 116         else if (PyLong_Check(v)) {
 117                 *p_arg = PyLong_AsDouble(v);
 118                 return 1;
 119         }
 120         return PyErr_BadArgument();
 121 }
 122
 123 static int
 124 extractfloat(v, p_arg)
 125         register PyObject *v;
 126         float *p_arg;
 127 {
 128         if (v == NULL) {
 129                 /* Fall through to error return at end of function */
 130         }
 131         else if (PyFloat_Check(v)) {
 132                 *p_arg = (float) PyFloat_AS_DOUBLE((PyFloatObject *)v);
 133                 return 1;
 134         }
 135         else if (PyInt_Check(v)) {
 136                 *p_arg = (float) PyInt_AS_LONG((PyIntObject *)v);
 137                 return 1;
 138         }
 139         else if (PyLong_Check(v)) {
 140                 *p_arg = (float) PyLong_AsDouble(v);
 141                 return 1;
 142         }
 143         return PyErr_BadArgument();
 144 }
 145
 146 int
 147 PyArg_GetFloat(args, nargs, i, p_arg)
 148         register PyObject *args;
 149         int nargs, i;
 150         float *p_arg;
 151 {
 152         PyObject *v;
 153         float x;
 154         if (!PyArg_GetObject(args, nargs, i, &v))
 155                 return 0;
 156         if (!extractfloat(v, &x))
 157                 return 0;
 158         *p_arg = x;
 159         return 1;
 160 }
 161
 162 int
 163 PyArg_GetString(args, nargs, i, p_arg)
 164         PyObject *args;
 165         int nargs, i;
 166         string *p_arg;
 167 {
 168         PyObject *v;
 169         if (!PyArg_GetObject(args, nargs, i, &v))
 170                 return 0;
 171         if (!PyString_Check(v)) {
 172                 return PyErr_BadArgument();
 173         }
 174         *p_arg = PyString_AsString(v);
 175         return 1;
 176 }
 177
 178 int
 179 PyArg_GetChar(args, nargs, i, p_arg)
 180         PyObject *args;
 181         int nargs, i;
 182         char *p_arg;
 183 {
 184         string x;
 185         if (!PyArg_GetString(args, nargs, i, &x))
 186                 return 0;
 187         if (x[0] == '\0' || x[1] != '\0') {
 188                 /* Not exactly one char */
 189                 return PyErr_BadArgument();
 190         }
 191         *p_arg = x[0];
 192         return 1;
 193 }
 194
 195 int
 196 PyArg_GetLongArraySize(args, nargs, i, p_arg)
 197         PyObject *args;
 198         int nargs, i;
 199         long *p_arg;
 200 {
 201         PyObject *v;
 202         if (!PyArg_GetObject(args, nargs, i, &v))
 203                 return 0;
 204         if (PyTuple_Check(v)) {
 205                 *p_arg = PyTuple_Size(v);
 206                 return 1;
 207         }
 208         if (PyList_Check(v)) {
 209                 *p_arg = PyList_Size(v);
 210                 return 1;
 211         }
 212         return PyErr_BadArgument();
 213 }
 214
 215 int
 216 PyArg_GetShortArraySize(args, nargs, i, p_arg)
 217         PyObject *args;
 218         int nargs, i;
 219         short *p_arg;
 220 {
 221         long x;
 222         if (!PyArg_GetLongArraySize(args, nargs, i, &x))
 223                 return 0;
 224         *p_arg = (short) x;
 225         return 1;
 226 }
 227
 228 /* XXX The following four are too similar.  Should share more code. */
 229
 230 int
 231 PyArg_GetLongArray(args, nargs, i, n, p_arg)
 232         PyObject *args;
 233         int nargs, i;
 234         int n;
 235         long *p_arg; /* [n] */
 236 {
 237         PyObject *v, *w;
 238         if (!PyArg_GetObject(args, nargs, i, &v))
 239                 return 0;
 240         if (PyTuple_Check(v)) {
 241                 if (PyTuple_Size(v) != n) {
 242                         return PyErr_BadArgument();
 243                 }
 244                 for (i = 0; i < n; i++) {
 245                         w = PyTuple_GetItem(v, i);
 246                         if (!PyInt_Check(w)) {
 247                                 return PyErr_BadArgument();
 248                         }
 249                         p_arg[i] = PyInt_AsLong(w);
 250                 }
 251                 return 1;
 252         }
 253         else if (PyList_Check(v)) {
 254                 if (PyList_Size(v) != n) {
 255                         return PyErr_BadArgument();
 256                 }
 257                 for (i = 0; i < n; i++) {
 258                         w = PyList_GetItem(v, i);
 259                         if (!PyInt_Check(w)) {
 260                                 return PyErr_BadArgument();
 261                         }
 262                         p_arg[i] = PyInt_AsLong(w);
 263                 }
 264                 return 1;
 265         }
 266         else {
 267                 return PyErr_BadArgument();
 268         }
 269 }
 270
 271 int
 272 PyArg_GetShortArray(args, nargs, i, n, p_arg)
 273         PyObject *args;
 274         int nargs, i;
 275         int n;
 276         short *p_arg; /* [n] */
 277 {
 278         PyObject *v, *w;
 279         if (!PyArg_GetObject(args, nargs, i, &v))
 280                 return 0;
 281         if (PyTuple_Check(v)) {
 282                 if (PyTuple_Size(v) != n) {
 283                         return PyErr_BadArgument();
 284                 }
 285                 for (i = 0; i < n; i++) {
 286                         w = PyTuple_GetItem(v, i);
 287                         if (!PyInt_Check(w)) {
 288                                 return PyErr_BadArgument();
 289                         }
 290                         p_arg[i] = (short) PyInt_AsLong(w);
 291                 }
 292                 return 1;
 293         }
 294         else if (PyList_Check(v)) {
 295                 if (PyList_Size(v) != n) {
 296                         return PyErr_BadArgument();
 297                 }
 298                 for (i = 0; i < n; i++) {
 299                         w = PyList_GetItem(v, i);
 300                         if (!PyInt_Check(w)) {
 301                                 return PyErr_BadArgument();
 302                         }
 303                         p_arg[i] = (short) PyInt_AsLong(w);
 304                 }
 305                 return 1;
 306         }
 307         else {
 308                 return PyErr_BadArgument();
 309         }
 310 }
 311
 312 int
 313 PyArg_GetDoubleArray(args, nargs, i, n, p_arg)
 314         PyObject *args;
 315         int nargs, i;
 316         int n;
 317         double *p_arg; /* [n] */
 318 {
 319         PyObject *v, *w;
 320         if (!PyArg_GetObject(args, nargs, i, &v))
 321                 return 0;
 322         if (PyTuple_Check(v)) {
 323                 if (PyTuple_Size(v) != n) {
 324                         return PyErr_BadArgument();
 325                 }
 326                 for (i = 0; i < n; i++) {
 327                         w = PyTuple_GetItem(v, i);
 328                         if (!extractdouble(w, &p_arg[i]))
 329                                 return 0;
 330                 }
 331                 return 1;
 332         }
 333         else if (PyList_Check(v)) {
 334                 if (PyList_Size(v) != n) {
 335                         return PyErr_BadArgument();
 336                 }
 337                 for (i = 0; i < n; i++) {
 338                         w = PyList_GetItem(v, i);
 339                         if (!extractdouble(w, &p_arg[i]))
 340                                 return 0;
 341                 }
 342                 return 1;
 343         }
 344         else {
 345                 return PyErr_BadArgument();
 346         }
 347 }
 348
 349 int
 350 PyArg_GetFloatArray(args, nargs, i, n, p_arg)
 351         PyObject *args;
 352         int nargs, i;
 353         int n;
 354         float *p_arg; /* [n] */
 355 {
 356         PyObject *v, *w;
 357         if (!PyArg_GetObject(args, nargs, i, &v))
 358                 return 0;
 359         if (PyTuple_Check(v)) {
 360                 if (PyTuple_Size(v) != n) {
 361                         return PyErr_BadArgument();
 362                 }
 363                 for (i = 0; i < n; i++) {
 364                         w = PyTuple_GetItem(v, i);
 365                         if (!extractfloat(w, &p_arg[i]))
 366                                 return 0;
 367                 }
 368                 return 1;
 369         }
 370         else if (PyList_Check(v)) {
 371                 if (PyList_Size(v) != n) {
 372                         return PyErr_BadArgument();
 373                 }
 374                 for (i = 0; i < n; i++) {
 375                         w = PyList_GetItem(v, i);
 376                         if (!extractfloat(w, &p_arg[i]))
 377                                 return 0;
 378                 }
 379                 return 1;
 380         }
 381         else {
 382                 return PyErr_BadArgument();
 383         }
 384 }