Objects/moduleobject.c

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