Modules/cgensupport.c

   1 /***********************************************************
   2 Copyright (c) 2000, BeOpen.com.
   3 Copyright (c) 1995-2000, Corporation for National Research Initiatives.
   4 Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
   5 All rights reserved.
   6
   7 See the file "Misc/COPYRIGHT" for information on usage and
   8 redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
   9 ******************************************************************/
  10
  11 /* Functions used by cgen output */
  12
  13 #include "Python.h"
  14 #include "cgensupport.h"
  15
  16
  17 /* Functions to extract arguments.
  18    These needs to know the total number of arguments supplied,
  19    since the argument list is a tuple only of there is more than
  20    one argument. */
  21
  22 int
  23 PyArg_GetObject(register PyObject *args, int nargs, int i, PyObject **p_arg)
  24 {
  25         if (nargs != 1) {
  26                 if (args == NULL || !PyTuple_Check(args) ||
  27                                 nargs != PyTuple_Size(args) ||
  28                                 i < 0 || i >= nargs) {
  29                         return PyErr_BadArgument();
  30                 }
  31                 else {
  32                         args = PyTuple_GetItem(args, i);
  33                 }
  34         }
  35         if (args == NULL) {
  36                 return PyErr_BadArgument();
  37         }
  38         *p_arg = args;
  39         return 1;
  40 }
  41
  42 int
  43 PyArg_GetLong(register PyObject *args, int nargs, int i, long *p_arg)
  44 {
  45         if (nargs != 1) {
  46                 if (args == NULL || !PyTuple_Check(args) ||
  47                                 nargs != PyTuple_Size(args) ||
  48                                 i < 0 || i >= nargs) {
  49                         return PyErr_BadArgument();
  50                 }
  51                 args = PyTuple_GetItem(args, i);
  52         }
  53         if (args == NULL || !PyInt_Check(args)) {
  54                 return PyErr_BadArgument();
  55         }
  56         *p_arg = PyInt_AsLong(args);
  57         return 1;
  58 }
  59
  60 int
  61 PyArg_GetShort(register PyObject *args, int nargs, int i, short *p_arg)
  62 {
  63         long x;
  64         if (!PyArg_GetLong(args, nargs, i, &x))
  65                 return 0;
  66         *p_arg = (short) x;
  67         return 1;
  68 }
  69
  70 static int
  71 extractdouble(register PyObject *v, double *p_arg)
  72 {
  73         if (v == NULL) {
  74                 /* Fall through to error return at end of function */
  75         }
  76         else if (PyFloat_Check(v)) {
  77                 *p_arg = PyFloat_AS_DOUBLE((PyFloatObject *)v);
  78                 return 1;
  79         }
  80         else if (PyInt_Check(v)) {
  81                 *p_arg = PyInt_AS_LONG((PyIntObject *)v);
  82                 return 1;
  83         }
  84         else if (PyLong_Check(v)) {
  85                 *p_arg = PyLong_AsDouble(v);
  86                 return 1;
  87         }
  88         return PyErr_BadArgument();
  89 }
  90
  91 static int
  92 extractfloat(register PyObject *v, float *p_arg)
  93 {
  94         if (v == NULL) {
  95                 /* Fall through to error return at end of function */
  96         }
  97         else if (PyFloat_Check(v)) {
  98                 *p_arg = (float) PyFloat_AS_DOUBLE((PyFloatObject *)v);
  99                 return 1;
 100         }
 101         else if (PyInt_Check(v)) {
 102                 *p_arg = (float) PyInt_AS_LONG((PyIntObject *)v);
 103                 return 1;
 104         }
 105         else if (PyLong_Check(v)) {
 106                 *p_arg = (float) PyLong_AsDouble(v);
 107                 return 1;
 108         }
 109         return PyErr_BadArgument();
 110 }
 111
 112 int
 113 PyArg_GetFloat(register PyObject *args, int nargs, int i, float *p_arg)
 114 {
 115         PyObject *v;
 116         float x;
 117         if (!PyArg_GetObject(args, nargs, i, &v))
 118                 return 0;
 119         if (!extractfloat(v, &x))
 120                 return 0;
 121         *p_arg = x;
 122         return 1;
 123 }
 124
 125 int
 126 PyArg_GetString(PyObject *args, int nargs, int i, string *p_arg)
 127 {
 128         PyObject *v;
 129         if (!PyArg_GetObject(args, nargs, i, &v))
 130                 return 0;
 131         if (!PyString_Check(v)) {
 132                 return PyErr_BadArgument();
 133         }
 134         *p_arg = PyString_AsString(v);
 135         return 1;
 136 }
 137
 138 int
 139 PyArg_GetChar(PyObject *args, int nargs, int i, char *p_arg)
 140 {
 141         string x;
 142         if (!PyArg_GetString(args, nargs, i, &x))
 143                 return 0;
 144         if (x[0] == '\0' || x[1] != '\0') {
 145                 /* Not exactly one char */
 146                 return PyErr_BadArgument();
 147         }
 148         *p_arg = x[0];
 149         return 1;
 150 }
 151
 152 int
 153 PyArg_GetLongArraySize(PyObject *args, int nargs, int i, long *p_arg)
 154 {
 155         PyObject *v;
 156         if (!PyArg_GetObject(args, nargs, i, &v))
 157                 return 0;
 158         if (PyTuple_Check(v)) {
 159                 *p_arg = PyTuple_Size(v);
 160                 return 1;
 161         }
 162         if (PyList_Check(v)) {
 163                 *p_arg = PyList_Size(v);
 164                 return 1;
 165         }
 166         return PyErr_BadArgument();
 167 }
 168
 169 int
 170 PyArg_GetShortArraySize(PyObject *args, int nargs, int i, short *p_arg)
 171 {
 172         long x;
 173         if (!PyArg_GetLongArraySize(args, nargs, i, &x))
 174                 return 0;
 175         *p_arg = (short) x;
 176         return 1;
 177 }
 178
 179 /* XXX The following four are too similar.  Should share more code. */
 180
 181 int
 182 PyArg_GetLongArray(PyObject *args, int nargs, int i, int n, long *p_arg)
 183 {
 184         PyObject *v, *w;
 185         if (!PyArg_GetObject(args, nargs, i, &v))
 186                 return 0;
 187         if (PyTuple_Check(v)) {
 188                 if (PyTuple_Size(v) != n) {
 189                         return PyErr_BadArgument();
 190                 }
 191                 for (i = 0; i < n; i++) {
 192                         w = PyTuple_GetItem(v, i);
 193                         if (!PyInt_Check(w)) {
 194                                 return PyErr_BadArgument();
 195                         }
 196                         p_arg[i] = PyInt_AsLong(w);
 197                 }
 198                 return 1;
 199         }
 200         else if (PyList_Check(v)) {
 201                 if (PyList_Size(v) != n) {
 202                         return PyErr_BadArgument();
 203                 }
 204                 for (i = 0; i < n; i++) {
 205                         w = PyList_GetItem(v, i);
 206                         if (!PyInt_Check(w)) {
 207                                 return PyErr_BadArgument();
 208                         }
 209                         p_arg[i] = PyInt_AsLong(w);
 210                 }
 211                 return 1;
 212         }
 213         else {
 214                 return PyErr_BadArgument();
 215         }
 216 }
 217
 218 int
 219 PyArg_GetShortArray(PyObject *args, int nargs, int i, int n, short *p_arg)
 220 {
 221         PyObject *v, *w;
 222         if (!PyArg_GetObject(args, nargs, i, &v))
 223                 return 0;
 224         if (PyTuple_Check(v)) {
 225                 if (PyTuple_Size(v) != n) {
 226                         return PyErr_BadArgument();
 227                 }
 228                 for (i = 0; i < n; i++) {
 229                         w = PyTuple_GetItem(v, i);
 230                         if (!PyInt_Check(w)) {
 231                                 return PyErr_BadArgument();
 232                         }
 233                         p_arg[i] = (short) PyInt_AsLong(w);
 234                 }
 235                 return 1;
 236         }
 237         else if (PyList_Check(v)) {
 238                 if (PyList_Size(v) != n) {
 239                         return PyErr_BadArgument();
 240                 }
 241                 for (i = 0; i < n; i++) {
 242                         w = PyList_GetItem(v, i);
 243                         if (!PyInt_Check(w)) {
 244                                 return PyErr_BadArgument();
 245                         }
 246                         p_arg[i] = (short) PyInt_AsLong(w);
 247                 }
 248                 return 1;
 249         }
 250         else {
 251                 return PyErr_BadArgument();
 252         }
 253 }
 254
 255 int
 256 PyArg_GetDoubleArray(PyObject *args, int nargs, int i, int n, double *p_arg)
 257 {
 258         PyObject *v, *w;
 259         if (!PyArg_GetObject(args, nargs, i, &v))
 260                 return 0;
 261         if (PyTuple_Check(v)) {
 262                 if (PyTuple_Size(v) != n) {
 263                         return PyErr_BadArgument();
 264                 }
 265                 for (i = 0; i < n; i++) {
 266                         w = PyTuple_GetItem(v, i);
 267                         if (!extractdouble(w, &p_arg[i]))
 268                                 return 0;
 269                 }
 270                 return 1;
 271         }
 272         else if (PyList_Check(v)) {
 273                 if (PyList_Size(v) != n) {
 274                         return PyErr_BadArgument();
 275                 }
 276                 for (i = 0; i < n; i++) {
 277                         w = PyList_GetItem(v, i);
 278                         if (!extractdouble(w, &p_arg[i]))
 279                                 return 0;
 280                 }
 281                 return 1;
 282         }
 283         else {
 284                 return PyErr_BadArgument();
 285         }
 286 }
 287
 288 int
 289 PyArg_GetFloatArray(PyObject *args, int nargs, int i, int n, float *p_arg)
 290 {
 291         PyObject *v, *w;
 292         if (!PyArg_GetObject(args, nargs, i, &v))
 293                 return 0;
 294         if (PyTuple_Check(v)) {
 295                 if (PyTuple_Size(v) != n) {
 296                         return PyErr_BadArgument();
 297                 }
 298                 for (i = 0; i < n; i++) {
 299                         w = PyTuple_GetItem(v, i);
 300                         if (!extractfloat(w, &p_arg[i]))
 301                                 return 0;
 302                 }
 303                 return 1;
 304         }
 305         else if (PyList_Check(v)) {
 306                 if (PyList_Size(v) != n) {
 307                         return PyErr_BadArgument();
 308                 }
 309                 for (i = 0; i < n; i++) {
 310                         w = PyList_GetItem(v, i);
 311                         if (!extractfloat(w, &p_arg[i]))
 312                                 return 0;
 313                 }
 314                 return 1;
 315         }
 316         else {
 317                 return PyErr_BadArgument();
 318         }
 319 }