cpython: 1f3242fb0c9c (original) (raw)

--- a/Misc/NEWS +++ b/Misc/NEWS @@ -25,6 +25,8 @@ Core and Builtins Library ------- +- Issue #20152: Ported Python/import.c over to Argument Clinic. +

Issue #13107: argparse and optparse no longer raises an exception when output a help on environment with too small COLUMNS. Based on patch by Elazar Gershuni.

--- a/Python/import.c +++ b/Python/import.c @@ -31,6 +31,19 @@ struct _inittab PyImport_Inittab = _PyI static PyObject initstr = NULL; +/[clinic input] +module _imp +[clinic start generated code]/ +/[clinic end generated code: checksum=da39a3ee5e6b4b0d3255bfef95601890afd80709]/ + +/*[python input] +class fs_unicode_converter(CConverter):

type = 'PyObject *'
converter = 'PyUnicode_FSDecoder'

+ +[python start generated code]/ +/[python end generated code: checksum=da39a3ee5e6b4b0d3255bfef95601890afd80709]/ + / Initialize things / void @@ -210,8 +223,39 @@ void #endif +/[clinic input] +imp.lock_held + +Return True if the import lock is currently held, else False. + +On platforms without threads, return False. +[clinic start generated code]*/ + +PyDoc_STRVAR(imp_lock_held__doc, +"lock_held()\n" +"Return True if the import lock is currently held, else False.\n" +"\n" +"On platforms without threads, return False."); + +#define _IMP_LOCK_HELD_METHODDEF [](#l2.41)

{"lock_held", (PyCFunction)imp_lock_held, METH_NOARGS, imp_lock_held__doc},

+ static PyObject * -imp_lock_held(PyObject *self, PyObject *noargs) +_imp_lock_held_impl(PyModuleDef *module); + +static PyObject * +_imp_lock_held(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) +{

PyObject *return_value = NULL;

return_value = _imp_lock_held_impl(module);

return return_value;

+} + +static PyObject +_imp_lock_held_impl(PyModuleDef module) +/[clinic end generated code: checksum=c5858b257881f94dee95526229a8d1a57ccff158]/ { #ifdef WITH_THREAD return PyBool_FromLong(import_lock_thread != -1); @@ -220,8 +264,41 @@ imp_lock_held(PyObject self, PyObject #endif } +/[clinic input] +_imp.acquire_lock + +Acquires the interpreter's import lock for the current thread. + +This lock should be used by import hooks to ensure thread-safety when importing +modules. On platforms without threads, this function does nothing. +[clinic start generated code]/ + +PyDoc_STRVAR(imp_acquire_lock__doc_, +"acquire_lock()\n" +"Acquires the interpreter's import lock for the current thread.\n" +"\n" +"This lock should be used by import hooks to ensure thread-safety when importing\n" +"modules. On platforms without threads, this function does nothing."); + +#define _IMP_ACQUIRE_LOCK_METHODDEF [](#l2.84)

{"acquire_lock", (PyCFunction)imp_acquire_lock, METH_NOARGS, imp_acquire_lock__doc},

+ static PyObject * -imp_acquire_lock(PyObject *self, PyObject *noargs) +_imp_acquire_lock_impl(PyModuleDef *module); + +static PyObject * +_imp_acquire_lock(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) +{

PyObject *return_value = NULL;

return_value = _imp_acquire_lock_impl(module);

return return_value;

+} + +static PyObject +_imp_acquire_lock_impl(PyModuleDef module) +/[clinic end generated code: checksum=badb56ed0079a6b902c9616fe068d572765b1863]/ { #ifdef WITH_THREAD _PyImport_AcquireLock(); @@ -230,8 +307,39 @@ imp_acquire_lock(PyObject self, PyObjec return Py_None; } +/[clinic input] +imp.release_lock + +Release the interpreter's import lock. + +On platforms without threads, this function does nothing. +[clinic start generated code]*/ + +PyDoc_STRVAR(imp_release_lock__doc, +"release_lock()\n" +"Release the interpreter's import lock.\n" +"\n" +"On platforms without threads, this function does nothing."); + +#define _IMP_RELEASE_LOCK_METHODDEF [](#l2.125)

{"release_lock", (PyCFunction)imp_release_lock, METH_NOARGS, imp_release_lock__doc},

+ static PyObject * -imp_release_lock(PyObject *self, PyObject *noargs) +_imp_release_lock_impl(PyModuleDef *module); + +static PyObject * +_imp_release_lock(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) +{

PyObject *return_value = NULL;

return_value = _imp_release_lock_impl(module);

return return_value;

+} + +static PyObject +_imp_release_lock_impl(PyModuleDef module) +/[clinic end generated code: checksum=f1c2a75e3136a113184e0af2a676d5f0b5b685b4]/ { #ifdef WITH_THREAD if (_PyImport_ReleaseLock() < 0) { @@ -817,28 +925,57 @@ update_compiled_module(PyCodeObject *co, Py_DECREF(oldname); } -static PyObject * -imp_fix_co_filename(PyObject *self, PyObject *args) -{

PyObject *co;
PyObject *file_path;

+/*[clinic input] +_imp._fix_co_filename +

code: object(type="PyCodeObject *", subclass_of="&PyCode_Type")
```
   Code object to change.[](#l2.161)
```

path: unicode
```
   File path to use.[](#l2.164)
```
/

if (!PyArg_ParseTuple(args, "OO:_fix_co_filename", &co, &file_path))
```
   return NULL;[](#l2.168)
```

+Changes code.co_filename to specify the passed-in file path. +[clinic start generated code]*/ + +PyDoc_STRVAR(imp__fix_co_filename__doc_, +"_fix_co_filename(code, path)\n" +"Changes code.co_filename to specify the passed-in file path.\n" +"\n" +" code\n" +" Code object to change.\n" +" path\n" +" File path to use."); + +#define _IMP__FIX_CO_FILENAME_METHODDEF [](#l2.181)

{"_fix_co_filename", (PyCFunction)imp__fix_co_filename, METH_VARARGS, imp__fix_co_filename__doc},

if (!PyCode_Check(co)) {

   PyErr_SetString(PyExc_TypeError,[](#l2.185)

                   "first argument must be a code object");[](#l2.186)

```
   return NULL;[](#l2.187)
```
}

+static PyObject * +_imp__fix_co_filename_impl(PyModuleDef *module, PyCodeObject *code, PyObject *path); + +static PyObject * +_imp__fix_co_filename(PyModuleDef *module, PyObject *args) +{

PyObject *return_value = NULL;
PyCodeObject *code;
PyObject *path;

if (!PyUnicode_Check(file_path)) {

   PyErr_SetString(PyExc_TypeError,[](#l2.200)

                   "second argument must be a string");[](#l2.201)

```
   return NULL;[](#l2.202)
```
}

if (!PyArg_ParseTuple(args,
```
   "O!U:_fix_co_filename",[](#l2.205)
```

   &PyCode_Type, &code, &path))[](#l2.206)

```
   goto exit;[](#l2.207)
```
return_value = _imp__fix_co_filename_impl(module, code, path);

update_compiled_module((PyCodeObject*)co, file_path);

+exit:

return return_value;

+} + +static PyObject * +_imp__fix_co_filename_impl(PyModuleDef *module, PyCodeObject code, PyObject path) +/[clinic end generated code: checksum=4f55bad308072b30ad1921068fc4ce85bd2b39bf]/ + +{

update_compiled_module((PyCodeObject*)code, path);

Py_RETURN_NONE; } @@ -1691,8 +1828,35 @@ PyImport_Import(PyObject module_name) return r; } +/[clinic input] +imp.extension_suffixes + +Returns the list of file suffixes used to identify extension modules. +[clinic start generated code]*/ + +PyDoc_STRVAR(imp_extension_suffixes__doc, +"extension_suffixes()\n" +"Returns the list of file suffixes used to identify extension modules."); + +#define _IMP_EXTENSION_SUFFIXES_METHODDEF [](#l2.238)

{"extension_suffixes", (PyCFunction)imp_extension_suffixes, METH_NOARGS, imp_extension_suffixes__doc},

+ static PyObject * -imp_extension_suffixes(PyObject *self, PyObject *noargs) +_imp_extension_suffixes_impl(PyModuleDef *module); + +static PyObject * +_imp_extension_suffixes(PyModuleDef *module, PyObject *Py_UNUSED(ignored)) +{

PyObject *return_value = NULL;

return_value = _imp_extension_suffixes_impl(module);

return return_value;

+} + +static PyObject +_imp_extension_suffixes_impl(PyModuleDef module) +/[clinic end generated code: checksum=835921e67fd698e22e101eea64839d1ad62b6451]/ { PyObject *list; const char *suffix; @@ -1720,14 +1884,48 @@ imp_extension_suffixes(PyObject self, P return list; } +/[clinic input] +_imp.init_builtin +

name: unicode
/

+ +Initializes a built-in module. +[clinic start generated code]*/ + +PyDoc_STRVAR(imp_init_builtin__doc_, +"init_builtin(name)\n" +"Initializes a built-in module."); + +#define _IMP_INIT_BUILTIN_METHODDEF [](#l2.278)

{"init_builtin", (PyCFunction)imp_init_builtin, METH_VARARGS, imp_init_builtin__doc},

+ static PyObject * -imp_init_builtin(PyObject *self, PyObject *args) +_imp_init_builtin_impl(PyModuleDef *module, PyObject *name); + +static PyObject * +_imp_init_builtin(PyModuleDef *module, PyObject *args) {

PyObject *return_value = NULL; PyObject *name; +
if (!PyArg_ParseTuple(args,
```
   "U:init_builtin",[](#l2.292)
```
```
   &name))[](#l2.293)
```
```
   goto exit;[](#l2.294)
```
return_value = _imp_init_builtin_impl(module, name);

+ +exit:

return return_value;

+} + +static PyObject * +_imp_init_builtin_impl(PyModuleDef module, PyObject name) +/[clinic end generated code: checksum=59239206e5b2fb59358066e72fd0e72e55a7baf5]/ +{ int ret; PyObject *m;

if (!PyArg_ParseTuple(args, "U:init_builtin", &name))
```
   return NULL;[](#l2.308)
```

+ ret = init_builtin(name); if (ret < 0) return NULL; @@ -1740,14 +1938,48 @@ imp_init_builtin(PyObject self, PyObjec return m; } +/[clinic input] +_imp.init_frozen +

name: unicode
/

+ +Initializes a frozen module. +[clinic start generated code]*/ + +PyDoc_STRVAR(imp_init_frozen__doc_, +"init_frozen(name)\n" +"Initializes a frozen module."); + +#define _IMP_INIT_FROZEN_METHODDEF [](#l2.330)

{"init_frozen", (PyCFunction)imp_init_frozen, METH_VARARGS, imp_init_frozen__doc},

+ static PyObject * -imp_init_frozen(PyObject *self, PyObject *args) +_imp_init_frozen_impl(PyModuleDef *module, PyObject *name); + +static PyObject * +_imp_init_frozen(PyModuleDef *module, PyObject *args) {

PyObject *return_value = NULL; PyObject *name; +
if (!PyArg_ParseTuple(args,
```
   "U:init_frozen",[](#l2.344)
```
```
   &name))[](#l2.345)
```
```
   goto exit;[](#l2.346)
```
return_value = _imp_init_frozen_impl(module, name);

+ +exit:

return return_value;

+} + +static PyObject * +_imp_init_frozen_impl(PyModuleDef module, PyObject name) +/[clinic end generated code: checksum=503fcc3de9961263e4d9484259af357a7d287a0b]/ +{ int ret; PyObject *m;

if (!PyArg_ParseTuple(args, "U:init_frozen", &name))
```
   return NULL;[](#l2.360)
```

+ ret = PyImport_ImportFrozenModuleObject(name); if (ret < 0) return NULL; @@ -1760,61 +1992,229 @@ imp_init_frozen(PyObject self, PyObject return m; } +/[clinic input] +_imp.get_frozen_object +

name: unicode
/

+ +Create a code object for a frozen module. +[clinic start generated code]*/ + +PyDoc_STRVAR(imp_get_frozen_object__doc_, +"get_frozen_object(name)\n" +"Create a code object for a frozen module."); + +#define _IMP_GET_FROZEN_OBJECT_METHODDEF [](#l2.382)

{"get_frozen_object", (PyCFunction)imp_get_frozen_object, METH_VARARGS, imp_get_frozen_object__doc},

+ static PyObject * -imp_get_frozen_object(PyObject *self, PyObject *args) +_imp_get_frozen_object_impl(PyModuleDef *module, PyObject *name); + +static PyObject * +_imp_get_frozen_object(PyModuleDef *module, PyObject *args) {

PyObject *return_value = NULL; PyObject *name;

if (!PyArg_ParseTuple(args, "U:get_frozen_object", &name))
```
   return NULL;[](#l2.396)
```

if (!PyArg_ParseTuple(args,
```
   "U:get_frozen_object",[](#l2.398)
```
```
   &name))[](#l2.399)
```
```
   goto exit;[](#l2.400)
```
return_value = _imp_get_frozen_object_impl(module, name);

+ +exit:

return return_value;

+} + +static PyObject +_imp_get_frozen_object_impl(PyModuleDef module, PyObject name) +/[clinic end generated code: checksum=7a6423a4daf139496b9a394ff3ac6130089d1cba]/ +{ return get_frozen_object(name); } +/[clinic input] +_imp.is_frozen_package +

name: unicode
/

+ +Returns True if the module name is of a frozen package. +[clinic start generated code]*/ + +PyDoc_STRVAR(imp_is_frozen_package__doc_, +"is_frozen_package(name)\n" +"Returns True if the module name is of a frozen package."); + +#define _IMP_IS_FROZEN_PACKAGE_METHODDEF [](#l2.427)

{"is_frozen_package", (PyCFunction)imp_is_frozen_package, METH_VARARGS, imp_is_frozen_package__doc},

+ +static PyObject * +_imp_is_frozen_package_impl(PyModuleDef *module, PyObject *name); + +static PyObject * +_imp_is_frozen_package(PyModuleDef *module, PyObject *args) +{

PyObject *return_value = NULL;
PyObject *name;

if (!PyArg_ParseTuple(args,
```
   "U:is_frozen_package",[](#l2.440)
```
```
   &name))[](#l2.441)
```
```
   goto exit;[](#l2.442)
```
return_value = _imp_is_frozen_package_impl(module, name);

+ +exit:

return return_value;

+} + static PyObject * -imp_is_frozen_package(PyObject *self, PyObject *args) +_imp_is_frozen_package_impl(PyModuleDef module, PyObject name) +/[clinic end generated code: checksum=dc7e361ea30b6945b8bbe7266d7b9a5ea433b510]/ {

return is_frozen_package(name);

+} + +/*[clinic input] +_imp.is_builtin +

name: unicode
/

+ +Returns True if the module name corresponds to a built-in module. +[clinic start generated code]*/ + +PyDoc_STRVAR(imp_is_builtin__doc_, +"is_builtin(name)\n" +"Returns True if the module name corresponds to a built-in module."); + +#define _IMP_IS_BUILTIN_METHODDEF [](#l2.470)

{"is_builtin", (PyCFunction)imp_is_builtin, METH_VARARGS, imp_is_builtin__doc},

+ +static PyObject * +_imp_is_builtin_impl(PyModuleDef *module, PyObject *name); + +static PyObject * +_imp_is_builtin(PyModuleDef *module, PyObject *args) +{

PyObject *return_value = NULL; PyObject *name;

if (!PyArg_ParseTuple(args, "U:is_frozen_package", &name))
```
   return NULL;[](#l2.483)
```
return is_frozen_package(name);

if (!PyArg_ParseTuple(args,
```
   "U:is_builtin",[](#l2.486)
```
```
   &name))[](#l2.487)
```
```
   goto exit;[](#l2.488)
```
return_value = _imp_is_builtin_impl(module, name);

+ +exit:

return return_value;

} static PyObject * -imp_is_builtin(PyObject *self, PyObject *args) +_imp_is_builtin_impl(PyModuleDef module, PyObject name) +/[clinic end generated code: checksum=353938c1d55210a1e3850d3ccba7539d02165cac]/ {

PyObject *name;
if (!PyArg_ParseTuple(args, "U:is_builtin", &name))
```
   return NULL;[](#l2.502)
```
return PyLong_FromLong(is_builtin(name)); } +/*[clinic input] +_imp.is_frozen +

name: unicode
/

+ +Returns True if the module name corresponds to a frozen module. +[clinic start generated code]*/ + +PyDoc_STRVAR(imp_is_frozen__doc_, +"is_frozen(name)\n" +"Returns True if the module name corresponds to a frozen module."); + +#define _IMP_IS_FROZEN_METHODDEF [](#l2.519)

{"is_frozen", (PyCFunction)imp_is_frozen, METH_VARARGS, imp_is_frozen__doc},

+ static PyObject * -imp_is_frozen(PyObject *self, PyObject *args) +_imp_is_frozen_impl(PyModuleDef *module, PyObject *name); + +static PyObject * +_imp_is_frozen(PyModuleDef *module, PyObject *args) {

PyObject *return_value = NULL; PyObject *name; +
if (!PyArg_ParseTuple(args,
```
   "U:is_frozen",[](#l2.533)
```
```
   &name))[](#l2.534)
```
```
   goto exit;[](#l2.535)
```
return_value = _imp_is_frozen_impl(module, name);

+ +exit:

return return_value;

+} + +static PyObject * +_imp_is_frozen_impl(PyModuleDef module, PyObject name) +/[clinic end generated code: checksum=978b547ddcb76fa6c4a181ad53569c9acf382c7b]/ +{ const struct _frozen *p;

if (!PyArg_ParseTuple(args, "U:is_frozen", &name))
```
   return NULL;[](#l2.548)
```

+ p = find_frozen(name); return PyBool_FromLong((long) (p == NULL ? 0 : p->size)); } #ifdef HAVE_DYNAMIC_LOADING +/*[clinic input] +_imp.load_dynamic +

name: unicode
path: fs_unicode
file: object = NULL
/

+ +Loads an extension module. +[clinic start generated code]*/ + +PyDoc_STRVAR(imp_load_dynamic__doc_, +"load_dynamic(name, path, file=None)\n" +"Loads an extension module."); + +#define _IMP_LOAD_DYNAMIC_METHODDEF [](#l2.571)

{"load_dynamic", (PyCFunction)imp_load_dynamic, METH_VARARGS, imp_load_dynamic__doc},

+ static PyObject * -imp_load_dynamic(PyObject *self, PyObject *args) +_imp_load_dynamic_impl(PyModuleDef *module, PyObject *name, PyObject *path, PyObject *file); + +static PyObject * +_imp_load_dynamic(PyModuleDef *module, PyObject *args) {

PyObject *name, *pathname, *fob = NULL, *mod;

PyObject *return_value = NULL;
PyObject *name;
PyObject *path;
PyObject *file = NULL;

if (!PyArg_ParseTuple(args,
```
   "UO&|O:load_dynamic",[](#l2.588)
```

   &name, PyUnicode_FSDecoder, &path, &file))[](#l2.589)

```
   goto exit;[](#l2.590)
```
return_value = _imp_load_dynamic_impl(module, name, path, file);

+ +exit:

return return_value;

+} + +static PyObject * +_imp_load_dynamic_impl(PyModuleDef *module, PyObject *name, PyObject path, PyObject file) +/[clinic end generated code: checksum=6795f65d9ce003ccaf08e4e8eef484dc52e262d0]/ +{

PyObject *mod; FILE *fp;

if (!PyArg_ParseTuple(args, "UO&|O:load_dynamic",

                     &name, PyUnicode_FSDecoder, &pathname, &fob))[](#l2.605)

```
   return NULL;[](#l2.606)
```
if (fob != NULL) {

   fp = _Py_fopen_obj(pathname, "r");[](#l2.608)

if (file != NULL) {

   fp = _Py_fopen_obj(path, "r");[](#l2.610)
   if (fp == NULL) {[](#l2.611)

```
       Py_DECREF(pathname);[](#l2.612)
```

       Py_DECREF(path);[](#l2.613)
       if (!PyErr_Occurred())[](#l2.614)
           PyErr_SetFromErrno(PyExc_IOError);[](#l2.615)
       return NULL;[](#l2.616)

@@ -1822,8 +2222,8 @@ imp_load_dynamic(PyObject *self, PyObjec } else fp = NULL;

mod = _PyImport_LoadDynamicModule(name, pathname, fp);
Py_DECREF(pathname);

mod = _PyImport_LoadDynamicModule(name, path, fp);
Py_DECREF(path); if (fp) fclose(fp); return mod; @@ -1832,49 +2232,25 @@ imp_load_dynamic(PyObject *self, PyObjec

#endif /* HAVE_DYNAMIC_LOADING / -/ Doc strings */ - PyDoc_STRVAR(doc_imp, "(Extremely) low-level import machinery bits as used by importlib and imp."); -PyDoc_STRVAR(doc_extension_suffixes, -"extension_suffixes() -> list of strings\n[](#l2.638) -Returns the list of file suffixes used to identify extension modules."); - -PyDoc_STRVAR(doc_lock_held, -"lock_held() -> boolean\n[](#l2.642) -Return True if the import lock is currently held, else False.\n[](#l2.643) -On platforms without threads, return False."); - -PyDoc_STRVAR(doc_acquire_lock, -"acquire_lock() -> None\n[](#l2.647) -Acquires the interpreter's import lock for the current thread.\n[](#l2.648) -This lock should be used by import hooks to ensure thread-safety\n[](#l2.649) -when importing modules.\n[](#l2.650) -On platforms without threads, this function does nothing."); - -PyDoc_STRVAR(doc_release_lock, -"release_lock() -> None\n[](#l2.654) -Release the interpreter's import lock.\n[](#l2.655) -On platforms without threads, this function does nothing."); - static PyMethodDef imp_methods[] = {

{"extension_suffixes", imp_extension_suffixes, METH_NOARGS,
```
   doc_extension_suffixes},[](#l2.660)
```
{"lock_held", imp_lock_held, METH_NOARGS, doc_lock_held},
{"acquire_lock", imp_acquire_lock, METH_NOARGS, doc_acquire_lock},
{"release_lock", imp_release_lock, METH_NOARGS, doc_release_lock},
{"get_frozen_object", imp_get_frozen_object, METH_VARARGS},
{"is_frozen_package", imp_is_frozen_package, METH_VARARGS},
{"init_builtin", imp_init_builtin, METH_VARARGS},
{"init_frozen", imp_init_frozen, METH_VARARGS},
{"is_builtin", imp_is_builtin, METH_VARARGS},
{"is_frozen", imp_is_frozen, METH_VARARGS},

_IMP_EXTENSION_SUFFIXES_METHODDEF
_IMP_LOCK_HELD_METHODDEF
_IMP_ACQUIRE_LOCK_METHODDEF
_IMP_RELEASE_LOCK_METHODDEF
_IMP_GET_FROZEN_OBJECT_METHODDEF
_IMP_IS_FROZEN_PACKAGE_METHODDEF
_IMP_INIT_BUILTIN_METHODDEF
_IMP_INIT_FROZEN_METHODDEF
_IMP_IS_BUILTIN_METHODDEF
_IMP_IS_FROZEN_METHODDEF

#ifdef HAVE_DYNAMIC_LOADING

{"load_dynamic", imp_load_dynamic, METH_VARARGS},

_IMP_LOAD_DYNAMIC_METHODDEF

#endif

{"_fix_co_filename", imp_fix_co_filename, METH_VARARGS},
{NULL, NULL} /* sentinel */

_IMP__FIX_CO_FILENAME_METHODDEF
{NULL, NULL} /* sentinel */

};