1 

     2 /* Functions used by cgen output */

     3 

     4 #include "Python.h"

     5 #include "cgensupport.h"

     6 

     7 

     8 /* Functions to extract arguments.

     9    These needs to know the total number of arguments supplied,

    10    since the argument list is a tuple only of there is more than

    11    one argument. */

    12 

    13 int

    14 PyArg_GetObject(register PyObject *args, int nargs, int i, PyObject **p_arg)

    15 {

    16 	if (nargs != 1) {

    17 		if (args == NULL || !PyTuple_Check(args) ||

    18 				nargs != PyTuple_Size(args) ||

    19 				i < 0 || i >= nargs) {

    20 			return PyErr_BadArgument();

    21 		}

    22 		else {

    23 			args = PyTuple_GetItem(args, i);

    24 		}

    25 	}

    26 	if (args == NULL) {

    27 		return PyErr_BadArgument();

    28 	}

    29 	*p_arg = args;

    30 	return 1;

    31 }

    32 

    33 int

    34 PyArg_GetLong(register PyObject *args, int nargs, int i, long *p_arg)

    35 {

    36 	if (nargs != 1) {

    37 		if (args == NULL || !PyTuple_Check(args) ||

    38 				nargs != PyTuple_Size(args) ||

    39 				i < 0 || i >= nargs) {

    40 			return PyErr_BadArgument();

    41 		}

    42 		args = PyTuple_GetItem(args, i);

    43 	}

    44 	if (args == NULL || !PyInt_Check(args)) {

    45 		return PyErr_BadArgument();

    46 	}

    47 	*p_arg = PyInt_AsLong(args);

    48 	return 1;

    49 }

    50 

    51 int

    52 PyArg_GetShort(register PyObject *args, int nargs, int i, short *p_arg)

    53 {

    54 	long x;

    55 	if (!PyArg_GetLong(args, nargs, i, &x))

    56 		return 0;

    57 	*p_arg = (short) x;

    58 	return 1;

    59 }

    60 

    61 static int

    62 extractdouble(register PyObject *v, double *p_arg)

    63 {

    64 	if (v == NULL) {

    65 		/* Fall through to error return at end of function */

    66 	}

    67 	else if (PyFloat_Check(v)) {

    68 		*p_arg = PyFloat_AS_DOUBLE((PyFloatObject *)v);

    69 		return 1;

    70 	}

    71 	else if (PyInt_Check(v)) {

    72 		*p_arg = PyInt_AS_LONG((PyIntObject *)v);

    73 		return 1;

    74 	}

    75 	else if (PyLong_Check(v)) {

    76 		*p_arg = PyLong_AsDouble(v);

    77 		return 1;

    78 	}

    79 	return PyErr_BadArgument();

    80 }

    81 

    82 static int

    83 extractfloat(register PyObject *v, float *p_arg)

    84 {

    85 	if (v == NULL) {

    86 		/* Fall through to error return at end of function */

    87 	}

    88 	else if (PyFloat_Check(v)) {

    89 		*p_arg = (float) PyFloat_AS_DOUBLE((PyFloatObject *)v);

    90 		return 1;

    91 	}

    92 	else if (PyInt_Check(v)) {

    93 		*p_arg = (float) PyInt_AS_LONG((PyIntObject *)v);

    94 		return 1;

    95 	}

    96 	else if (PyLong_Check(v)) {

    97 		*p_arg = (float) PyLong_AsDouble(v);

    98 		return 1;

    99 	}

   100 	return PyErr_BadArgument();

   101 }

   102 

   103 int

   104 PyArg_GetFloat(register PyObject *args, int nargs, int i, float *p_arg)

   105 {

   106 	PyObject *v;

   107 	float x;

   108 	if (!PyArg_GetObject(args, nargs, i, &v))

   109 		return 0;

   110 	if (!extractfloat(v, &x))

   111 		return 0;

   112 	*p_arg = x;

   113 	return 1;

   114 }

   115 

   116 int

   117 PyArg_GetString(PyObject *args, int nargs, int i, string *p_arg)

   118 {

   119 	PyObject *v;

   120 	if (!PyArg_GetObject(args, nargs, i, &v))

   121 		return 0;

   122 	if (!PyString_Check(v)) {

   123 		return PyErr_BadArgument();

   124 	}

   125 	*p_arg = PyString_AsString(v);

   126 	return 1;

   127 }

   128 

   129 int

   130 PyArg_GetChar(PyObject *args, int nargs, int i, char *p_arg)

   131 {

   132 	string x;

   133 	if (!PyArg_GetString(args, nargs, i, &x))

   134 		return 0;

   135 	if (x[0] == '\0' || x[1] != '\0') {

   136 		/* Not exactly one char */

   137 		return PyErr_BadArgument();

   138 	}

   139 	*p_arg = x[0];

   140 	return 1;

   141 }

   142 

   143 int

   144 PyArg_GetLongArraySize(PyObject *args, int nargs, int i, long *p_arg)

   145 {

   146 	PyObject *v;

   147 	if (!PyArg_GetObject(args, nargs, i, &v))

   148 		return 0;

   149 	if (PyTuple_Check(v)) {

   150 		*p_arg = PyTuple_Size(v);

   151 		return 1;

   152 	}

   153 	if (PyList_Check(v)) {

   154 		*p_arg = PyList_Size(v);

   155 		return 1;

   156 	}

   157 	return PyErr_BadArgument();

   158 }

   159 

   160 int

   161 PyArg_GetShortArraySize(PyObject *args, int nargs, int i, short *p_arg)

   162 {

   163 	long x;

   164 	if (!PyArg_GetLongArraySize(args, nargs, i, &x))

   165 		return 0;

   166 	*p_arg = (short) x;

   167 	return 1;

   168 }

   169 

   170 /* XXX The following four are too similar.  Should share more code. */

   171 

   172 int

   173 PyArg_GetLongArray(PyObject *args, int nargs, int i, int n, long *p_arg)

   174 {

   175 	PyObject *v, *w;

   176 	if (!PyArg_GetObject(args, nargs, i, &v))

   177 		return 0;

   178 	if (PyTuple_Check(v)) {

   179 		if (PyTuple_Size(v) != n) {

   180 			return PyErr_BadArgument();

   181 		}

   182 		for (i = 0; i < n; i++) {

   183 			w = PyTuple_GetItem(v, i);

   184 			if (!PyInt_Check(w)) {

   185 				return PyErr_BadArgument();

   186 			}

   187 			p_arg[i] = PyInt_AsLong(w);

   188 		}

   189 		return 1;

   190 	}

   191 	else if (PyList_Check(v)) {

   192 		if (PyList_Size(v) != n) {

   193 			return PyErr_BadArgument();

   194 		}

   195 		for (i = 0; i < n; i++) {

   196 			w = PyList_GetItem(v, i);

   197 			if (!PyInt_Check(w)) {

   198 				return PyErr_BadArgument();

   199 			}

   200 			p_arg[i] = PyInt_AsLong(w);

   201 		}

   202 		return 1;

   203 	}

   204 	else {

   205 		return PyErr_BadArgument();

   206 	}

   207 }

   208 

   209 int

   210 PyArg_GetShortArray(PyObject *args, int nargs, int i, int n, short *p_arg)

   211 {

   212 	PyObject *v, *w;

   213 	if (!PyArg_GetObject(args, nargs, i, &v))

   214 		return 0;

   215 	if (PyTuple_Check(v)) {

   216 		if (PyTuple_Size(v) != n) {

   217 			return PyErr_BadArgument();

   218 		}

   219 		for (i = 0; i < n; i++) {

   220 			w = PyTuple_GetItem(v, i);

   221 			if (!PyInt_Check(w)) {

   222 				return PyErr_BadArgument();

   223 			}

   224 			p_arg[i] = (short) PyInt_AsLong(w);

   225 		}

   226 		return 1;

   227 	}

   228 	else if (PyList_Check(v)) {

   229 		if (PyList_Size(v) != n) {

   230 			return PyErr_BadArgument();

   231 		}

   232 		for (i = 0; i < n; i++) {

   233 			w = PyList_GetItem(v, i);

   234 			if (!PyInt_Check(w)) {

   235 				return PyErr_BadArgument();

   236 			}

   237 			p_arg[i] = (short) PyInt_AsLong(w);

   238 		}

   239 		return 1;

   240 	}

   241 	else {

   242 		return PyErr_BadArgument();

   243 	}

   244 }

   245 

   246 int

   247 PyArg_GetDoubleArray(PyObject *args, int nargs, int i, int n, double *p_arg)

   248 {

   249 	PyObject *v, *w;

   250 	if (!PyArg_GetObject(args, nargs, i, &v))

   251 		return 0;

   252 	if (PyTuple_Check(v)) {

   253 		if (PyTuple_Size(v) != n) {

   254 			return PyErr_BadArgument();

   255 		}

   256 		for (i = 0; i < n; i++) {

   257 			w = PyTuple_GetItem(v, i);

   258 			if (!extractdouble(w, &p_arg[i]))

   259 				return 0;

   260 		}

   261 		return 1;

   262 	}

   263 	else if (PyList_Check(v)) {

   264 		if (PyList_Size(v) != n) {

   265 			return PyErr_BadArgument();

   266 		}

   267 		for (i = 0; i < n; i++) {

   268 			w = PyList_GetItem(v, i);

   269 			if (!extractdouble(w, &p_arg[i]))

   270 				return 0;

   271 		}

   272 		return 1;

   273 	}

   274 	else {

   275 		return PyErr_BadArgument();

   276 	}

   277 }

   278 

   279 int

   280 PyArg_GetFloatArray(PyObject *args, int nargs, int i, int n, float *p_arg)

   281 {

   282 	PyObject *v, *w;

   283 	if (!PyArg_GetObject(args, nargs, i, &v))

   284 		return 0;

   285 	if (PyTuple_Check(v)) {

   286 		if (PyTuple_Size(v) != n) {

   287 			return PyErr_BadArgument();

   288 		}

   289 		for (i = 0; i < n; i++) {

   290 			w = PyTuple_GetItem(v, i);

   291 			if (!extractfloat(w, &p_arg[i]))

   292 				return 0;

   293 		}

   294 		return 1;

   295 	}

   296 	else if (PyList_Check(v)) {

   297 		if (PyList_Size(v) != n) {

   298 			return PyErr_BadArgument();

   299 		}

   300 		for (i = 0; i < n; i++) {

   301 			w = PyList_GetItem(v, i);

   302 			if (!extractfloat(w, &p_arg[i]))

   303 				return 0;

   304 		}

   305 		return 1;

   306 	}

   307 	else {

   308 		return PyErr_BadArgument();

   309 	}

   310 }