[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Objects / moduleobject.c

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