1 

     2 /* Module support implementation */

     3 

     4 #include "Python.h"

     5 

     6 #define FLAG_SIZE_T 1

     7 typedef double va_double;

     8 

     9 static PyObject *va_build_value(const char *, va_list, int);

    10 

    11 /* Package context -- the full module name for package imports */

    12 char *_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 

    27 static 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 

    31 PyObject *

    32 Py_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 

   108 static int

   109 countformat(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 

   152 static PyObject *do_mktuple(const char**, va_list *, int, int, int);

   153 static PyObject *do_mklist(const char**, va_list *, int, int, int);

   154 static PyObject *do_mkdict(const char**, va_list *, int, int, int);

   155 static PyObject *do_mkvalue(const char**, va_list *, int);

   156 

   157 

   158 static PyObject *

   159 do_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 

   204 static PyObject *

   205 do_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

   244 static 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 

   254 static PyObject *

   255 do_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 

   291 static PyObject *

   292 do_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 

   478 PyObject *

   479 Py_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 

   489 PyObject *

   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 

   500 PyObject *

   501 Py_VaBuildValue(const char *format, va_list va)

   502 {

   503 	return va_build_value(format, va, 0);

   504 }

   505 

   506 PyObject *

   507 _Py_VaBuildValue_SizeT(const char *format, va_list va)

   508 {

   509 	return va_build_value(format, va, FLAG_SIZE_T);

   510 }

   511 

   512 static PyObject *

   513 va_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 

   541 PyObject *

   542 PyEval_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 

   563 PyObject *

   564 PyEval_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 

   592 int

   593 PyModule_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 

   621 int 

   622 PyModule_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 

   633 int 

   634 PyModule_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 }