Objects/moduleobject.c

   1
   2 /* Module object implementation */
   3
   4 #include "Python.h"
   5 #include "structmember.h"
   6
   7 typedef struct {
   8         PyObject_HEAD
   9         PyObject *md_dict;
  10 } PyModuleObject;
  11
  12 static PyMemberDef module_members[] = {
  13         {"__dict__", T_OBJECT, offsetof(PyModuleObject, md_dict), READONLY},
  14         {0}
  15 };
  16
  17 PyObject *
  18 PyModule_New(const char *name)
  19 {
  20         PyModuleObject *m;
  21         PyObject *nameobj;
  22         m = PyObject_GC_New(PyModuleObject, &PyModule_Type);
  23         if (m == NULL)
  24                 return NULL;
  25         nameobj = PyString_FromString(name);
  26         m->md_dict = PyDict_New();
  27         if (m->md_dict == NULL || nameobj == NULL)
  28                 goto fail;
  29         if (PyDict_SetItemString(m->md_dict, "__name__", nameobj) != 0)
  30                 goto fail;
  31         if (PyDict_SetItemString(m->md_dict, "__doc__", Py_None) != 0)
  32                 goto fail;
  33         if (PyDict_SetItemString(m->md_dict, "__package__", Py_None) != 0)
  34                 goto fail;
  35         Py_DECREF(nameobj);
  36         PyObject_GC_Track(m);
  37         return (PyObject *)m;
  38
  39  fail:
  40         Py_XDECREF(nameobj);
  41         Py_DECREF(m);
  42         return NULL;
  43 }
  44
  45 PyObject *
  46 PyModule_GetDict(PyObject *m)
  47 {
  48         PyObject *d;
  49         if (!PyModule_Check(m)) {
  50                 PyErr_BadInternalCall();
  51                 return NULL;
  52         }
  53         d = ((PyModuleObject *)m) -> md_dict;
  54         if (d == NULL)
  55                 ((PyModuleObject *)m) -> md_dict = d = PyDict_New();
  56         return d;
  57 }
  58
  59 char *
  60 PyModule_GetName(PyObject *m)
  61 {
  62         PyObject *d;
  63         PyObject *nameobj;
  64         if (!PyModule_Check(m)) {
  65                 PyErr_BadArgument();
  66                 return NULL;
  67         }
  68         d = ((PyModuleObject *)m)->md_dict;
  69         if (d == NULL ||
  70             (nameobj = PyDict_GetItemString(d, "__name__")) == NULL ||
  71             !PyString_Check(nameobj))
  72         {
  73                 PyErr_SetString(PyExc_SystemError, "nameless module");
  74                 return NULL;
  75         }
  76         return PyString_AsString(nameobj);
  77 }
  78
  79 char *
  80 PyModule_GetFilename(PyObject *m)
  81 {
  82         PyObject *d;
  83         PyObject *fileobj;
  84         if (!PyModule_Check(m)) {
  85                 PyErr_BadArgument();
  86                 return NULL;
  87         }
  88         d = ((PyModuleObject *)m)->md_dict;
  89         if (d == NULL ||
  90             (fileobj = PyDict_GetItemString(d, "__file__")) == NULL ||
  91             !PyString_Check(fileobj))
  92         {
  93                 PyErr_SetString(PyExc_SystemError, "module filename missing");
  94                 return NULL;
  95         }
  96         return PyString_AsString(fileobj);
  97 }
  98
  99 void
 100 _PyModule_Clear(PyObject *m)
 101 {
 102         /* To make the execution order of destructors for global
 103            objects a bit more predictable, we first zap all objects
 104            whose name starts with a single underscore, before we clear
 105            the entire dictionary.  We zap them by replacing them with
 106            None, rather than deleting them from the dictionary, to
 107            avoid rehashing the dictionary (to some extent). */
 108
 109         Py_ssize_t pos;
 110         PyObject *key, *value;
 111         PyObject *d;
 112
 113         d = ((PyModuleObject *)m)->md_dict;
 114         if (d == NULL)
 115                 return;
 116
 117         /* First, clear only names starting with a single underscore */
 118         pos = 0;
 119         while (PyDict_Next(d, &pos, &key, &value)) {
 120                 if (value != Py_None && PyString_Check(key)) {
 121                         char *s = PyString_AsString(key);
 122                         if (s[0] == '_' && s[1] != '_') {
 123                                 if (Py_VerboseFlag > 1)
 124                                     PySys_WriteStderr("#   clear[1] %s\n", s);
 125                                 PyDict_SetItem(d, key, Py_None);
 126                         }
 127                 }
 128         }
 129
 130         /* Next, clear all names except for __builtins__ */
 131         pos = 0;
 132         while (PyDict_Next(d, &pos, &key, &value)) {
 133                 if (value != Py_None && PyString_Check(key)) {
 134                         char *s = PyString_AsString(key);
 135                         if (s[0] != '_' || strcmp(s, "__builtins__") != 0) {
 136                                 if (Py_VerboseFlag > 1)
 137                                     PySys_WriteStderr("#   clear[2] %s\n", s);
 138                                 PyDict_SetItem(d, key, Py_None);
 139                         }
 140                 }
 141         }
 142
 143         /* Note: we leave __builtins__ in place, so that destructors
 144            of non-global objects defined in this module can still use
 145            builtins, in particularly 'None'. */
 146
 147 }
 148
 149 /* Methods */
 150
 151 static int
 152 module_init(PyModuleObject *m, PyObject *args, PyObject *kwds)
 153 {
 154         static char *kwlist[] = {"name", "doc", NULL};
 155         PyObject *dict, *name = Py_None, *doc = Py_None;
 156         if (!PyArg_ParseTupleAndKeywords(args, kwds, "S|O:module.__init__",
 157                                          kwlist, &name, &doc))
 158                 return -1;
 159         dict = m->md_dict;
 160         if (dict == NULL) {
 161                 dict = PyDict_New();
 162                 if (dict == NULL)
 163                         return -1;
 164                 m->md_dict = dict;
 165         }
 166         if (PyDict_SetItemString(dict, "__name__", name) < 0)
 167                 return -1;
 168         if (PyDict_SetItemString(dict, "__doc__", doc) < 0)
 169                 return -1;
 170         return 0;
 171 }
 172
 173 static void
 174 module_dealloc(PyModuleObject *m)
 175 {
 176         PyObject_GC_UnTrack(m);
 177         if (m->md_dict != NULL) {
 178                 /* If we are the only ones holding a reference, we can clear
 179                    the dictionary. */
 180                 if (Py_REFCNT(m->md_dict) == 1)
 181                         _PyModule_Clear((PyObject *)m);
 182                 Py_DECREF(m->md_dict);
 183         }
 184         Py_TYPE(m)->tp_free((PyObject *)m);
 185 }
 186
 187 static PyObject *
 188 module_repr(PyModuleObject *m)
 189 {
 190         char *name;
 191         char *filename;
 192
 193         name = PyModule_GetName((PyObject *)m);
 194         if (name == NULL) {
 195                 PyErr_Clear();
 196                 name = "?";
 197         }
 198         filename = PyModule_GetFilename((PyObject *)m);
 199         if (filename == NULL) {
 200                 PyErr_Clear();
 201                 return PyString_FromFormat("<module '%s' (built-in)>", name);
 202         }
 203         return PyString_FromFormat("<module '%s' from '%s'>", name, filename);
 204 }
 205
 206 /* We only need a traverse function, no clear function: If the module
 207    is in a cycle, md_dict will be cleared as well, which will break
 208    the cycle. */
 209 static int
 210 module_traverse(PyModuleObject *m, visitproc visit, void *arg)
 211 {
 212         Py_VISIT(m->md_dict);
 213         return 0;
 214 }
 215
 216 PyDoc_STRVAR(module_doc,
 217 "module(name[, doc])\n\
 218 \n\
 219 Create a module object.\n\
 220 The name must be a string; the optional doc argument can have any type.");
 221
 222 PyTypeObject PyModule_Type = {
 223         PyVarObject_HEAD_INIT(&PyType_Type, 0)
 224         "module",                               /* tp_name */
 225         sizeof(PyModuleObject),                 /* tp_size */
 226         0,                                      /* tp_itemsize */
 227         (destructor)module_dealloc,             /* tp_dealloc */
 228         0,                                      /* tp_print */
 229         0,                                      /* tp_getattr */
 230         0,                                      /* tp_setattr */
 231         0,                                      /* tp_compare */
 232         (reprfunc)module_repr,                  /* tp_repr */
 233         0,                                      /* tp_as_number */
 234         0,                                      /* tp_as_sequence */
 235         0,                                      /* tp_as_mapping */
 236         0,                                      /* tp_hash */
 237         0,                                      /* tp_call */
 238         0,                                      /* tp_str */
 239         PyObject_GenericGetAttr,                /* tp_getattro */
 240         PyObject_GenericSetAttr,                /* tp_setattro */
 241         0,                                      /* tp_as_buffer */
 242         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
 243                 Py_TPFLAGS_BASETYPE,            /* tp_flags */
 244         module_doc,                             /* tp_doc */
 245         (traverseproc)module_traverse,          /* tp_traverse */
 246         0,                                      /* tp_clear */
 247         0,                                      /* tp_richcompare */
 248         0,                                      /* tp_weaklistoffset */
 249         0,                                      /* tp_iter */
 250         0,                                      /* tp_iternext */
 251         0,                                      /* tp_methods */
 252         module_members,                         /* tp_members */
 253         0,                                      /* tp_getset */
 254         0,                                      /* tp_base */
 255         0,                                      /* tp_dict */
 256         0,                                      /* tp_descr_get */
 257         0,                                      /* tp_descr_set */
 258         offsetof(PyModuleObject, md_dict),      /* tp_dictoffset */
 259         (initproc)module_init,                  /* tp_init */
 260         PyType_GenericAlloc,                    /* tp_alloc */
 261         PyType_GenericNew,                      /* tp_new */
 262         PyObject_GC_Del,                        /* tp_free */
 263 };