PageRenderTime 3ms CodeModel.GetById 18ms app.highlight 21ms RepoModel.GetById 0ms app.codeStats 0ms

/src/utils/python/python26/Python/modsupport.c

https://bitbucket.org/apexgames-ondemand/zombie-onslaught-source
C | 643 lines | 534 code | 64 blank | 45 comment | 126 complexity | 41e203c761fbb1a062e29947e8f09fdd MD5 | raw file
  1
  2/* Module support implementation */
  3
  4#include "Python.h"
  5
  6#define FLAG_SIZE_T 1
  7typedef double va_double;
  8
  9static PyObject *va_build_value(const char *, va_list, int);
 10
 11/* Package context -- the full module name for package imports */
 12char *_Py_PackageContext = NULL;
 13
 14/* Py_InitModule4() parameters:
 15   - name is the module name
 16   - methods is the list of top-level functions
 17   - doc is the documentation string
 18   - passthrough is passed as self to functions defined in the module
 19   - api_version is the value of PYTHON_API_VERSION at the time the
 20     module was compiled
 21
 22   Return value is a borrowed reference to the module object; or NULL
 23   if an error occurred (in Python 1.4 and before, errors were fatal).
 24   Errors may still leak memory.
 25*/
 26
 27static char api_version_warning[] =
 28"Python C API version mismatch for module %.100s:\
 29 This Python has API version %d, module %.100s has version %d.";
 30
 31PyObject *
 32Py_InitModule4(const char *name, PyMethodDef *methods, const char *doc,
 33	       PyObject *passthrough, int module_api_version)
 34{
 35	PyObject *m, *d, *v, *n;
 36	PyMethodDef *ml;
 37	if (!Py_IsInitialized())
 38	    Py_FatalError("Interpreter not initialized (version mismatch?)");
 39	if (module_api_version != PYTHON_API_VERSION) {
 40		char message[512];
 41		PyOS_snprintf(message, sizeof(message), 
 42			      api_version_warning, name, 
 43			      PYTHON_API_VERSION, name, 
 44			      module_api_version);
 45		if (PyErr_Warn(PyExc_RuntimeWarning, message)) 
 46			return NULL;
 47	}
 48	/* Make sure name is fully qualified.
 49
 50	   This is a bit of a hack: when the shared library is loaded,
 51	   the module name is "package.module", but the module calls
 52	   Py_InitModule*() with just "module" for the name.  The shared
 53	   library loader squirrels away the true name of the module in
 54	   _Py_PackageContext, and Py_InitModule*() will substitute this
 55	   (if the name actually matches).
 56	*/
 57	if (_Py_PackageContext != NULL) {
 58		char *p = strrchr(_Py_PackageContext, '.');
 59		if (p != NULL && strcmp(name, p+1) == 0) {
 60			name = _Py_PackageContext;
 61			_Py_PackageContext = NULL;
 62		}
 63	}
 64	if ((m = PyImport_AddModule(name)) == NULL)
 65		return NULL;
 66	d = PyModule_GetDict(m);
 67	if (methods != NULL) {
 68		n = PyString_FromString(name);
 69		if (n == NULL)
 70			return NULL;
 71		for (ml = methods; ml->ml_name != NULL; ml++) {
 72			if ((ml->ml_flags & METH_CLASS) ||
 73			    (ml->ml_flags & METH_STATIC)) {
 74				PyErr_SetString(PyExc_ValueError,
 75						"module functions cannot set"
 76						" METH_CLASS or METH_STATIC");
 77				Py_DECREF(n);
 78				return NULL;
 79			}
 80			v = PyCFunction_NewEx(ml, passthrough, n);
 81			if (v == NULL) {
 82				Py_DECREF(n);
 83				return NULL;
 84			}
 85			if (PyDict_SetItemString(d, ml->ml_name, v) != 0) {
 86				Py_DECREF(v);
 87				Py_DECREF(n);
 88				return NULL;
 89			}
 90			Py_DECREF(v);
 91		}
 92		Py_DECREF(n);
 93	}
 94	if (doc != NULL) {
 95		v = PyString_FromString(doc);
 96		if (v == NULL || PyDict_SetItemString(d, "__doc__", v) != 0) {
 97			Py_XDECREF(v);
 98			return NULL;
 99		}
100		Py_DECREF(v);
101	}
102	return m;
103}
104
105
106/* Helper for mkvalue() to scan the length of a format */
107
108static int
109countformat(const char *format, int endchar)
110{
111	int count = 0;
112	int level = 0;
113	while (level > 0 || *format != endchar) {
114		switch (*format) {
115		case '\0':
116			/* Premature end */
117			PyErr_SetString(PyExc_SystemError,
118					"unmatched paren in format");
119			return -1;
120		case '(':
121		case '[':
122		case '{':
123			if (level == 0)
124				count++;
125			level++;
126			break;
127		case ')':
128		case ']':
129		case '}':
130			level--;
131			break;
132		case '#':
133		case '&':
134		case ',':
135		case ':':
136		case ' ':
137		case '\t':
138			break;
139		default:
140			if (level == 0)
141				count++;
142		}
143		format++;
144	}
145	return count;
146}
147
148
149/* Generic function to create a value -- the inverse of getargs() */
150/* After an original idea and first implementation by Steven Miale */
151
152static PyObject *do_mktuple(const char**, va_list *, int, int, int);
153static PyObject *do_mklist(const char**, va_list *, int, int, int);
154static PyObject *do_mkdict(const char**, va_list *, int, int, int);
155static PyObject *do_mkvalue(const char**, va_list *, int);
156
157
158static PyObject *
159do_mkdict(const char **p_format, va_list *p_va, int endchar, int n, int flags)
160{
161	PyObject *d;
162	int i;
163	int itemfailed = 0;
164	if (n < 0)
165		return NULL;
166	if ((d = PyDict_New()) == NULL)
167		return NULL;
168	/* Note that we can't bail immediately on error as this will leak
169	   refcounts on any 'N' arguments. */
170	for (i = 0; i < n; i+= 2) {
171		PyObject *k, *v;
172		int err;
173		k = do_mkvalue(p_format, p_va, flags);
174		if (k == NULL) {
175			itemfailed = 1;
176			Py_INCREF(Py_None);
177			k = Py_None;
178		}
179		v = do_mkvalue(p_format, p_va, flags);
180		if (v == NULL) {
181			itemfailed = 1;
182			Py_INCREF(Py_None);
183			v = Py_None;
184		}
185		err = PyDict_SetItem(d, k, v);
186		Py_DECREF(k);
187		Py_DECREF(v);
188		if (err < 0 || itemfailed) {
189			Py_DECREF(d);
190			return NULL;
191		}
192	}
193	if (d != NULL && **p_format != endchar) {
194		Py_DECREF(d);
195		d = NULL;
196		PyErr_SetString(PyExc_SystemError,
197				"Unmatched paren in format");
198	}
199	else if (endchar)
200		++*p_format;
201	return d;
202}
203
204static PyObject *
205do_mklist(const char **p_format, va_list *p_va, int endchar, int n, int flags)
206{
207	PyObject *v;
208	int i;
209	int itemfailed = 0;
210	if (n < 0)
211		return NULL;
212	v = PyList_New(n);
213	if (v == NULL)
214		return NULL;
215	/* Note that we can't bail immediately on error as this will leak
216	   refcounts on any 'N' arguments. */
217	for (i = 0; i < n; i++) {
218		PyObject *w = do_mkvalue(p_format, p_va, flags);
219		if (w == NULL) {
220			itemfailed = 1;
221			Py_INCREF(Py_None);
222			w = Py_None;
223		}
224		PyList_SET_ITEM(v, i, w);
225	}
226
227	if (itemfailed) {
228		/* do_mkvalue() should have already set an error */
229		Py_DECREF(v);
230		return NULL;
231	}
232	if (**p_format != endchar) {
233		Py_DECREF(v);
234		PyErr_SetString(PyExc_SystemError,
235				"Unmatched paren in format");
236		return NULL;
237	}
238	if (endchar)
239		++*p_format;
240	return v;
241}
242
243#ifdef Py_USING_UNICODE
244static int
245_ustrlen(Py_UNICODE *u)
246{
247	int i = 0;
248	Py_UNICODE *v = u;
249	while (*v != 0) { i++; v++; } 
250	return i;
251}
252#endif
253
254static PyObject *
255do_mktuple(const char **p_format, va_list *p_va, int endchar, int n, int flags)
256{
257	PyObject *v;
258	int i;
259	int itemfailed = 0;
260	if (n < 0)
261		return NULL;
262	if ((v = PyTuple_New(n)) == NULL)
263		return NULL;
264	/* Note that we can't bail immediately on error as this will leak
265	   refcounts on any 'N' arguments. */
266	for (i = 0; i < n; i++) {
267		PyObject *w = do_mkvalue(p_format, p_va, flags);
268		if (w == NULL) {
269			itemfailed = 1;
270			Py_INCREF(Py_None);
271			w = Py_None;
272		}
273		PyTuple_SET_ITEM(v, i, w);
274	}
275	if (itemfailed) {
276		/* do_mkvalue() should have already set an error */
277		Py_DECREF(v);
278		return NULL;
279	}
280	if (**p_format != endchar) {
281		Py_DECREF(v);
282		PyErr_SetString(PyExc_SystemError,
283				"Unmatched paren in format");
284		return NULL;
285	}
286	if (endchar)
287		++*p_format;
288	return v;
289}
290
291static PyObject *
292do_mkvalue(const char **p_format, va_list *p_va, int flags)
293{
294	for (;;) {
295		switch (*(*p_format)++) {
296		case '(':
297			return do_mktuple(p_format, p_va, ')',
298					  countformat(*p_format, ')'), flags);
299
300		case '[':
301			return do_mklist(p_format, p_va, ']',
302					 countformat(*p_format, ']'), flags);
303
304		case '{':
305			return do_mkdict(p_format, p_va, '}',
306					 countformat(*p_format, '}'), flags);
307
308		case 'b':
309		case 'B':
310		case 'h':
311		case 'i':
312			return PyInt_FromLong((long)va_arg(*p_va, int));
313			
314		case 'H':
315			return PyInt_FromLong((long)va_arg(*p_va, unsigned int));
316
317		case 'I':
318		{
319			unsigned int n;
320			n = va_arg(*p_va, unsigned int);
321			if (n > (unsigned long)PyInt_GetMax())
322				return PyLong_FromUnsignedLong((unsigned long)n);
323			else
324				return PyInt_FromLong(n);
325		}
326		
327		case 'n':
328#if SIZEOF_SIZE_T!=SIZEOF_LONG
329			return PyInt_FromSsize_t(va_arg(*p_va, Py_ssize_t));
330#endif
331			/* Fall through from 'n' to 'l' if Py_ssize_t is long */
332		case 'l':
333			return PyInt_FromLong(va_arg(*p_va, long));
334
335		case 'k':
336		{
337			unsigned long n;
338			n = va_arg(*p_va, unsigned long);
339			if (n > (unsigned long)PyInt_GetMax())
340				return PyLong_FromUnsignedLong(n);
341			else
342				return PyInt_FromLong(n);
343		}
344
345#ifdef HAVE_LONG_LONG
346		case 'L':
347			return PyLong_FromLongLong((PY_LONG_LONG)va_arg(*p_va, PY_LONG_LONG));
348
349		case 'K':
350			return PyLong_FromUnsignedLongLong((PY_LONG_LONG)va_arg(*p_va, unsigned PY_LONG_LONG));
351#endif
352#ifdef Py_USING_UNICODE
353		case 'u':
354		{
355			PyObject *v;
356			Py_UNICODE *u = va_arg(*p_va, Py_UNICODE *);
357			Py_ssize_t n;	
358			if (**p_format == '#') {
359				++*p_format;
360				if (flags & FLAG_SIZE_T)
361					n = va_arg(*p_va, Py_ssize_t);
362				else
363					n = va_arg(*p_va, int);
364			}
365			else
366				n = -1;
367			if (u == NULL) {
368				v = Py_None;
369				Py_INCREF(v);
370			}
371			else {
372				if (n < 0)
373					n = _ustrlen(u);
374				v = PyUnicode_FromUnicode(u, n);
375			}
376			return v;
377		}
378#endif
379		case 'f':
380		case 'd':
381			return PyFloat_FromDouble(
382				(double)va_arg(*p_va, va_double));
383
384#ifndef WITHOUT_COMPLEX
385		case 'D':
386			return PyComplex_FromCComplex(
387				*((Py_complex *)va_arg(*p_va, Py_complex *)));
388#endif /* WITHOUT_COMPLEX */
389
390		case 'c':
391		{
392			char p[1];
393			p[0] = (char)va_arg(*p_va, int);
394			return PyString_FromStringAndSize(p, 1);
395		}
396
397		case 's':
398		case 'z':
399		{
400			PyObject *v;
401			char *str = va_arg(*p_va, char *);
402			Py_ssize_t n;
403			if (**p_format == '#') {
404				++*p_format;
405				if (flags & FLAG_SIZE_T)
406					n = va_arg(*p_va, Py_ssize_t);
407				else
408					n = va_arg(*p_va, int);
409			}
410			else
411				n = -1;
412			if (str == NULL) {
413				v = Py_None;
414				Py_INCREF(v);
415			}
416			else {
417				if (n < 0) {
418					size_t m = strlen(str);
419					if (m > PY_SSIZE_T_MAX) {
420						PyErr_SetString(PyExc_OverflowError,
421							"string too long for Python string");
422						return NULL;
423					}
424					n = (Py_ssize_t)m;
425				}
426				v = PyString_FromStringAndSize(str, n);
427			}
428			return v;
429		}
430
431		case 'N':
432		case 'S':
433		case 'O':
434		if (**p_format == '&') {
435			typedef PyObject *(*converter)(void *);
436			converter func = va_arg(*p_va, converter);
437			void *arg = va_arg(*p_va, void *);
438			++*p_format;
439			return (*func)(arg);
440		}
441		else {
442			PyObject *v;
443			v = va_arg(*p_va, PyObject *);
444			if (v != NULL) {
445				if (*(*p_format - 1) != 'N')
446					Py_INCREF(v);
447			}
448			else if (!PyErr_Occurred())
449				/* If a NULL was passed
450				 * because a call that should
451				 * have constructed a value
452				 * failed, that's OK, and we
453				 * pass the error on; but if
454				 * no error occurred it's not
455				 * clear that the caller knew
456				 * what she was doing. */
457				PyErr_SetString(PyExc_SystemError,
458					"NULL object passed to Py_BuildValue");
459			return v;
460		}
461
462		case ':':
463		case ',':
464		case ' ':
465		case '\t':
466			break;
467
468		default:
469			PyErr_SetString(PyExc_SystemError,
470				"bad format char passed to Py_BuildValue");
471			return NULL;
472
473		}
474	}
475}
476
477
478PyObject *
479Py_BuildValue(const char *format, ...)
480{
481	va_list va;
482	PyObject* retval;
483	va_start(va, format);
484	retval = va_build_value(format, va, 0);
485	va_end(va);
486	return retval;
487}
488
489PyObject *
490_Py_BuildValue_SizeT(const char *format, ...)
491{
492	va_list va;
493	PyObject* retval;
494	va_start(va, format);
495	retval = va_build_value(format, va, FLAG_SIZE_T);
496	va_end(va);
497	return retval;
498}
499
500PyObject *
501Py_VaBuildValue(const char *format, va_list va)
502{
503	return va_build_value(format, va, 0);
504}
505
506PyObject *
507_Py_VaBuildValue_SizeT(const char *format, va_list va)
508{
509	return va_build_value(format, va, FLAG_SIZE_T);
510}
511
512static PyObject *
513va_build_value(const char *format, va_list va, int flags)
514{
515	const char *f = format;
516	int n = countformat(f, '\0');
517	va_list lva;
518
519#ifdef VA_LIST_IS_ARRAY
520	memcpy(lva, va, sizeof(va_list));
521#else
522#ifdef __va_copy
523	__va_copy(lva, va);
524#else
525	lva = va;
526#endif
527#endif
528
529	if (n < 0)
530		return NULL;
531	if (n == 0) {
532		Py_INCREF(Py_None);
533		return Py_None;
534	}
535	if (n == 1)
536		return do_mkvalue(&f, &lva, flags);
537	return do_mktuple(&f, &lva, '\0', n, flags);
538}
539
540
541PyObject *
542PyEval_CallFunction(PyObject *obj, const char *format, ...)
543{
544	va_list vargs;
545	PyObject *args;
546	PyObject *res;
547
548	va_start(vargs, format);
549
550	args = Py_VaBuildValue(format, vargs);
551	va_end(vargs);
552
553	if (args == NULL)
554		return NULL;
555
556	res = PyEval_CallObject(obj, args);
557	Py_DECREF(args);
558
559	return res;
560}
561
562
563PyObject *
564PyEval_CallMethod(PyObject *obj, const char *methodname, const char *format, ...)
565{
566	va_list vargs;
567	PyObject *meth;
568	PyObject *args;
569	PyObject *res;
570
571	meth = PyObject_GetAttrString(obj, methodname);
572	if (meth == NULL)
573		return NULL;
574
575	va_start(vargs, format);
576
577	args = Py_VaBuildValue(format, vargs);
578	va_end(vargs);
579
580	if (args == NULL) {
581		Py_DECREF(meth);
582		return NULL;
583	}
584
585	res = PyEval_CallObject(meth, args);
586	Py_DECREF(meth);
587	Py_DECREF(args);
588
589	return res;
590}
591
592int
593PyModule_AddObject(PyObject *m, const char *name, PyObject *o)
594{
595	PyObject *dict;
596	if (!PyModule_Check(m)) {
597		PyErr_SetString(PyExc_TypeError,
598			    "PyModule_AddObject() needs module as first arg");
599		return -1;
600	}
601	if (!o) {
602		if (!PyErr_Occurred())
603			PyErr_SetString(PyExc_TypeError,
604					"PyModule_AddObject() needs non-NULL value");
605		return -1;
606	}
607
608	dict = PyModule_GetDict(m);
609	if (dict == NULL) {
610		/* Internal error -- modules must have a dict! */
611		PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
612			     PyModule_GetName(m));
613		return -1;
614	}
615	if (PyDict_SetItemString(dict, name, o))
616		return -1;
617	Py_DECREF(o);
618	return 0;
619}
620
621int 
622PyModule_AddIntConstant(PyObject *m, const char *name, long value)
623{
624	PyObject *o = PyInt_FromLong(value);
625	if (!o)
626		return -1;
627	if (PyModule_AddObject(m, name, o) == 0)
628		return 0;
629	Py_DECREF(o);
630	return -1;
631}
632
633int 
634PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
635{
636	PyObject *o = PyString_FromString(value);
637	if (!o)
638		return -1;
639	if (PyModule_AddObject(m, name, o) == 0)
640		return 0;
641	Py_DECREF(o);
642	return -1;
643}