History

add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Python/modsupport.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Python/modsupport.c+631−0
@@ -0,0 +1,631 @@
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+ return PyModule_AddObject(m, name, PyInt_FromLong(value));
625+}
626+
627+int
628+PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
629+{
630+ return PyModule_AddObject(m, name, PyString_FromString(value));
631+}