summaryrefslogtreecommitdiffstats
path: root/PC/clinic/winreg.c.h
diff options
context:
space:
mode:
Diffstat (limited to 'PC/clinic/winreg.c.h')
-rw-r--r--PC/clinic/winreg.c.h1078
1 files changed, 1078 insertions, 0 deletions
diff --git a/PC/clinic/winreg.c.h b/PC/clinic/winreg.c.h
new file mode 100644
index 0000000..6aff424b8
--- /dev/null
+++ b/PC/clinic/winreg.c.h
@@ -0,0 +1,1078 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(winreg_HKEYType_Close__doc__,
+"Close($self, /)\n"
+"--\n"
+"\n"
+"Closes the underlying Windows handle.\n"
+"\n"
+"If the handle is already closed, no error is raised.");
+
+#define WINREG_HKEYTYPE_CLOSE_METHODDEF \
+ {"Close", (PyCFunction)winreg_HKEYType_Close, METH_NOARGS, winreg_HKEYType_Close__doc__},
+
+static PyObject *
+winreg_HKEYType_Close_impl(PyHKEYObject *self);
+
+static PyObject *
+winreg_HKEYType_Close(PyHKEYObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return winreg_HKEYType_Close_impl(self);
+}
+
+PyDoc_STRVAR(winreg_HKEYType_Detach__doc__,
+"Detach($self, /)\n"
+"--\n"
+"\n"
+"Detaches the Windows handle from the handle object.\n"
+"\n"
+"The result is the value of the handle before it is detached. If the\n"
+"handle is already detached, this will return zero.\n"
+"\n"
+"After calling this function, the handle is effectively invalidated,\n"
+"but the handle is not closed. You would call this function when you\n"
+"need the underlying win32 handle to exist beyond the lifetime of the\n"
+"handle object.");
+
+#define WINREG_HKEYTYPE_DETACH_METHODDEF \
+ {"Detach", (PyCFunction)winreg_HKEYType_Detach, METH_NOARGS, winreg_HKEYType_Detach__doc__},
+
+static PyObject *
+winreg_HKEYType_Detach_impl(PyHKEYObject *self);
+
+static PyObject *
+winreg_HKEYType_Detach(PyHKEYObject *self, PyObject *Py_UNUSED(ignored))
+{
+ return winreg_HKEYType_Detach_impl(self);
+}
+
+PyDoc_STRVAR(winreg_HKEYType___enter____doc__,
+"__enter__($self, /)\n"
+"--\n"
+"\n");
+
+#define WINREG_HKEYTYPE___ENTER___METHODDEF \
+ {"__enter__", (PyCFunction)winreg_HKEYType___enter__, METH_NOARGS, winreg_HKEYType___enter____doc__},
+
+static PyHKEYObject *
+winreg_HKEYType___enter___impl(PyHKEYObject *self);
+
+static PyObject *
+winreg_HKEYType___enter__(PyHKEYObject *self, PyObject *Py_UNUSED(ignored))
+{
+ PyObject *return_value = NULL;
+ PyHKEYObject *_return_value;
+
+ _return_value = winreg_HKEYType___enter___impl(self);
+ return_value = (PyObject *)_return_value;
+
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_HKEYType___exit____doc__,
+"__exit__($self, /, exc_type, exc_value, traceback)\n"
+"--\n"
+"\n");
+
+#define WINREG_HKEYTYPE___EXIT___METHODDEF \
+ {"__exit__", (PyCFunction)winreg_HKEYType___exit__, METH_VARARGS|METH_KEYWORDS, winreg_HKEYType___exit____doc__},
+
+static PyObject *
+winreg_HKEYType___exit___impl(PyHKEYObject *self, PyObject *exc_type, PyObject *exc_value, PyObject *traceback);
+
+static PyObject *
+winreg_HKEYType___exit__(PyHKEYObject *self, PyObject *args, PyObject *kwargs)
+{
+ PyObject *return_value = NULL;
+ static char *_keywords[] = {"exc_type", "exc_value", "traceback", NULL};
+ PyObject *exc_type;
+ PyObject *exc_value;
+ PyObject *traceback;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+ "OOO:__exit__", _keywords,
+ &exc_type, &exc_value, &traceback))
+ goto exit;
+ return_value = winreg_HKEYType___exit___impl(self, exc_type, exc_value, traceback);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_CloseKey__doc__,
+"CloseKey($module, hkey, /)\n"
+"--\n"
+"\n"
+"Closes a previously opened registry key.\n"
+"\n"
+" hkey\n"
+" A previously opened key.\n"
+"\n"
+"Note that if the key is not closed using this method, it will be\n"
+"closed when the hkey object is destroyed by Python.");
+
+#define WINREG_CLOSEKEY_METHODDEF \
+ {"CloseKey", (PyCFunction)winreg_CloseKey, METH_O, winreg_CloseKey__doc__},
+
+PyDoc_STRVAR(winreg_ConnectRegistry__doc__,
+"ConnectRegistry($module, computer_name, key, /)\n"
+"--\n"
+"\n"
+"Establishes a connection to the registry on on another computer.\n"
+"\n"
+" computer_name\n"
+" The name of the remote computer, of the form r\"\\\\computername\". If\n"
+" None, the local computer is used.\n"
+" key\n"
+" The predefined key to connect to.\n"
+"\n"
+"The return value is the handle of the opened key.\n"
+"If the function fails, an OSError exception is raised.");
+
+#define WINREG_CONNECTREGISTRY_METHODDEF \
+ {"ConnectRegistry", (PyCFunction)winreg_ConnectRegistry, METH_VARARGS, winreg_ConnectRegistry__doc__},
+
+static HKEY
+winreg_ConnectRegistry_impl(PyModuleDef *module, Py_UNICODE *computer_name, HKEY key);
+
+static PyObject *
+winreg_ConnectRegistry(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ Py_UNICODE *computer_name;
+ HKEY key;
+ HKEY _return_value;
+
+ if (!PyArg_ParseTuple(args,
+ "ZO&:ConnectRegistry",
+ &computer_name, clinic_HKEY_converter, &key))
+ goto exit;
+ _return_value = winreg_ConnectRegistry_impl(module, computer_name, key);
+ if (_return_value == NULL)
+ goto exit;
+ return_value = PyHKEY_FromHKEY(_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_CreateKey__doc__,
+"CreateKey($module, key, sub_key, /)\n"
+"--\n"
+"\n"
+"Creates or opens the specified key.\n"
+"\n"
+" key\n"
+" An already open key, or one of the predefined HKEY_* constants.\n"
+" sub_key\n"
+" The name of the key this method opens or creates.\n"
+"\n"
+"If key is one of the predefined keys, sub_key may be None. In that case,\n"
+"the handle returned is the same key handle passed in to the function.\n"
+"\n"
+"If the key already exists, this function opens the existing key.\n"
+"\n"
+"The return value is the handle of the opened key.\n"
+"If the function fails, an OSError exception is raised.");
+
+#define WINREG_CREATEKEY_METHODDEF \
+ {"CreateKey", (PyCFunction)winreg_CreateKey, METH_VARARGS, winreg_CreateKey__doc__},
+
+static HKEY
+winreg_CreateKey_impl(PyModuleDef *module, HKEY key, Py_UNICODE *sub_key);
+
+static PyObject *
+winreg_CreateKey(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+ Py_UNICODE *sub_key;
+ HKEY _return_value;
+
+ if (!PyArg_ParseTuple(args,
+ "O&Z:CreateKey",
+ clinic_HKEY_converter, &key, &sub_key))
+ goto exit;
+ _return_value = winreg_CreateKey_impl(module, key, sub_key);
+ if (_return_value == NULL)
+ goto exit;
+ return_value = PyHKEY_FromHKEY(_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_CreateKeyEx__doc__,
+"CreateKeyEx($module, /, key, sub_key, reserved=0,\n"
+" access=winreg.KEY_WRITE)\n"
+"--\n"
+"\n"
+"Creates or opens the specified key.\n"
+"\n"
+" key\n"
+" An already open key, or one of the predefined HKEY_* constants.\n"
+" sub_key\n"
+" The name of the key this method opens or creates.\n"
+" reserved\n"
+" A reserved integer, and must be zero. Default is zero.\n"
+" access\n"
+" An integer that specifies an access mask that describes the\n"
+" desired security access for the key. Default is KEY_WRITE.\n"
+"\n"
+"If key is one of the predefined keys, sub_key may be None. In that case,\n"
+"the handle returned is the same key handle passed in to the function.\n"
+"\n"
+"If the key already exists, this function opens the existing key\n"
+"\n"
+"The return value is the handle of the opened key.\n"
+"If the function fails, an OSError exception is raised.");
+
+#define WINREG_CREATEKEYEX_METHODDEF \
+ {"CreateKeyEx", (PyCFunction)winreg_CreateKeyEx, METH_VARARGS|METH_KEYWORDS, winreg_CreateKeyEx__doc__},
+
+static HKEY
+winreg_CreateKeyEx_impl(PyModuleDef *module, HKEY key, Py_UNICODE *sub_key, int reserved, REGSAM access);
+
+static PyObject *
+winreg_CreateKeyEx(PyModuleDef *module, PyObject *args, PyObject *kwargs)
+{
+ PyObject *return_value = NULL;
+ static char *_keywords[] = {"key", "sub_key", "reserved", "access", NULL};
+ HKEY key;
+ Py_UNICODE *sub_key;
+ int reserved = 0;
+ REGSAM access = KEY_WRITE;
+ HKEY _return_value;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+ "O&Z|ii:CreateKeyEx", _keywords,
+ clinic_HKEY_converter, &key, &sub_key, &reserved, &access))
+ goto exit;
+ _return_value = winreg_CreateKeyEx_impl(module, key, sub_key, reserved, access);
+ if (_return_value == NULL)
+ goto exit;
+ return_value = PyHKEY_FromHKEY(_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_DeleteKey__doc__,
+"DeleteKey($module, key, sub_key, /)\n"
+"--\n"
+"\n"
+"Deletes the specified key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" sub_key\n"
+" A string that must be the name of a subkey of the key identified by\n"
+" the key parameter. This value must not be None, and the key may not\n"
+" have subkeys.\n"
+"\n"
+"This method can not delete keys with subkeys.\n"
+"\n"
+"If the function succeeds, the entire key, including all of its values,\n"
+"is removed. If the function fails, an OSError exception is raised.");
+
+#define WINREG_DELETEKEY_METHODDEF \
+ {"DeleteKey", (PyCFunction)winreg_DeleteKey, METH_VARARGS, winreg_DeleteKey__doc__},
+
+static PyObject *
+winreg_DeleteKey_impl(PyModuleDef *module, HKEY key, Py_UNICODE *sub_key);
+
+static PyObject *
+winreg_DeleteKey(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+ Py_UNICODE *sub_key;
+
+ if (!PyArg_ParseTuple(args,
+ "O&u:DeleteKey",
+ clinic_HKEY_converter, &key, &sub_key))
+ goto exit;
+ return_value = winreg_DeleteKey_impl(module, key, sub_key);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_DeleteKeyEx__doc__,
+"DeleteKeyEx($module, /, key, sub_key, access=winreg.KEY_WOW64_64KEY,\n"
+" reserved=0)\n"
+"--\n"
+"\n"
+"Deletes the specified key (64-bit OS only).\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" sub_key\n"
+" A string that must be the name of a subkey of the key identified by\n"
+" the key parameter. This value must not be None, and the key may not\n"
+" have subkeys.\n"
+" access\n"
+" An integer that specifies an access mask that describes the\n"
+" desired security access for the key. Default is KEY_WOW64_64KEY.\n"
+" reserved\n"
+" A reserved integer, and must be zero. Default is zero.\n"
+"\n"
+"This method can not delete keys with subkeys.\n"
+"\n"
+"If the function succeeds, the entire key, including all of its values,\n"
+"is removed. If the function fails, an OSError exception is raised.\n"
+"On unsupported Windows versions, NotImplementedError is raised.");
+
+#define WINREG_DELETEKEYEX_METHODDEF \
+ {"DeleteKeyEx", (PyCFunction)winreg_DeleteKeyEx, METH_VARARGS|METH_KEYWORDS, winreg_DeleteKeyEx__doc__},
+
+static PyObject *
+winreg_DeleteKeyEx_impl(PyModuleDef *module, HKEY key, Py_UNICODE *sub_key, REGSAM access, int reserved);
+
+static PyObject *
+winreg_DeleteKeyEx(PyModuleDef *module, PyObject *args, PyObject *kwargs)
+{
+ PyObject *return_value = NULL;
+ static char *_keywords[] = {"key", "sub_key", "access", "reserved", NULL};
+ HKEY key;
+ Py_UNICODE *sub_key;
+ REGSAM access = KEY_WOW64_64KEY;
+ int reserved = 0;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+ "O&u|ii:DeleteKeyEx", _keywords,
+ clinic_HKEY_converter, &key, &sub_key, &access, &reserved))
+ goto exit;
+ return_value = winreg_DeleteKeyEx_impl(module, key, sub_key, access, reserved);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_DeleteValue__doc__,
+"DeleteValue($module, key, value, /)\n"
+"--\n"
+"\n"
+"Removes a named value from a registry key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" value\n"
+" A string that identifies the value to remove.");
+
+#define WINREG_DELETEVALUE_METHODDEF \
+ {"DeleteValue", (PyCFunction)winreg_DeleteValue, METH_VARARGS, winreg_DeleteValue__doc__},
+
+static PyObject *
+winreg_DeleteValue_impl(PyModuleDef *module, HKEY key, Py_UNICODE *value);
+
+static PyObject *
+winreg_DeleteValue(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+ Py_UNICODE *value;
+
+ if (!PyArg_ParseTuple(args,
+ "O&Z:DeleteValue",
+ clinic_HKEY_converter, &key, &value))
+ goto exit;
+ return_value = winreg_DeleteValue_impl(module, key, value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_EnumKey__doc__,
+"EnumKey($module, key, index, /)\n"
+"--\n"
+"\n"
+"Enumerates subkeys of an open registry key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" index\n"
+" An integer that identifies the index of the key to retrieve.\n"
+"\n"
+"The function retrieves the name of one subkey each time it is called.\n"
+"It is typically called repeatedly until an OSError exception is\n"
+"raised, indicating no more values are available.");
+
+#define WINREG_ENUMKEY_METHODDEF \
+ {"EnumKey", (PyCFunction)winreg_EnumKey, METH_VARARGS, winreg_EnumKey__doc__},
+
+static PyObject *
+winreg_EnumKey_impl(PyModuleDef *module, HKEY key, int index);
+
+static PyObject *
+winreg_EnumKey(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+ int index;
+
+ if (!PyArg_ParseTuple(args,
+ "O&i:EnumKey",
+ clinic_HKEY_converter, &key, &index))
+ goto exit;
+ return_value = winreg_EnumKey_impl(module, key, index);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_EnumValue__doc__,
+"EnumValue($module, key, index, /)\n"
+"--\n"
+"\n"
+"Enumerates values of an open registry key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" index\n"
+" An integer that identifies the index of the value to retrieve.\n"
+"\n"
+"The function retrieves the name of one subkey each time it is called.\n"
+"It is typically called repeatedly, until an OSError exception\n"
+"is raised, indicating no more values.\n"
+"\n"
+"The result is a tuple of 3 items:\n"
+" value_name\n"
+" A string that identifies the value.\n"
+" value_data\n"
+" An object that holds the value data, and whose type depends\n"
+" on the underlying registry type.\n"
+" data_type\n"
+" An integer that identifies the type of the value data.");
+
+#define WINREG_ENUMVALUE_METHODDEF \
+ {"EnumValue", (PyCFunction)winreg_EnumValue, METH_VARARGS, winreg_EnumValue__doc__},
+
+static PyObject *
+winreg_EnumValue_impl(PyModuleDef *module, HKEY key, int index);
+
+static PyObject *
+winreg_EnumValue(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+ int index;
+
+ if (!PyArg_ParseTuple(args,
+ "O&i:EnumValue",
+ clinic_HKEY_converter, &key, &index))
+ goto exit;
+ return_value = winreg_EnumValue_impl(module, key, index);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_ExpandEnvironmentStrings__doc__,
+"ExpandEnvironmentStrings($module, string, /)\n"
+"--\n"
+"\n"
+"Expand environment vars.");
+
+#define WINREG_EXPANDENVIRONMENTSTRINGS_METHODDEF \
+ {"ExpandEnvironmentStrings", (PyCFunction)winreg_ExpandEnvironmentStrings, METH_O, winreg_ExpandEnvironmentStrings__doc__},
+
+static PyObject *
+winreg_ExpandEnvironmentStrings_impl(PyModuleDef *module, Py_UNICODE *string);
+
+static PyObject *
+winreg_ExpandEnvironmentStrings(PyModuleDef *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ Py_UNICODE *string;
+
+ if (!PyArg_Parse(arg,
+ "u:ExpandEnvironmentStrings",
+ &string))
+ goto exit;
+ return_value = winreg_ExpandEnvironmentStrings_impl(module, string);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_FlushKey__doc__,
+"FlushKey($module, key, /)\n"
+"--\n"
+"\n"
+"Writes all the attributes of a key to the registry.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+"\n"
+"It is not necessary to call FlushKey to change a key. Registry changes\n"
+"are flushed to disk by the registry using its lazy flusher. Registry\n"
+"changes are also flushed to disk at system shutdown. Unlike\n"
+"CloseKey(), the FlushKey() method returns only when all the data has\n"
+"been written to the registry.\n"
+"\n"
+"An application should only call FlushKey() if it requires absolute\n"
+"certainty that registry changes are on disk. If you don\'t know whether\n"
+"a FlushKey() call is required, it probably isn\'t.");
+
+#define WINREG_FLUSHKEY_METHODDEF \
+ {"FlushKey", (PyCFunction)winreg_FlushKey, METH_O, winreg_FlushKey__doc__},
+
+static PyObject *
+winreg_FlushKey_impl(PyModuleDef *module, HKEY key);
+
+static PyObject *
+winreg_FlushKey(PyModuleDef *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+
+ if (!PyArg_Parse(arg,
+ "O&:FlushKey",
+ clinic_HKEY_converter, &key))
+ goto exit;
+ return_value = winreg_FlushKey_impl(module, key);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_LoadKey__doc__,
+"LoadKey($module, key, sub_key, file_name, /)\n"
+"--\n"
+"\n"
+"Insert data into the registry from a file.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" sub_key\n"
+" A string that identifies the sub-key to load.\n"
+" file_name\n"
+" The name of the file to load registry data from. This file must\n"
+" have been created with the SaveKey() function. Under the file\n"
+" allocation table (FAT) file system, the filename may not have an\n"
+" extension.\n"
+"\n"
+"Creates a subkey under the specified key and stores registration\n"
+"information from a specified file into that subkey.\n"
+"\n"
+"A call to LoadKey() fails if the calling process does not have the\n"
+"SE_RESTORE_PRIVILEGE privilege.\n"
+"\n"
+"If key is a handle returned by ConnectRegistry(), then the path\n"
+"specified in fileName is relative to the remote computer.\n"
+"\n"
+"The MSDN docs imply key must be in the HKEY_USER or HKEY_LOCAL_MACHINE\n"
+"tree.");
+
+#define WINREG_LOADKEY_METHODDEF \
+ {"LoadKey", (PyCFunction)winreg_LoadKey, METH_VARARGS, winreg_LoadKey__doc__},
+
+static PyObject *
+winreg_LoadKey_impl(PyModuleDef *module, HKEY key, Py_UNICODE *sub_key, Py_UNICODE *file_name);
+
+static PyObject *
+winreg_LoadKey(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+ Py_UNICODE *sub_key;
+ Py_UNICODE *file_name;
+
+ if (!PyArg_ParseTuple(args,
+ "O&uu:LoadKey",
+ clinic_HKEY_converter, &key, &sub_key, &file_name))
+ goto exit;
+ return_value = winreg_LoadKey_impl(module, key, sub_key, file_name);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_OpenKey__doc__,
+"OpenKey($module, /, key, sub_key, reserved=0, access=winreg.KEY_READ)\n"
+"--\n"
+"\n"
+"Opens the specified key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" sub_key\n"
+" A string that identifies the sub_key to open.\n"
+" reserved\n"
+" A reserved integer that must be zero. Default is zero.\n"
+" access\n"
+" An integer that specifies an access mask that describes the desired\n"
+" security access for the key. Default is KEY_READ.\n"
+"\n"
+"The result is a new handle to the specified key.\n"
+"If the function fails, an OSError exception is raised.");
+
+#define WINREG_OPENKEY_METHODDEF \
+ {"OpenKey", (PyCFunction)winreg_OpenKey, METH_VARARGS|METH_KEYWORDS, winreg_OpenKey__doc__},
+
+static HKEY
+winreg_OpenKey_impl(PyModuleDef *module, HKEY key, Py_UNICODE *sub_key, int reserved, REGSAM access);
+
+static PyObject *
+winreg_OpenKey(PyModuleDef *module, PyObject *args, PyObject *kwargs)
+{
+ PyObject *return_value = NULL;
+ static char *_keywords[] = {"key", "sub_key", "reserved", "access", NULL};
+ HKEY key;
+ Py_UNICODE *sub_key;
+ int reserved = 0;
+ REGSAM access = KEY_READ;
+ HKEY _return_value;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+ "O&Z|ii:OpenKey", _keywords,
+ clinic_HKEY_converter, &key, &sub_key, &reserved, &access))
+ goto exit;
+ _return_value = winreg_OpenKey_impl(module, key, sub_key, reserved, access);
+ if (_return_value == NULL)
+ goto exit;
+ return_value = PyHKEY_FromHKEY(_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_OpenKeyEx__doc__,
+"OpenKeyEx($module, /, key, sub_key, reserved=0, access=winreg.KEY_READ)\n"
+"--\n"
+"\n"
+"Opens the specified key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" sub_key\n"
+" A string that identifies the sub_key to open.\n"
+" reserved\n"
+" A reserved integer that must be zero. Default is zero.\n"
+" access\n"
+" An integer that specifies an access mask that describes the desired\n"
+" security access for the key. Default is KEY_READ.\n"
+"\n"
+"The result is a new handle to the specified key.\n"
+"If the function fails, an OSError exception is raised.");
+
+#define WINREG_OPENKEYEX_METHODDEF \
+ {"OpenKeyEx", (PyCFunction)winreg_OpenKeyEx, METH_VARARGS|METH_KEYWORDS, winreg_OpenKeyEx__doc__},
+
+static HKEY
+winreg_OpenKeyEx_impl(PyModuleDef *module, HKEY key, Py_UNICODE *sub_key, int reserved, REGSAM access);
+
+static PyObject *
+winreg_OpenKeyEx(PyModuleDef *module, PyObject *args, PyObject *kwargs)
+{
+ PyObject *return_value = NULL;
+ static char *_keywords[] = {"key", "sub_key", "reserved", "access", NULL};
+ HKEY key;
+ Py_UNICODE *sub_key;
+ int reserved = 0;
+ REGSAM access = KEY_READ;
+ HKEY _return_value;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+ "O&Z|ii:OpenKeyEx", _keywords,
+ clinic_HKEY_converter, &key, &sub_key, &reserved, &access))
+ goto exit;
+ _return_value = winreg_OpenKeyEx_impl(module, key, sub_key, reserved, access);
+ if (_return_value == NULL)
+ goto exit;
+ return_value = PyHKEY_FromHKEY(_return_value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_QueryInfoKey__doc__,
+"QueryInfoKey($module, key, /)\n"
+"--\n"
+"\n"
+"Returns information about a key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+"\n"
+"The result is a tuple of 3 items:\n"
+"An integer that identifies the number of sub keys this key has.\n"
+"An integer that identifies the number of values this key has.\n"
+"An integer that identifies when the key was last modified (if available)\n"
+"as 100\'s of nanoseconds since Jan 1, 1600.");
+
+#define WINREG_QUERYINFOKEY_METHODDEF \
+ {"QueryInfoKey", (PyCFunction)winreg_QueryInfoKey, METH_O, winreg_QueryInfoKey__doc__},
+
+static PyObject *
+winreg_QueryInfoKey_impl(PyModuleDef *module, HKEY key);
+
+static PyObject *
+winreg_QueryInfoKey(PyModuleDef *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+
+ if (!PyArg_Parse(arg,
+ "O&:QueryInfoKey",
+ clinic_HKEY_converter, &key))
+ goto exit;
+ return_value = winreg_QueryInfoKey_impl(module, key);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_QueryValue__doc__,
+"QueryValue($module, key, sub_key, /)\n"
+"--\n"
+"\n"
+"Retrieves the unnamed value for a key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" sub_key\n"
+" A string that holds the name of the subkey with which the value\n"
+" is associated. If this parameter is None or empty, the function\n"
+" retrieves the value set by the SetValue() method for the key\n"
+" identified by key.\n"
+"\n"
+"Values in the registry have name, type, and data components. This method\n"
+"retrieves the data for a key\'s first value that has a NULL name.\n"
+"But since the underlying API call doesn\'t return the type, you\'ll\n"
+"probably be happier using QueryValueEx; this function is just here for\n"
+"completeness.");
+
+#define WINREG_QUERYVALUE_METHODDEF \
+ {"QueryValue", (PyCFunction)winreg_QueryValue, METH_VARARGS, winreg_QueryValue__doc__},
+
+static PyObject *
+winreg_QueryValue_impl(PyModuleDef *module, HKEY key, Py_UNICODE *sub_key);
+
+static PyObject *
+winreg_QueryValue(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+ Py_UNICODE *sub_key;
+
+ if (!PyArg_ParseTuple(args,
+ "O&Z:QueryValue",
+ clinic_HKEY_converter, &key, &sub_key))
+ goto exit;
+ return_value = winreg_QueryValue_impl(module, key, sub_key);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_QueryValueEx__doc__,
+"QueryValueEx($module, key, name, /)\n"
+"--\n"
+"\n"
+"Retrieves the type and value of a specified sub-key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" name\n"
+" A string indicating the value to query.\n"
+"\n"
+"Behaves mostly like QueryValue(), but also returns the type of the\n"
+"specified value name associated with the given open registry key.\n"
+"\n"
+"The return value is a tuple of the value and the type_id.");
+
+#define WINREG_QUERYVALUEEX_METHODDEF \
+ {"QueryValueEx", (PyCFunction)winreg_QueryValueEx, METH_VARARGS, winreg_QueryValueEx__doc__},
+
+static PyObject *
+winreg_QueryValueEx_impl(PyModuleDef *module, HKEY key, Py_UNICODE *name);
+
+static PyObject *
+winreg_QueryValueEx(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+ Py_UNICODE *name;
+
+ if (!PyArg_ParseTuple(args,
+ "O&Z:QueryValueEx",
+ clinic_HKEY_converter, &key, &name))
+ goto exit;
+ return_value = winreg_QueryValueEx_impl(module, key, name);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_SaveKey__doc__,
+"SaveKey($module, key, file_name, /)\n"
+"--\n"
+"\n"
+"Saves the specified key, and all its subkeys to the specified file.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" file_name\n"
+" The name of the file to save registry data to. This file cannot\n"
+" already exist. If this filename includes an extension, it cannot be\n"
+" used on file allocation table (FAT) file systems by the LoadKey(),\n"
+" ReplaceKey() or RestoreKey() methods.\n"
+"\n"
+"If key represents a key on a remote computer, the path described by\n"
+"file_name is relative to the remote computer.\n"
+"\n"
+"The caller of this method must possess the SeBackupPrivilege\n"
+"security privilege. This function passes NULL for security_attributes\n"
+"to the API.");
+
+#define WINREG_SAVEKEY_METHODDEF \
+ {"SaveKey", (PyCFunction)winreg_SaveKey, METH_VARARGS, winreg_SaveKey__doc__},
+
+static PyObject *
+winreg_SaveKey_impl(PyModuleDef *module, HKEY key, Py_UNICODE *file_name);
+
+static PyObject *
+winreg_SaveKey(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+ Py_UNICODE *file_name;
+
+ if (!PyArg_ParseTuple(args,
+ "O&u:SaveKey",
+ clinic_HKEY_converter, &key, &file_name))
+ goto exit;
+ return_value = winreg_SaveKey_impl(module, key, file_name);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_SetValue__doc__,
+"SetValue($module, key, sub_key, type, value, /)\n"
+"--\n"
+"\n"
+"Associates a value with a specified key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" sub_key\n"
+" A string that names the subkey with which the value is associated.\n"
+" type\n"
+" An integer that specifies the type of the data. Currently this must\n"
+" be REG_SZ, meaning only strings are supported.\n"
+" value\n"
+" A string that specifies the new value.\n"
+"\n"
+"If the key specified by the sub_key parameter does not exist, the\n"
+"SetValue function creates it.\n"
+"\n"
+"Value lengths are limited by available memory. Long values (more than\n"
+"2048 bytes) should be stored as files with the filenames stored in\n"
+"the configuration registry to help the registry perform efficiently.\n"
+"\n"
+"The key identified by the key parameter must have been opened with\n"
+"KEY_SET_VALUE access.");
+
+#define WINREG_SETVALUE_METHODDEF \
+ {"SetValue", (PyCFunction)winreg_SetValue, METH_VARARGS, winreg_SetValue__doc__},
+
+static PyObject *
+winreg_SetValue_impl(PyModuleDef *module, HKEY key, Py_UNICODE *sub_key, DWORD type, Py_UNICODE *value, Py_ssize_clean_t value_length);
+
+static PyObject *
+winreg_SetValue(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+ Py_UNICODE *sub_key;
+ DWORD type;
+ Py_UNICODE *value;
+ Py_ssize_clean_t value_length;
+
+ if (!PyArg_ParseTuple(args,
+ "O&Zku#:SetValue",
+ clinic_HKEY_converter, &key, &sub_key, &type, &value, &value_length))
+ goto exit;
+ return_value = winreg_SetValue_impl(module, key, sub_key, type, value, value_length);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_SetValueEx__doc__,
+"SetValueEx($module, key, value_name, reserved, type, value, /)\n"
+"--\n"
+"\n"
+"Stores data in the value field of an open registry key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+" value_name\n"
+" A string containing the name of the value to set, or None.\n"
+" reserved\n"
+" Can be anything - zero is always passed to the API.\n"
+" type\n"
+" An integer that specifies the type of the data, one of:\n"
+" REG_BINARY -- Binary data in any form.\n"
+" REG_DWORD -- A 32-bit number.\n"
+" REG_DWORD_LITTLE_ENDIAN -- A 32-bit number in little-endian format.\n"
+" REG_DWORD_BIG_ENDIAN -- A 32-bit number in big-endian format.\n"
+" REG_EXPAND_SZ -- A null-terminated string that contains unexpanded\n"
+" references to environment variables (for example,\n"
+" %PATH%).\n"
+" REG_LINK -- A Unicode symbolic link.\n"
+" REG_MULTI_SZ -- An sequence of null-terminated strings, terminated\n"
+" by two null characters. Note that Python handles\n"
+" this termination automatically.\n"
+" REG_NONE -- No defined value type.\n"
+" REG_RESOURCE_LIST -- A device-driver resource list.\n"
+" REG_SZ -- A null-terminated string.\n"
+" value\n"
+" A string that specifies the new value.\n"
+"\n"
+"This method can also set additional value and type information for the\n"
+"specified key. The key identified by the key parameter must have been\n"
+"opened with KEY_SET_VALUE access.\n"
+"\n"
+"To open the key, use the CreateKeyEx() or OpenKeyEx() methods.\n"
+"\n"
+"Value lengths are limited by available memory. Long values (more than\n"
+"2048 bytes) should be stored as files with the filenames stored in\n"
+"the configuration registry to help the registry perform efficiently.");
+
+#define WINREG_SETVALUEEX_METHODDEF \
+ {"SetValueEx", (PyCFunction)winreg_SetValueEx, METH_VARARGS, winreg_SetValueEx__doc__},
+
+static PyObject *
+winreg_SetValueEx_impl(PyModuleDef *module, HKEY key, Py_UNICODE *value_name, PyObject *reserved, DWORD type, PyObject *value);
+
+static PyObject *
+winreg_SetValueEx(PyModuleDef *module, PyObject *args)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+ Py_UNICODE *value_name;
+ PyObject *reserved;
+ DWORD type;
+ PyObject *value;
+
+ if (!PyArg_ParseTuple(args,
+ "O&ZOkO:SetValueEx",
+ clinic_HKEY_converter, &key, &value_name, &reserved, &type, &value))
+ goto exit;
+ return_value = winreg_SetValueEx_impl(module, key, value_name, reserved, type, value);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_DisableReflectionKey__doc__,
+"DisableReflectionKey($module, key, /)\n"
+"--\n"
+"\n"
+"Disables registry reflection for 32bit processes running on a 64bit OS.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+"\n"
+"Will generally raise NotImplemented if executed on a 32bit OS.\n"
+"\n"
+"If the key is not on the reflection list, the function succeeds but has\n"
+"no effect. Disabling reflection for a key does not affect reflection\n"
+"of any subkeys.");
+
+#define WINREG_DISABLEREFLECTIONKEY_METHODDEF \
+ {"DisableReflectionKey", (PyCFunction)winreg_DisableReflectionKey, METH_O, winreg_DisableReflectionKey__doc__},
+
+static PyObject *
+winreg_DisableReflectionKey_impl(PyModuleDef *module, HKEY key);
+
+static PyObject *
+winreg_DisableReflectionKey(PyModuleDef *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+
+ if (!PyArg_Parse(arg,
+ "O&:DisableReflectionKey",
+ clinic_HKEY_converter, &key))
+ goto exit;
+ return_value = winreg_DisableReflectionKey_impl(module, key);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_EnableReflectionKey__doc__,
+"EnableReflectionKey($module, key, /)\n"
+"--\n"
+"\n"
+"Restores registry reflection for the specified disabled key.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+"\n"
+"Will generally raise NotImplemented if executed on a 32bit OS.\n"
+"Restoring reflection for a key does not affect reflection of any\n"
+"subkeys.");
+
+#define WINREG_ENABLEREFLECTIONKEY_METHODDEF \
+ {"EnableReflectionKey", (PyCFunction)winreg_EnableReflectionKey, METH_O, winreg_EnableReflectionKey__doc__},
+
+static PyObject *
+winreg_EnableReflectionKey_impl(PyModuleDef *module, HKEY key);
+
+static PyObject *
+winreg_EnableReflectionKey(PyModuleDef *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+
+ if (!PyArg_Parse(arg,
+ "O&:EnableReflectionKey",
+ clinic_HKEY_converter, &key))
+ goto exit;
+ return_value = winreg_EnableReflectionKey_impl(module, key);
+
+exit:
+ return return_value;
+}
+
+PyDoc_STRVAR(winreg_QueryReflectionKey__doc__,
+"QueryReflectionKey($module, key, /)\n"
+"--\n"
+"\n"
+"Returns the reflection state for the specified key as a bool.\n"
+"\n"
+" key\n"
+" An already open key, or any one of the predefined HKEY_* constants.\n"
+"\n"
+"Will generally raise NotImplemented if executed on a 32bit OS.");
+
+#define WINREG_QUERYREFLECTIONKEY_METHODDEF \
+ {"QueryReflectionKey", (PyCFunction)winreg_QueryReflectionKey, METH_O, winreg_QueryReflectionKey__doc__},
+
+static PyObject *
+winreg_QueryReflectionKey_impl(PyModuleDef *module, HKEY key);
+
+static PyObject *
+winreg_QueryReflectionKey(PyModuleDef *module, PyObject *arg)
+{
+ PyObject *return_value = NULL;
+ HKEY key;
+
+ if (!PyArg_Parse(arg,
+ "O&:QueryReflectionKey",
+ clinic_HKEY_converter, &key))
+ goto exit;
+ return_value = winreg_QueryReflectionKey_impl(module, key);
+
+exit:
+ return return_value;
+}
+/*[clinic end generated code: output=be6e50b901570878 input=a9049054013a1b77]*/