/kbe/src/lib/python/Objects/moduleobject.c
C | 446 lines | 388 code | 36 blank | 22 comment | 111 complexity | 2b204fd3e6d449d73b1234e47da83fcf MD5 | raw file
1
2/* Module object implementation */
3
4#include "Python.h"
5#include "structmember.h"
6
7static Py_ssize_t max_module_number;
8
9typedef struct {
10 PyObject_HEAD
11 PyObject *md_dict;
12 struct PyModuleDef *md_def;
13 void *md_state;
14} PyModuleObject;
15
16static PyMemberDef module_members[] = {
17 {"__dict__", T_OBJECT, offsetof(PyModuleObject, md_dict), READONLY},
18 {0}
19};
20
21static PyTypeObject moduledef_type = {
22 PyVarObject_HEAD_INIT(&PyType_Type, 0)
23 "moduledef", /* tp_name */
24 sizeof(struct PyModuleDef), /* tp_size */
25 0, /* tp_itemsize */
26};
27
28
29PyObject *
30PyModule_New(const char *name)
31{
32 PyModuleObject *m;
33 PyObject *nameobj;
34 m = PyObject_GC_New(PyModuleObject, &PyModule_Type);
35 if (m == NULL)
36 return NULL;
37 m->md_def = NULL;
38 m->md_state = NULL;
39 nameobj = PyUnicode_FromString(name);
40 m->md_dict = PyDict_New();
41 if (m->md_dict == NULL || nameobj == NULL)
42 goto fail;
43 if (PyDict_SetItemString(m->md_dict, "__name__", nameobj) != 0)
44 goto fail;
45 if (PyDict_SetItemString(m->md_dict, "__doc__", Py_None) != 0)
46 goto fail;
47 if (PyDict_SetItemString(m->md_dict, "__package__", Py_None) != 0)
48 goto fail;
49 Py_DECREF(nameobj);
50 PyObject_GC_Track(m);
51 return (PyObject *)m;
52
53 fail:
54 Py_XDECREF(nameobj);
55 Py_DECREF(m);
56 return NULL;
57}
58
59PyObject *
60PyModule_Create2(struct PyModuleDef* module, int module_api_version)
61{
62 PyObject *d, *v, *n;
63 PyMethodDef *ml;
64 const char* name;
65 PyModuleObject *m;
66 PyInterpreterState *interp = PyThreadState_Get()->interp;
67 if (interp->modules == NULL)
68 Py_FatalError("Python import machinery not initialized");
69 if (PyType_Ready(&moduledef_type) < 0)
70 return NULL;
71 if (module->m_base.m_index == 0) {
72 max_module_number++;
73 Py_REFCNT(module) = 1;
74 Py_TYPE(module) = &moduledef_type;
75 module->m_base.m_index = max_module_number;
76 }
77 name = module->m_name;
78 if (module_api_version != PYTHON_API_VERSION && module_api_version != PYTHON_ABI_VERSION) {
79 int err;
80 err = PyErr_WarnFormat(PyExc_RuntimeWarning, 1,
81 "Python C API version mismatch for module %.100s: "
82 "This Python has API version %d, module %.100s has version %d.",
83 name,
84 PYTHON_API_VERSION, name, module_api_version);
85 if (err)
86 return NULL;
87 }
88 /* Make sure name is fully qualified.
89
90 This is a bit of a hack: when the shared library is loaded,
91 the module name is "package.module", but the module calls
92 PyModule_Create*() with just "module" for the name. The shared
93 library loader squirrels away the true name of the module in
94 _Py_PackageContext, and PyModule_Create*() will substitute this
95 (if the name actually matches).
96 */
97 if (_Py_PackageContext != NULL) {
98 char *p = strrchr(_Py_PackageContext, '.');
99 if (p != NULL && strcmp(module->m_name, p+1) == 0) {
100 name = _Py_PackageContext;
101 _Py_PackageContext = NULL;
102 }
103 }
104 if ((m = (PyModuleObject*)PyModule_New(name)) == NULL)
105 return NULL;
106
107 if (module->m_size > 0) {
108 m->md_state = PyMem_MALLOC(module->m_size);
109 if (!m->md_state) {
110 PyErr_NoMemory();
111 Py_DECREF(m);
112 return NULL;
113 }
114 memset(m->md_state, 0, module->m_size);
115 }
116
117 d = PyModule_GetDict((PyObject*)m);
118 if (module->m_methods != NULL) {
119 n = PyUnicode_FromString(name);
120 if (n == NULL) {
121 Py_DECREF(m);
122 return NULL;
123 }
124 for (ml = module->m_methods; ml->ml_name != NULL; ml++) {
125 if ((ml->ml_flags & METH_CLASS) ||
126 (ml->ml_flags & METH_STATIC)) {
127 PyErr_SetString(PyExc_ValueError,
128 "module functions cannot set"
129 " METH_CLASS or METH_STATIC");
130 Py_DECREF(n);
131 Py_DECREF(m);
132 return NULL;
133 }
134 v = PyCFunction_NewEx(ml, (PyObject*)m, n);
135 if (v == NULL) {
136 Py_DECREF(n);
137 Py_DECREF(m);
138 return NULL;
139 }
140 if (PyDict_SetItemString(d, ml->ml_name, v) != 0) {
141 Py_DECREF(v);
142 Py_DECREF(n);
143 Py_DECREF(m);
144 return NULL;
145 }
146 Py_DECREF(v);
147 }
148 Py_DECREF(n);
149 }
150 if (module->m_doc != NULL) {
151 v = PyUnicode_FromString(module->m_doc);
152 if (v == NULL || PyDict_SetItemString(d, "__doc__", v) != 0) {
153 Py_XDECREF(v);
154 Py_DECREF(m);
155 return NULL;
156 }
157 Py_DECREF(v);
158 }
159 m->md_def = module;
160 return (PyObject*)m;
161}
162
163
164PyObject *
165PyModule_GetDict(PyObject *m)
166{
167 PyObject *d;
168 if (!PyModule_Check(m)) {
169 PyErr_BadInternalCall();
170 return NULL;
171 }
172 d = ((PyModuleObject *)m) -> md_dict;
173 if (d == NULL)
174 ((PyModuleObject *)m) -> md_dict = d = PyDict_New();
175 return d;
176}
177
178const char *
179PyModule_GetName(PyObject *m)
180{
181 PyObject *d;
182 PyObject *nameobj;
183 if (!PyModule_Check(m)) {
184 PyErr_BadArgument();
185 return NULL;
186 }
187 d = ((PyModuleObject *)m)->md_dict;
188 if (d == NULL ||
189 (nameobj = PyDict_GetItemString(d, "__name__")) == NULL ||
190 !PyUnicode_Check(nameobj))
191 {
192 PyErr_SetString(PyExc_SystemError, "nameless module");
193 return NULL;
194 }
195 return _PyUnicode_AsString(nameobj);
196}
197
198PyObject*
199PyModule_GetFilenameObject(PyObject *m)
200{
201 PyObject *d;
202 PyObject *fileobj;
203 if (!PyModule_Check(m)) {
204 PyErr_BadArgument();
205 return NULL;
206 }
207 d = ((PyModuleObject *)m)->md_dict;
208 if (d == NULL ||
209 (fileobj = PyDict_GetItemString(d, "__file__")) == NULL ||
210 !PyUnicode_Check(fileobj))
211 {
212 PyErr_SetString(PyExc_SystemError, "module filename missing");
213 return NULL;
214 }
215 Py_INCREF(fileobj);
216 return fileobj;
217}
218
219const char *
220PyModule_GetFilename(PyObject *m)
221{
222 PyObject *fileobj;
223 char *utf8;
224 fileobj = PyModule_GetFilenameObject(m);
225 if (fileobj == NULL)
226 return NULL;
227 utf8 = _PyUnicode_AsString(fileobj);
228 Py_DECREF(fileobj);
229 return utf8;
230}
231
232PyModuleDef*
233PyModule_GetDef(PyObject* m)
234{
235 if (!PyModule_Check(m)) {
236 PyErr_BadArgument();
237 return NULL;
238 }
239 return ((PyModuleObject *)m)->md_def;
240}
241
242void*
243PyModule_GetState(PyObject* m)
244{
245 if (!PyModule_Check(m)) {
246 PyErr_BadArgument();
247 return NULL;
248 }
249 return ((PyModuleObject *)m)->md_state;
250}
251
252void
253_PyModule_Clear(PyObject *m)
254{
255 /* To make the execution order of destructors for global
256 objects a bit more predictable, we first zap all objects
257 whose name starts with a single underscore, before we clear
258 the entire dictionary. We zap them by replacing them with
259 None, rather than deleting them from the dictionary, to
260 avoid rehashing the dictionary (to some extent). */
261
262 Py_ssize_t pos;
263 PyObject *key, *value;
264 PyObject *d;
265
266 d = ((PyModuleObject *)m)->md_dict;
267 if (d == NULL)
268 return;
269
270 /* First, clear only names starting with a single underscore */
271 pos = 0;
272 while (PyDict_Next(d, &pos, &key, &value)) {
273 if (value != Py_None && PyUnicode_Check(key)) {
274 Py_UNICODE *u = PyUnicode_AS_UNICODE(key);
275 if (u[0] == '_' && u[1] != '_') {
276 if (Py_VerboseFlag > 1) {
277 const char *s = _PyUnicode_AsString(key);
278 if (s != NULL)
279 PySys_WriteStderr("# clear[1] %s\n", s);
280 else
281 PyErr_Clear();
282 }
283 PyDict_SetItem(d, key, Py_None);
284 }
285 }
286 }
287
288 /* Next, clear all names except for __builtins__ */
289 pos = 0;
290 while (PyDict_Next(d, &pos, &key, &value)) {
291 if (value != Py_None && PyUnicode_Check(key)) {
292 Py_UNICODE *u = PyUnicode_AS_UNICODE(key);
293 if (u[0] != '_'
294 || PyUnicode_CompareWithASCIIString(key, "__builtins__") != 0)
295 {
296 if (Py_VerboseFlag > 1) {
297 const char *s = _PyUnicode_AsString(key);
298 if (s != NULL)
299 PySys_WriteStderr("# clear[2] %s\n", s);
300 else
301 PyErr_Clear();
302 }
303 PyDict_SetItem(d, key, Py_None);
304 }
305 }
306 }
307
308 /* Note: we leave __builtins__ in place, so that destructors
309 of non-global objects defined in this module can still use
310 builtins, in particularly 'None'. */
311
312}
313
314/* Methods */
315
316static int
317module_init(PyModuleObject *m, PyObject *args, PyObject *kwds)
318{
319 static char *kwlist[] = {"name", "doc", NULL};
320 PyObject *dict, *name = Py_None, *doc = Py_None;
321 if (!PyArg_ParseTupleAndKeywords(args, kwds, "U|O:module.__init__",
322 kwlist, &name, &doc))
323 return -1;
324 dict = m->md_dict;
325 if (dict == NULL) {
326 dict = PyDict_New();
327 if (dict == NULL)
328 return -1;
329 m->md_dict = dict;
330 }
331 if (PyDict_SetItemString(dict, "__name__", name) < 0)
332 return -1;
333 if (PyDict_SetItemString(dict, "__doc__", doc) < 0)
334 return -1;
335 return 0;
336}
337
338static void
339module_dealloc(PyModuleObject *m)
340{
341 PyObject_GC_UnTrack(m);
342 if (m->md_def && m->md_def->m_free)
343 m->md_def->m_free(m);
344 if (m->md_dict != NULL) {
345 _PyModule_Clear((PyObject *)m);
346 Py_DECREF(m->md_dict);
347 }
348 if (m->md_state != NULL)
349 PyMem_FREE(m->md_state);
350 Py_TYPE(m)->tp_free((PyObject *)m);
351}
352
353static PyObject *
354module_repr(PyModuleObject *m)
355{
356 const char *name;
357 PyObject *filename, *repr;
358
359 name = PyModule_GetName((PyObject *)m);
360 if (name == NULL) {
361 PyErr_Clear();
362 name = "?";
363 }
364 filename = PyModule_GetFilenameObject((PyObject *)m);
365 if (filename == NULL) {
366 PyErr_Clear();
367 return PyUnicode_FromFormat("<module '%s' (built-in)>", name);
368 }
369 repr = PyUnicode_FromFormat("<module '%s' from '%U'>", name, filename);
370 Py_DECREF(filename);
371 return repr;
372}
373
374static int
375module_traverse(PyModuleObject *m, visitproc visit, void *arg)
376{
377 if (m->md_def && m->md_def->m_traverse) {
378 int res = m->md_def->m_traverse((PyObject*)m, visit, arg);
379 if (res)
380 return res;
381 }
382 Py_VISIT(m->md_dict);
383 return 0;
384}
385
386static int
387module_clear(PyModuleObject *m)
388{
389 if (m->md_def && m->md_def->m_clear) {
390 int res = m->md_def->m_clear((PyObject*)m);
391 if (res)
392 return res;
393 }
394 Py_CLEAR(m->md_dict);
395 return 0;
396}
397
398
399PyDoc_STRVAR(module_doc,
400"module(name[, doc])\n\
401\n\
402Create a module object.\n\
403The name must be a string; the optional doc argument can have any type.");
404
405PyTypeObject PyModule_Type = {
406 PyVarObject_HEAD_INIT(&PyType_Type, 0)
407 "module", /* tp_name */
408 sizeof(PyModuleObject), /* tp_size */
409 0, /* tp_itemsize */
410 (destructor)module_dealloc, /* tp_dealloc */
411 0, /* tp_print */
412 0, /* tp_getattr */
413 0, /* tp_setattr */
414 0, /* tp_reserved */
415 (reprfunc)module_repr, /* tp_repr */
416 0, /* tp_as_number */
417 0, /* tp_as_sequence */
418 0, /* tp_as_mapping */
419 0, /* tp_hash */
420 0, /* tp_call */
421 0, /* tp_str */
422 PyObject_GenericGetAttr, /* tp_getattro */
423 PyObject_GenericSetAttr, /* tp_setattro */
424 0, /* tp_as_buffer */
425 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
426 Py_TPFLAGS_BASETYPE, /* tp_flags */
427 module_doc, /* tp_doc */
428 (traverseproc)module_traverse, /* tp_traverse */
429 (inquiry)module_clear, /* tp_clear */
430 0, /* tp_richcompare */
431 0, /* tp_weaklistoffset */
432 0, /* tp_iter */
433 0, /* tp_iternext */
434 0, /* tp_methods */
435 module_members, /* tp_members */
436 0, /* tp_getset */
437 0, /* tp_base */
438 0, /* tp_dict */
439 0, /* tp_descr_get */
440 0, /* tp_descr_set */
441 offsetof(PyModuleObject, md_dict), /* tp_dictoffset */
442 (initproc)module_init, /* tp_init */
443 PyType_GenericAlloc, /* tp_alloc */
444 PyType_GenericNew, /* tp_new */
445 PyObject_GC_Del, /* tp_free */
446};