Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit fd4d050

Browse files
brettcannonbrettcannon
committed
Move import.c to use Clinic file output.
1 parent 1715830 commit fd4d050

2 files changed

Lines changed: 340 additions & 330 deletions

File tree

‎Python/clinic/import.c.h‎

Lines changed: 323 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,323 @@
1+
/*[clinic input]
2+
preserve
3+
[clinic start generated code]*/
4+
5+
PyDoc_STRVAR(_imp_lock_held__doc__,
6+
"lock_held($module, /)\n"
7+
"--\n"
8+
"\n"
9+
"Return True if the import lock is currently held, else False.\n"
10+
"\n"
11+
"On platforms without threads, return False.");
12+
13+
#define _IMP_LOCK_HELD_METHODDEF \
14+
{"lock_held", (PyCFunction)_imp_lock_held, METH_NOARGS, _imp_lock_held__doc__},
15+
16+
static PyObject *
17+
_imp_lock_held_impl(PyModuleDef *module);
18+
19+
static PyObject *
20+
_imp_lock_held(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
21+
{
22+
return _imp_lock_held_impl(module);
23+
}
24+
25+
PyDoc_STRVAR(_imp_acquire_lock__doc__,
26+
"acquire_lock($module, /)\n"
27+
"--\n"
28+
"\n"
29+
"Acquires the interpreter\'s import lock for the current thread.\n"
30+
"\n"
31+
"This lock should be used by import hooks to ensure thread-safety when importing\n"
32+
"modules. On platforms without threads, this function does nothing.");
33+
34+
#define _IMP_ACQUIRE_LOCK_METHODDEF \
35+
{"acquire_lock", (PyCFunction)_imp_acquire_lock, METH_NOARGS, _imp_acquire_lock__doc__},
36+
37+
static PyObject *
38+
_imp_acquire_lock_impl(PyModuleDef *module);
39+
40+
static PyObject *
41+
_imp_acquire_lock(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
42+
{
43+
return _imp_acquire_lock_impl(module);
44+
}
45+
46+
PyDoc_STRVAR(_imp_release_lock__doc__,
47+
"release_lock($module, /)\n"
48+
"--\n"
49+
"\n"
50+
"Release the interpreter\'s import lock.\n"
51+
"\n"
52+
"On platforms without threads, this function does nothing.");
53+
54+
#define _IMP_RELEASE_LOCK_METHODDEF \
55+
{"release_lock", (PyCFunction)_imp_release_lock, METH_NOARGS, _imp_release_lock__doc__},
56+
57+
static PyObject *
58+
_imp_release_lock_impl(PyModuleDef *module);
59+
60+
static PyObject *
61+
_imp_release_lock(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
62+
{
63+
return _imp_release_lock_impl(module);
64+
}
65+
66+
PyDoc_STRVAR(_imp__fix_co_filename__doc__,
67+
"_fix_co_filename($module, code, path, /)\n"
68+
"--\n"
69+
"\n"
70+
"Changes code.co_filename to specify the passed-in file path.\n"
71+
"\n"
72+
" code\n"
73+
" Code object to change.\n"
74+
" path\n"
75+
" File path to use.");
76+
77+
#define _IMP__FIX_CO_FILENAME_METHODDEF \
78+
{"_fix_co_filename", (PyCFunction)_imp__fix_co_filename, METH_VARARGS, _imp__fix_co_filename__doc__},
79+
80+
static PyObject *
81+
_imp__fix_co_filename_impl(PyModuleDef *module, PyCodeObject *code, PyObject *path);
82+
83+
static PyObject *
84+
_imp__fix_co_filename(PyModuleDef *module, PyObject *args)
85+
{
86+
PyObject *return_value = NULL;
87+
PyCodeObject *code;
88+
PyObject *path;
89+
90+
if (!PyArg_ParseTuple(args,
91+
"O!U:_fix_co_filename",
92+
&PyCode_Type, &code, &path))
93+
goto exit;
94+
return_value = _imp__fix_co_filename_impl(module, code, path);
95+
96+
exit:
97+
return return_value;
98+
}
99+
100+
PyDoc_STRVAR(_imp_extension_suffixes__doc__,
101+
"extension_suffixes($module, /)\n"
102+
"--\n"
103+
"\n"
104+
"Returns the list of file suffixes used to identify extension modules.");
105+
106+
#define _IMP_EXTENSION_SUFFIXES_METHODDEF \
107+
{"extension_suffixes", (PyCFunction)_imp_extension_suffixes, METH_NOARGS, _imp_extension_suffixes__doc__},
108+
109+
static PyObject *
110+
_imp_extension_suffixes_impl(PyModuleDef *module);
111+
112+
static PyObject *
113+
_imp_extension_suffixes(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
114+
{
115+
return _imp_extension_suffixes_impl(module);
116+
}
117+
118+
PyDoc_STRVAR(_imp_init_builtin__doc__,
119+
"init_builtin($module, name, /)\n"
120+
"--\n"
121+
"\n"
122+
"Initializes a built-in module.");
123+
124+
#define _IMP_INIT_BUILTIN_METHODDEF \
125+
{"init_builtin", (PyCFunction)_imp_init_builtin, METH_VARARGS, _imp_init_builtin__doc__},
126+
127+
static PyObject *
128+
_imp_init_builtin_impl(PyModuleDef *module, PyObject *name);
129+
130+
static PyObject *
131+
_imp_init_builtin(PyModuleDef *module, PyObject *args)
132+
{
133+
PyObject *return_value = NULL;
134+
PyObject *name;
135+
136+
if (!PyArg_ParseTuple(args,
137+
"U:init_builtin",
138+
&name))
139+
goto exit;
140+
return_value = _imp_init_builtin_impl(module, name);
141+
142+
exit:
143+
return return_value;
144+
}
145+
146+
PyDoc_STRVAR(_imp_init_frozen__doc__,
147+
"init_frozen($module, name, /)\n"
148+
"--\n"
149+
"\n"
150+
"Initializes a frozen module.");
151+
152+
#define _IMP_INIT_FROZEN_METHODDEF \
153+
{"init_frozen", (PyCFunction)_imp_init_frozen, METH_VARARGS, _imp_init_frozen__doc__},
154+
155+
static PyObject *
156+
_imp_init_frozen_impl(PyModuleDef *module, PyObject *name);
157+
158+
static PyObject *
159+
_imp_init_frozen(PyModuleDef *module, PyObject *args)
160+
{
161+
PyObject *return_value = NULL;
162+
PyObject *name;
163+
164+
if (!PyArg_ParseTuple(args,
165+
"U:init_frozen",
166+
&name))
167+
goto exit;
168+
return_value = _imp_init_frozen_impl(module, name);
169+
170+
exit:
171+
return return_value;
172+
}
173+
174+
PyDoc_STRVAR(_imp_get_frozen_object__doc__,
175+
"get_frozen_object($module, name, /)\n"
176+
"--\n"
177+
"\n"
178+
"Create a code object for a frozen module.");
179+
180+
#define _IMP_GET_FROZEN_OBJECT_METHODDEF \
181+
{"get_frozen_object", (PyCFunction)_imp_get_frozen_object, METH_VARARGS, _imp_get_frozen_object__doc__},
182+
183+
static PyObject *
184+
_imp_get_frozen_object_impl(PyModuleDef *module, PyObject *name);
185+
186+
static PyObject *
187+
_imp_get_frozen_object(PyModuleDef *module, PyObject *args)
188+
{
189+
PyObject *return_value = NULL;
190+
PyObject *name;
191+
192+
if (!PyArg_ParseTuple(args,
193+
"U:get_frozen_object",
194+
&name))
195+
goto exit;
196+
return_value = _imp_get_frozen_object_impl(module, name);
197+
198+
exit:
199+
return return_value;
200+
}
201+
202+
PyDoc_STRVAR(_imp_is_frozen_package__doc__,
203+
"is_frozen_package($module, name, /)\n"
204+
"--\n"
205+
"\n"
206+
"Returns True if the module name is of a frozen package.");
207+
208+
#define _IMP_IS_FROZEN_PACKAGE_METHODDEF \
209+
{"is_frozen_package", (PyCFunction)_imp_is_frozen_package, METH_VARARGS, _imp_is_frozen_package__doc__},
210+
211+
static PyObject *
212+
_imp_is_frozen_package_impl(PyModuleDef *module, PyObject *name);
213+
214+
static PyObject *
215+
_imp_is_frozen_package(PyModuleDef *module, PyObject *args)
216+
{
217+
PyObject *return_value = NULL;
218+
PyObject *name;
219+
220+
if (!PyArg_ParseTuple(args,
221+
"U:is_frozen_package",
222+
&name))
223+
goto exit;
224+
return_value = _imp_is_frozen_package_impl(module, name);
225+
226+
exit:
227+
return return_value;
228+
}
229+
230+
PyDoc_STRVAR(_imp_is_builtin__doc__,
231+
"is_builtin($module, name, /)\n"
232+
"--\n"
233+
"\n"
234+
"Returns True if the module name corresponds to a built-in module.");
235+
236+
#define _IMP_IS_BUILTIN_METHODDEF \
237+
{"is_builtin", (PyCFunction)_imp_is_builtin, METH_VARARGS, _imp_is_builtin__doc__},
238+
239+
static PyObject *
240+
_imp_is_builtin_impl(PyModuleDef *module, PyObject *name);
241+
242+
static PyObject *
243+
_imp_is_builtin(PyModuleDef *module, PyObject *args)
244+
{
245+
PyObject *return_value = NULL;
246+
PyObject *name;
247+
248+
if (!PyArg_ParseTuple(args,
249+
"U:is_builtin",
250+
&name))
251+
goto exit;
252+
return_value = _imp_is_builtin_impl(module, name);
253+
254+
exit:
255+
return return_value;
256+
}
257+
258+
PyDoc_STRVAR(_imp_is_frozen__doc__,
259+
"is_frozen($module, name, /)\n"
260+
"--\n"
261+
"\n"
262+
"Returns True if the module name corresponds to a frozen module.");
263+
264+
#define _IMP_IS_FROZEN_METHODDEF \
265+
{"is_frozen", (PyCFunction)_imp_is_frozen, METH_VARARGS, _imp_is_frozen__doc__},
266+
267+
static PyObject *
268+
_imp_is_frozen_impl(PyModuleDef *module, PyObject *name);
269+
270+
static PyObject *
271+
_imp_is_frozen(PyModuleDef *module, PyObject *args)
272+
{
273+
PyObject *return_value = NULL;
274+
PyObject *name;
275+
276+
if (!PyArg_ParseTuple(args,
277+
"U:is_frozen",
278+
&name))
279+
goto exit;
280+
return_value = _imp_is_frozen_impl(module, name);
281+
282+
exit:
283+
return return_value;
284+
}
285+
286+
#if defined(HAVE_DYNAMIC_LOADING)
287+
288+
PyDoc_STRVAR(_imp_load_dynamic__doc__,
289+
"load_dynamic($module, name, path, file=None, /)\n"
290+
"--\n"
291+
"\n"
292+
"Loads an extension module.");
293+
294+
#define _IMP_LOAD_DYNAMIC_METHODDEF \
295+
{"load_dynamic", (PyCFunction)_imp_load_dynamic, METH_VARARGS, _imp_load_dynamic__doc__},
296+
297+
static PyObject *
298+
_imp_load_dynamic_impl(PyModuleDef *module, PyObject *name, PyObject *path, PyObject *file);
299+
300+
static PyObject *
301+
_imp_load_dynamic(PyModuleDef *module, PyObject *args)
302+
{
303+
PyObject *return_value = NULL;
304+
PyObject *name;
305+
PyObject *path;
306+
PyObject *file = NULL;
307+
308+
if (!PyArg_ParseTuple(args,
309+
"UO&|O:load_dynamic",
310+
&name, PyUnicode_FSDecoder, &path, &file))
311+
goto exit;
312+
return_value = _imp_load_dynamic_impl(module, name, path, file);
313+
314+
exit:
315+
return return_value;
316+
}
317+
318+
#endif /* defined(HAVE_DYNAMIC_LOADING) */
319+
320+
#ifndef _IMP_LOAD_DYNAMIC_METHODDEF
321+
#define _IMP_LOAD_DYNAMIC_METHODDEF
322+
#endif /* !defined(_IMP_LOAD_DYNAMIC_METHODDEF) */
323+
/*[clinic end generated code: output=087a1f22e9febcc7 input=a9049054013a1b77]*/

0 commit comments

Comments
 (0)