[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.10 / 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
                if (PyDict_SetItem(d, key, Py_None) != 0)\r
                    PyErr_Clear();\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
                if (PyDict_SetItem(d, key, Py_None) != 0)\r
                    PyErr_Clear();\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
53b2ba57 DM	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	if (PyDict_SetItem(d, key, Py_None) != 0)\r
126	PyErr_Clear();\r
127	}\r
128	}\r
129	}\r
130	\r
131	/* Next, clear all names except for __builtins__ */\r
132	pos = 0;\r
133	while (PyDict_Next(d, &pos, &key, &value)) {\r
134	if (value != Py_None && PyString_Check(key)) {\r
135	char *s = PyString_AsString(key);\r
136	if (s[0] != '_' \|\| strcmp(s, "__builtins__") != 0) {\r
137	if (Py_VerboseFlag > 1)\r
138	PySys_WriteStderr("# clear[2] %s\n", s);\r
139	if (PyDict_SetItem(d, key, Py_None) != 0)\r
140	PyErr_Clear();\r
141	}\r
142	}\r
143	}\r
144	\r
145	/* Note: we leave __builtins__ in place, so that destructors\r
146	of non-global objects defined in this module can still use\r
147	builtins, in particularly 'None'. */\r
148	\r
149	}\r
150	\r
151	/* Methods */\r
152	\r
153	static int\r
154	module_init(PyModuleObject m, PyObject args, PyObject *kwds)\r
155	{\r
156	static char *kwlist[] = {"name", "doc", NULL};\r
157	PyObject dict, name = Py_None, *doc = Py_None;\r
158	if (!PyArg_ParseTupleAndKeywords(args, kwds, "S\|O:module.__init__",\r
159	kwlist, &name, &doc))\r
160	return -1;\r
161	dict = m->md_dict;\r
162	if (dict == NULL) {\r
163	dict = PyDict_New();\r
164	if (dict == NULL)\r
165	return -1;\r
166	m->md_dict = dict;\r
167	}\r
168	if (PyDict_SetItemString(dict, "__name__", name) < 0)\r
169	return -1;\r
170	if (PyDict_SetItemString(dict, "__doc__", doc) < 0)\r
171	return -1;\r
172	return 0;\r
173	}\r
174	\r
175	static void\r
176	module_dealloc(PyModuleObject *m)\r
177	{\r
178	PyObject_GC_UnTrack(m);\r
179	if (m->md_dict != NULL) {\r
180	_PyModule_Clear((PyObject *)m);\r
181	Py_DECREF(m->md_dict);\r
182	}\r
183	Py_TYPE(m)->tp_free((PyObject *)m);\r
184	}\r
185	\r
186	static PyObject *\r
187	module_repr(PyModuleObject *m)\r
188	{\r
189	char *name;\r
190	char *filename;\r
191	\r
192	name = PyModule_GetName((PyObject *)m);\r
193	if (name == NULL) {\r
194	PyErr_Clear();\r
195	name = "?";\r
196	}\r
197	filename = PyModule_GetFilename((PyObject *)m);\r
198	if (filename == NULL) {\r
199	PyErr_Clear();\r
200	return PyString_FromFormat("<module '%s' (built-in)>", name);\r
201	}\r
202	return PyString_FromFormat("<module '%s' from '%s'>", name, filename);\r
203	}\r
204	\r
205	/* We only need a traverse function, no clear function: If the module\r
206	is in a cycle, md_dict will be cleared as well, which will break\r
207	the cycle. */\r
208	static int\r
209	module_traverse(PyModuleObject m, visitproc visit, void arg)\r
210	{\r
211	Py_VISIT(m->md_dict);\r
212	return 0;\r
213	}\r
214	\r
215	PyDoc_STRVAR(module_doc,\r
216	"module(name[, doc])\n\\r
217	\n\\r
218	Create a module object.\n\\r
219	The name must be a string; the optional doc argument can have any type.");\r
220	\r
221	PyTypeObject PyModule_Type = {\r
222	PyVarObject_HEAD_INIT(&PyType_Type, 0)\r
223	"module", /* tp_name */\r
224	sizeof(PyModuleObject), /* tp_size */\r
225	0, /* tp_itemsize */\r
226	(destructor)module_dealloc, /* tp_dealloc */\r
227	0, /* tp_print */\r
228	0, /* tp_getattr */\r
229	0, /* tp_setattr */\r
230	0, /* tp_compare */\r
231	(reprfunc)module_repr, /* tp_repr */\r
232	0, /* tp_as_number */\r
233	0, /* tp_as_sequence */\r
234	0, /* tp_as_mapping */\r
235	0, /* tp_hash */\r
236	0, /* tp_call */\r
237	0, /* tp_str */\r
238	PyObject_GenericGetAttr, /* tp_getattro */\r
239	PyObject_GenericSetAttr, /* tp_setattro */\r
240	0, /* tp_as_buffer */\r
241	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC \|\r
242	Py_TPFLAGS_BASETYPE, /* tp_flags */\r
243	module_doc, /* tp_doc */\r
244	(traverseproc)module_traverse, /* tp_traverse */\r
245	0, /* tp_clear */\r
246	0, /* tp_richcompare */\r
247	0, /* tp_weaklistoffset */\r
248	0, /* tp_iter */\r
249	0, /* tp_iternext */\r
250	0, /* tp_methods */\r
251	module_members, /* tp_members */\r
252	0, /* tp_getset */\r
253	0, /* tp_base */\r
254	0, /* tp_dict */\r
255	0, /* tp_descr_get */\r
256	0, /* tp_descr_set */\r
257	offsetof(PyModuleObject, md_dict), /* tp_dictoffset */\r
258	(initproc)module_init, /* tp_init */\r
259	PyType_GenericAlloc, /* tp_alloc */\r
260	PyType_GenericNew, /* tp_new */\r
261	PyObject_GC_Del, /* tp_free */\r
262	};\r