PyDoc_STRVAR(winreg_HKEYType_Close__doc__,

"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__,

"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__,

"\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__,

"\n");

#define WINREG_HKEYTYPE___EXIT___METHODDEF \

{"__exit__", (PyCFunction)winreg_HKEYType___exit__, METH_FASTCALL|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 *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

static const char * const _keywords[] = {"exc_type", "exc_value", "traceback", NULL};

static _PyArg_Parser _parser = {"OOO:__exit__", _keywords, 0};

PyObject *exc_type;

PyObject *exc_value;

PyObject *traceback;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

&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__,

"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__,

"If the function fails, an OSError exception is raised.");

#define WINREG_CONNECTREGISTRY_METHODDEF \

{"ConnectRegistry", (PyCFunction)winreg_ConnectRegistry, METH_FASTCALL, winreg_ConnectRegistry__doc__},

static HKEY

winreg_ConnectRegistry_impl(PyObject *module, Py_UNICODE *computer_name,

HKEY key);

static PyObject *

winreg_ConnectRegistry(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

Py_UNICODE *computer_name;

HKEY key;

HKEY _return_value;

if (!_PyArg_ParseStack(args, nargs, "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__,

"If the function fails, an OSError exception is raised.");

#define WINREG_CREATEKEY_METHODDEF \

{"CreateKey", (PyCFunction)winreg_CreateKey, METH_FASTCALL, winreg_CreateKey__doc__},

static HKEY

winreg_CreateKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);

static PyObject *

winreg_CreateKey(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HKEY key;

Py_UNICODE *sub_key;

HKEY _return_value;

if (!_PyArg_ParseStack(args, nargs, "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__,

"If the function fails, an OSError exception is raised.");

#define WINREG_CREATEKEYEX_METHODDEF \

{"CreateKeyEx", (PyCFunction)winreg_CreateKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_CreateKeyEx__doc__},

static HKEY

winreg_CreateKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,

int reserved, REGSAM access);

static PyObject *

winreg_CreateKeyEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

static const char * const _keywords[] = {"key", "sub_key", "reserved", "access", NULL};

static _PyArg_Parser _parser = {"O&Z|ii:CreateKeyEx", _keywords, 0};

HKEY key;

Py_UNICODE *sub_key;

int reserved = 0;

REGSAM access = KEY_WRITE;

HKEY _return_value;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

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__,

"is removed. If the function fails, an OSError exception is raised.");

#define WINREG_DELETEKEY_METHODDEF \

{"DeleteKey", (PyCFunction)winreg_DeleteKey, METH_FASTCALL, winreg_DeleteKey__doc__},

static PyObject *

winreg_DeleteKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);

static PyObject *

winreg_DeleteKey(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HKEY key;

Py_UNICODE *sub_key;

if (!_PyArg_ParseStack(args, nargs, "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__,

"On unsupported Windows versions, NotImplementedError is raised.");

#define WINREG_DELETEKEYEX_METHODDEF \

{"DeleteKeyEx", (PyCFunction)winreg_DeleteKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_DeleteKeyEx__doc__},

static PyObject *

winreg_DeleteKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,

REGSAM access, int reserved);

static PyObject *

winreg_DeleteKeyEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

static const char * const _keywords[] = {"key", "sub_key", "access", "reserved", NULL};

static _PyArg_Parser _parser = {"O&u|ii:DeleteKeyEx", _keywords, 0};

HKEY key;

Py_UNICODE *sub_key;

REGSAM access = KEY_WOW64_64KEY;

int reserved = 0;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

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__,

" A string that identifies the value to remove.");

#define WINREG_DELETEVALUE_METHODDEF \

{"DeleteValue", (PyCFunction)winreg_DeleteValue, METH_FASTCALL, winreg_DeleteValue__doc__},

static PyObject *

winreg_DeleteValue_impl(PyObject *module, HKEY key, Py_UNICODE *value);

static PyObject *

winreg_DeleteValue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HKEY key;

Py_UNICODE *value;

if (!_PyArg_ParseStack(args, nargs, "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__,

"raised, indicating no more values are available.");

#define WINREG_ENUMKEY_METHODDEF \

{"EnumKey", (PyCFunction)winreg_EnumKey, METH_FASTCALL, winreg_EnumKey__doc__},

static PyObject *

winreg_EnumKey_impl(PyObject *module, HKEY key, int index);

static PyObject *

winreg_EnumKey(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HKEY key;

int index;

if (!_PyArg_ParseStack(args, nargs, "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__,

" An integer that identifies the type of the value data.");

#define WINREG_ENUMVALUE_METHODDEF \

{"EnumValue", (PyCFunction)winreg_EnumValue, METH_FASTCALL, winreg_EnumValue__doc__},

static PyObject *

winreg_EnumValue_impl(PyObject *module, HKEY key, int index);

static PyObject *

winreg_EnumValue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HKEY key;

int index;

if (!_PyArg_ParseStack(args, nargs, "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__,

"Expand environment vars.");

#define WINREG_EXPANDENVIRONMENTSTRINGS_METHODDEF \

{"ExpandEnvironmentStrings", (PyCFunction)winreg_ExpandEnvironmentStrings, METH_O, winreg_ExpandEnvironmentStrings__doc__},

static PyObject *

winreg_ExpandEnvironmentStrings_impl(PyObject *module, Py_UNICODE *string);

static PyObject *

winreg_ExpandEnvironmentStrings(PyObject *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__,

"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(PyObject *module, HKEY key);

static PyObject *

winreg_FlushKey(PyObject *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__,

"tree.");

#define WINREG_LOADKEY_METHODDEF \

{"LoadKey", (PyCFunction)winreg_LoadKey, METH_FASTCALL, winreg_LoadKey__doc__},

static PyObject *

winreg_LoadKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,

Py_UNICODE *file_name);

static PyObject *

winreg_LoadKey(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HKEY key;

Py_UNICODE *sub_key;

Py_UNICODE *file_name;

if (!_PyArg_ParseStack(args, nargs, "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__,

"If the function fails, an OSError exception is raised.");

#define WINREG_OPENKEY_METHODDEF \

{"OpenKey", (PyCFunction)winreg_OpenKey, METH_FASTCALL|METH_KEYWORDS, winreg_OpenKey__doc__},

static HKEY

winreg_OpenKey_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,

int reserved, REGSAM access);

static PyObject *

winreg_OpenKey(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

static const char * const _keywords[] = {"key", "sub_key", "reserved", "access", NULL};

static _PyArg_Parser _parser = {"O&Z|ii:OpenKey", _keywords, 0};

HKEY key;

Py_UNICODE *sub_key;

int reserved = 0;

REGSAM access = KEY_READ;

HKEY _return_value;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

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__,

"If the function fails, an OSError exception is raised.");

#define WINREG_OPENKEYEX_METHODDEF \

{"OpenKeyEx", (PyCFunction)winreg_OpenKeyEx, METH_FASTCALL|METH_KEYWORDS, winreg_OpenKeyEx__doc__},

static HKEY

winreg_OpenKeyEx_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,

int reserved, REGSAM access);

static PyObject *

winreg_OpenKeyEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)

{

PyObject *return_value = NULL;

static const char * const _keywords[] = {"key", "sub_key", "reserved", "access", NULL};

static _PyArg_Parser _parser = {"O&Z|ii:OpenKeyEx", _keywords, 0};

HKEY key;

Py_UNICODE *sub_key;

int reserved = 0;

REGSAM access = KEY_READ;

HKEY _return_value;

if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser,

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__,

"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(PyObject *module, HKEY key);

static PyObject *

winreg_QueryInfoKey(PyObject *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__,

"completeness.");

#define WINREG_QUERYVALUE_METHODDEF \

{"QueryValue", (PyCFunction)winreg_QueryValue, METH_FASTCALL, winreg_QueryValue__doc__},

static PyObject *

winreg_QueryValue_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key);

static PyObject *

winreg_QueryValue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HKEY key;

Py_UNICODE *sub_key;

if (!_PyArg_ParseStack(args, nargs, "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__,

"The return value is a tuple of the value and the type_id.");

#define WINREG_QUERYVALUEEX_METHODDEF \

{"QueryValueEx", (PyCFunction)winreg_QueryValueEx, METH_FASTCALL, winreg_QueryValueEx__doc__},

static PyObject *

winreg_QueryValueEx_impl(PyObject *module, HKEY key, Py_UNICODE *name);

static PyObject *

winreg_QueryValueEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HKEY key;

Py_UNICODE *name;

if (!_PyArg_ParseStack(args, nargs, "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__,

"to the API.");

#define WINREG_SAVEKEY_METHODDEF \

{"SaveKey", (PyCFunction)winreg_SaveKey, METH_FASTCALL, winreg_SaveKey__doc__},

static PyObject *

winreg_SaveKey_impl(PyObject *module, HKEY key, Py_UNICODE *file_name);

static PyObject *

winreg_SaveKey(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HKEY key;

Py_UNICODE *file_name;

if (!_PyArg_ParseStack(args, nargs, "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__,

"KEY_SET_VALUE access.");

#define WINREG_SETVALUE_METHODDEF \

{"SetValue", (PyCFunction)winreg_SetValue, METH_FASTCALL, winreg_SetValue__doc__},

static PyObject *

winreg_SetValue_impl(PyObject *module, HKEY key, Py_UNICODE *sub_key,

DWORD type, Py_UNICODE *value,

Py_ssize_clean_t value_length);

static PyObject *

winreg_SetValue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HKEY key;

Py_UNICODE *sub_key;

DWORD type;

Py_UNICODE *value;

Py_ssize_clean_t value_length;

if (!_PyArg_ParseStack(args, nargs, "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__,

"the configuration registry to help the registry perform efficiently.");

#define WINREG_SETVALUEEX_METHODDEF \

{"SetValueEx", (PyCFunction)winreg_SetValueEx, METH_FASTCALL, winreg_SetValueEx__doc__},

static PyObject *

winreg_SetValueEx_impl(PyObject *module, HKEY key, Py_UNICODE *value_name,

PyObject *reserved, DWORD type, PyObject *value);

static PyObject *

winreg_SetValueEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)

{

PyObject *return_value = NULL;

HKEY key;

Py_UNICODE *value_name;

PyObject *reserved;

DWORD type;

PyObject *value;

if (!_PyArg_ParseStack(args, nargs, "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__,