From a397e56d2aad76fe5cacd54a2ecbdb03702985c7 Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Thu, 9 Jun 2016 16:16:06 +0300
Subject: Issue #26305: Argument Clinic now uses braces in C code as required
 by PEP 7.

---
 Modules/clinic/_codecsmodule.c.h | 191 ++++++++++++++++++++++++++-------------
 1 file changed, 127 insertions(+), 64 deletions(-)

(limited to 'Modules/clinic/_codecsmodule.c.h')

diff --git a/Modules/clinic/_codecsmodule.c.h b/Modules/clinic/_codecsmodule.c.h
index 29f46bbb04..a7ca79e1bf 100644
--- a/Modules/clinic/_codecsmodule.c.h
+++ b/Modules/clinic/_codecsmodule.c.h
@@ -33,8 +33,9 @@ _codecs_lookup(PyModuleDef *module, PyObject *arg)
     PyObject *return_value = NULL;
     const char *encoding;
 
-    if (!PyArg_Parse(arg, "s:lookup", &encoding))
+    if (!PyArg_Parse(arg, "s:lookup", &encoding)) {
         goto exit;
+    }
     return_value = _codecs_lookup_impl(module, encoding);
 
 exit:
@@ -70,8 +71,9 @@ _codecs_encode(PyModuleDef *module, PyObject *args, PyObject *kwargs)
     const char *errors = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|ss:encode", _keywords,
-        &obj, &encoding, &errors))
+        &obj, &encoding, &errors)) {
         goto exit;
+    }
     return_value = _codecs_encode_impl(module, obj, encoding, errors);
 
 exit:
@@ -107,8 +109,9 @@ _codecs_decode(PyModuleDef *module, PyObject *args, PyObject *kwargs)
     const char *errors = NULL;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|ss:decode", _keywords,
-        &obj, &encoding, &errors))
+        &obj, &encoding, &errors)) {
         goto exit;
+    }
     return_value = _codecs_decode_impl(module, obj, encoding, errors);
 
 exit:
@@ -133,8 +136,9 @@ _codecs__forget_codec(PyModuleDef *module, PyObject *arg)
     PyObject *return_value = NULL;
     const char *encoding;
 
-    if (!PyArg_Parse(arg, "s:_forget_codec", &encoding))
+    if (!PyArg_Parse(arg, "s:_forget_codec", &encoding)) {
         goto exit;
+    }
     return_value = _codecs__forget_codec_impl(module, encoding);
 
 exit:
@@ -161,14 +165,16 @@ _codecs_escape_decode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "s*|z:escape_decode",
-        &data, &errors))
+        &data, &errors)) {
         goto exit;
+    }
     return_value = _codecs_escape_decode_impl(module, &data, errors);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -193,8 +199,9 @@ _codecs_escape_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "O!|z:escape_encode",
-        &PyBytes_Type, &data, &errors))
+        &PyBytes_Type, &data, &errors)) {
         goto exit;
+    }
     return_value = _codecs_escape_encode_impl(module, data, errors);
 
 exit:
@@ -221,8 +228,9 @@ _codecs_unicode_internal_decode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "O|z:unicode_internal_decode",
-        &obj, &errors))
+        &obj, &errors)) {
         goto exit;
+    }
     return_value = _codecs_unicode_internal_decode_impl(module, obj, errors);
 
 exit:
@@ -250,14 +258,16 @@ _codecs_utf_7_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "y*|zi:utf_7_decode",
-        &data, &errors, &final))
+        &data, &errors, &final)) {
         goto exit;
+    }
     return_value = _codecs_utf_7_decode_impl(module, &data, errors, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -283,14 +293,16 @@ _codecs_utf_8_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "y*|zi:utf_8_decode",
-        &data, &errors, &final))
+        &data, &errors, &final)) {
         goto exit;
+    }
     return_value = _codecs_utf_8_decode_impl(module, &data, errors, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -316,14 +328,16 @@ _codecs_utf_16_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "y*|zi:utf_16_decode",
-        &data, &errors, &final))
+        &data, &errors, &final)) {
         goto exit;
+    }
     return_value = _codecs_utf_16_decode_impl(module, &data, errors, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -349,14 +363,16 @@ _codecs_utf_16_le_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "y*|zi:utf_16_le_decode",
-        &data, &errors, &final))
+        &data, &errors, &final)) {
         goto exit;
+    }
     return_value = _codecs_utf_16_le_decode_impl(module, &data, errors, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -382,14 +398,16 @@ _codecs_utf_16_be_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "y*|zi:utf_16_be_decode",
-        &data, &errors, &final))
+        &data, &errors, &final)) {
         goto exit;
+    }
     return_value = _codecs_utf_16_be_decode_impl(module, &data, errors, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -417,14 +435,16 @@ _codecs_utf_16_ex_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "y*|zii:utf_16_ex_decode",
-        &data, &errors, &byteorder, &final))
+        &data, &errors, &byteorder, &final)) {
         goto exit;
+    }
     return_value = _codecs_utf_16_ex_decode_impl(module, &data, errors, byteorder, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -450,14 +470,16 @@ _codecs_utf_32_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "y*|zi:utf_32_decode",
-        &data, &errors, &final))
+        &data, &errors, &final)) {
         goto exit;
+    }
     return_value = _codecs_utf_32_decode_impl(module, &data, errors, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -483,14 +505,16 @@ _codecs_utf_32_le_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "y*|zi:utf_32_le_decode",
-        &data, &errors, &final))
+        &data, &errors, &final)) {
         goto exit;
+    }
     return_value = _codecs_utf_32_le_decode_impl(module, &data, errors, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -516,14 +540,16 @@ _codecs_utf_32_be_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "y*|zi:utf_32_be_decode",
-        &data, &errors, &final))
+        &data, &errors, &final)) {
         goto exit;
+    }
     return_value = _codecs_utf_32_be_decode_impl(module, &data, errors, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -551,14 +577,16 @@ _codecs_utf_32_ex_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "y*|zii:utf_32_ex_decode",
-        &data, &errors, &byteorder, &final))
+        &data, &errors, &byteorder, &final)) {
         goto exit;
+    }
     return_value = _codecs_utf_32_ex_decode_impl(module, &data, errors, byteorder, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -583,14 +611,16 @@ _codecs_unicode_escape_decode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "s*|z:unicode_escape_decode",
-        &data, &errors))
+        &data, &errors)) {
         goto exit;
+    }
     return_value = _codecs_unicode_escape_decode_impl(module, &data, errors);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -615,14 +645,16 @@ _codecs_raw_unicode_escape_decode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "s*|z:raw_unicode_escape_decode",
-        &data, &errors))
+        &data, &errors)) {
         goto exit;
+    }
     return_value = _codecs_raw_unicode_escape_decode_impl(module, &data, errors);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -647,14 +679,16 @@ _codecs_latin_1_decode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "y*|z:latin_1_decode",
-        &data, &errors))
+        &data, &errors)) {
         goto exit;
+    }
     return_value = _codecs_latin_1_decode_impl(module, &data, errors);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -679,14 +713,16 @@ _codecs_ascii_decode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "y*|z:ascii_decode",
-        &data, &errors))
+        &data, &errors)) {
         goto exit;
+    }
     return_value = _codecs_ascii_decode_impl(module, &data, errors);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -712,14 +748,16 @@ _codecs_charmap_decode(PyModuleDef *module, PyObject *args)
     PyObject *mapping = NULL;
 
     if (!PyArg_ParseTuple(args, "y*|zO:charmap_decode",
-        &data, &errors, &mapping))
+        &data, &errors, &mapping)) {
         goto exit;
+    }
     return_value = _codecs_charmap_decode_impl(module, &data, errors, mapping);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -747,14 +785,16 @@ _codecs_mbcs_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "y*|zi:mbcs_decode",
-        &data, &errors, &final))
+        &data, &errors, &final)) {
         goto exit;
+    }
     return_value = _codecs_mbcs_decode_impl(module, &data, errors, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -785,14 +825,16 @@ _codecs_code_page_decode(PyModuleDef *module, PyObject *args)
     int final = 0;
 
     if (!PyArg_ParseTuple(args, "iy*|zi:code_page_decode",
-        &codepage, &data, &errors, &final))
+        &codepage, &data, &errors, &final)) {
         goto exit;
+    }
     return_value = _codecs_code_page_decode_impl(module, codepage, &data, errors, final);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -819,14 +861,16 @@ _codecs_readbuffer_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "s*|z:readbuffer_encode",
-        &data, &errors))
+        &data, &errors)) {
         goto exit;
+    }
     return_value = _codecs_readbuffer_encode_impl(module, &data, errors);
 
 exit:
     /* Cleanup for data */
-    if (data.obj)
+    if (data.obj) {
        PyBuffer_Release(&data);
+    }
 
     return return_value;
 }
@@ -851,8 +895,9 @@ _codecs_unicode_internal_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "O|z:unicode_internal_encode",
-        &obj, &errors))
+        &obj, &errors)) {
         goto exit;
+    }
     return_value = _codecs_unicode_internal_encode_impl(module, obj, errors);
 
 exit:
@@ -879,8 +924,9 @@ _codecs_utf_7_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "U|z:utf_7_encode",
-        &str, &errors))
+        &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_utf_7_encode_impl(module, str, errors);
 
 exit:
@@ -907,8 +953,9 @@ _codecs_utf_8_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "U|z:utf_8_encode",
-        &str, &errors))
+        &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_utf_8_encode_impl(module, str, errors);
 
 exit:
@@ -936,8 +983,9 @@ _codecs_utf_16_encode(PyModuleDef *module, PyObject *args)
     int byteorder = 0;
 
     if (!PyArg_ParseTuple(args, "U|zi:utf_16_encode",
-        &str, &errors, &byteorder))
+        &str, &errors, &byteorder)) {
         goto exit;
+    }
     return_value = _codecs_utf_16_encode_impl(module, str, errors, byteorder);
 
 exit:
@@ -964,8 +1012,9 @@ _codecs_utf_16_le_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "U|z:utf_16_le_encode",
-        &str, &errors))
+        &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_utf_16_le_encode_impl(module, str, errors);
 
 exit:
@@ -992,8 +1041,9 @@ _codecs_utf_16_be_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "U|z:utf_16_be_encode",
-        &str, &errors))
+        &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_utf_16_be_encode_impl(module, str, errors);
 
 exit:
@@ -1021,8 +1071,9 @@ _codecs_utf_32_encode(PyModuleDef *module, PyObject *args)
     int byteorder = 0;
 
     if (!PyArg_ParseTuple(args, "U|zi:utf_32_encode",
-        &str, &errors, &byteorder))
+        &str, &errors, &byteorder)) {
         goto exit;
+    }
     return_value = _codecs_utf_32_encode_impl(module, str, errors, byteorder);
 
 exit:
@@ -1049,8 +1100,9 @@ _codecs_utf_32_le_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "U|z:utf_32_le_encode",
-        &str, &errors))
+        &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_utf_32_le_encode_impl(module, str, errors);
 
 exit:
@@ -1077,8 +1129,9 @@ _codecs_utf_32_be_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "U|z:utf_32_be_encode",
-        &str, &errors))
+        &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_utf_32_be_encode_impl(module, str, errors);
 
 exit:
@@ -1105,8 +1158,9 @@ _codecs_unicode_escape_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "U|z:unicode_escape_encode",
-        &str, &errors))
+        &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_unicode_escape_encode_impl(module, str, errors);
 
 exit:
@@ -1133,8 +1187,9 @@ _codecs_raw_unicode_escape_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "U|z:raw_unicode_escape_encode",
-        &str, &errors))
+        &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_raw_unicode_escape_encode_impl(module, str, errors);
 
 exit:
@@ -1161,8 +1216,9 @@ _codecs_latin_1_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "U|z:latin_1_encode",
-        &str, &errors))
+        &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_latin_1_encode_impl(module, str, errors);
 
 exit:
@@ -1189,8 +1245,9 @@ _codecs_ascii_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "U|z:ascii_encode",
-        &str, &errors))
+        &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_ascii_encode_impl(module, str, errors);
 
 exit:
@@ -1218,8 +1275,9 @@ _codecs_charmap_encode(PyModuleDef *module, PyObject *args)
     PyObject *mapping = NULL;
 
     if (!PyArg_ParseTuple(args, "U|zO:charmap_encode",
-        &str, &errors, &mapping))
+        &str, &errors, &mapping)) {
         goto exit;
+    }
     return_value = _codecs_charmap_encode_impl(module, str, errors, mapping);
 
 exit:
@@ -1243,8 +1301,9 @@ _codecs_charmap_build(PyModuleDef *module, PyObject *arg)
     PyObject *return_value = NULL;
     PyObject *map;
 
-    if (!PyArg_Parse(arg, "U:charmap_build", &map))
+    if (!PyArg_Parse(arg, "U:charmap_build", &map)) {
         goto exit;
+    }
     return_value = _codecs_charmap_build_impl(module, map);
 
 exit:
@@ -1273,8 +1332,9 @@ _codecs_mbcs_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "U|z:mbcs_encode",
-        &str, &errors))
+        &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_mbcs_encode_impl(module, str, errors);
 
 exit:
@@ -1306,8 +1366,9 @@ _codecs_code_page_encode(PyModuleDef *module, PyObject *args)
     const char *errors = NULL;
 
     if (!PyArg_ParseTuple(args, "iU|z:code_page_encode",
-        &code_page, &str, &errors))
+        &code_page, &str, &errors)) {
         goto exit;
+    }
     return_value = _codecs_code_page_encode_impl(module, code_page, str, errors);
 
 exit:
@@ -1341,8 +1402,9 @@ _codecs_register_error(PyModuleDef *module, PyObject *args)
     PyObject *handler;
 
     if (!PyArg_ParseTuple(args, "sO:register_error",
-        &errors, &handler))
+        &errors, &handler)) {
         goto exit;
+    }
     return_value = _codecs_register_error_impl(module, errors, handler);
 
 exit:
@@ -1370,8 +1432,9 @@ _codecs_lookup_error(PyModuleDef *module, PyObject *arg)
     PyObject *return_value = NULL;
     const char *name;
 
-    if (!PyArg_Parse(arg, "s:lookup_error", &name))
+    if (!PyArg_Parse(arg, "s:lookup_error", &name)) {
         goto exit;
+    }
     return_value = _codecs_lookup_error_impl(module, name);
 
 exit:
@@ -1393,4 +1456,4 @@ exit:
 #ifndef _CODECS_CODE_PAGE_ENCODE_METHODDEF
     #define _CODECS_CODE_PAGE_ENCODE_METHODDEF
 #endif /* !defined(_CODECS_CODE_PAGE_ENCODE_METHODDEF) */
-/*[clinic end generated code: output=04007a13c8387689 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=120320fe2ac32085 input=a9049054013a1b77]*/
-- 
cgit v1.2.1


From 96d299b2b87dd2311bcc94cbab7b1cfa2c30ccba Mon Sep 17 00:00:00 2001
From: Serhiy Storchaka <storchaka@gmail.com>
Date: Sun, 14 Aug 2016 10:52:18 +0300
Subject: Issue #27574: Decreased an overhead of parsing keyword arguments in
 functions implemented with using Argument Clinic.

---
 Modules/clinic/_codecsmodule.c.h | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'Modules/clinic/_codecsmodule.c.h')

diff --git a/Modules/clinic/_codecsmodule.c.h b/Modules/clinic/_codecsmodule.c.h
index 52c61c597a..090b1efd9e 100644
--- a/Modules/clinic/_codecsmodule.c.h
+++ b/Modules/clinic/_codecsmodule.c.h
@@ -65,12 +65,13 @@ static PyObject *
 _codecs_encode(PyObject *module, PyObject *args, PyObject *kwargs)
 {
     PyObject *return_value = NULL;
-    static char *_keywords[] = {"obj", "encoding", "errors", NULL};
+    static const char * const _keywords[] = {"obj", "encoding", "errors", NULL};
+    static _PyArg_Parser _parser = {"O|ss:encode", _keywords, 0};
     PyObject *obj;
     const char *encoding = NULL;
     const char *errors = NULL;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|ss:encode", _keywords,
+    if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
         &obj, &encoding, &errors)) {
         goto exit;
     }
@@ -103,12 +104,13 @@ static PyObject *
 _codecs_decode(PyObject *module, PyObject *args, PyObject *kwargs)
 {
     PyObject *return_value = NULL;
-    static char *_keywords[] = {"obj", "encoding", "errors", NULL};
+    static const char * const _keywords[] = {"obj", "encoding", "errors", NULL};
+    static _PyArg_Parser _parser = {"O|ss:decode", _keywords, 0};
     PyObject *obj;
     const char *encoding = NULL;
     const char *errors = NULL;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|ss:decode", _keywords,
+    if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
         &obj, &encoding, &errors)) {
         goto exit;
     }
@@ -1455,4 +1457,4 @@ exit:
 #ifndef _CODECS_CODE_PAGE_ENCODE_METHODDEF
     #define _CODECS_CODE_PAGE_ENCODE_METHODDEF
 #endif /* !defined(_CODECS_CODE_PAGE_ENCODE_METHODDEF) */
-/*[clinic end generated code: output=6e89ff4423c12a9b input=a9049054013a1b77]*/
+/*[clinic end generated code: output=0221e4eece62c905 input=a9049054013a1b77]*/
-- 
cgit v1.2.1


From 7bbc40238d3182b2d495024df0e473cd2ab03bce Mon Sep 17 00:00:00 2001
From: Steve Dower <steve.dower@microsoft.com>
Date: Tue, 6 Sep 2016 19:42:27 -0700
Subject: Issue #27959: Adds oem encoding, alias ansi to mbcs, move aliasmbcs
 to codec lookup

---
 Modules/clinic/_codecsmodule.c.h | 81 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 80 insertions(+), 1 deletion(-)

(limited to 'Modules/clinic/_codecsmodule.c.h')

diff --git a/Modules/clinic/_codecsmodule.c.h b/Modules/clinic/_codecsmodule.c.h
index 090b1efd9e..6a63cec66c 100644
--- a/Modules/clinic/_codecsmodule.c.h
+++ b/Modules/clinic/_codecsmodule.c.h
@@ -805,6 +805,45 @@ exit:
 
 #if defined(HAVE_MBCS)
 
+PyDoc_STRVAR(_codecs_oem_decode__doc__,
+"oem_decode($module, data, errors=None, final=False, /)\n"
+"--\n"
+"\n");
+
+#define _CODECS_OEM_DECODE_METHODDEF    \
+    {"oem_decode", (PyCFunction)_codecs_oem_decode, METH_VARARGS, _codecs_oem_decode__doc__},
+
+static PyObject *
+_codecs_oem_decode_impl(PyObject *module, Py_buffer *data,
+                        const char *errors, int final);
+
+static PyObject *
+_codecs_oem_decode(PyObject *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    Py_buffer data = {NULL, NULL};
+    const char *errors = NULL;
+    int final = 0;
+
+    if (!PyArg_ParseTuple(args, "y*|zi:oem_decode",
+        &data, &errors, &final)) {
+        goto exit;
+    }
+    return_value = _codecs_oem_decode_impl(module, &data, errors, final);
+
+exit:
+    /* Cleanup for data */
+    if (data.obj) {
+       PyBuffer_Release(&data);
+    }
+
+    return return_value;
+}
+
+#endif /* defined(HAVE_MBCS) */
+
+#if defined(HAVE_MBCS)
+
 PyDoc_STRVAR(_codecs_code_page_decode__doc__,
 "code_page_decode($module, codepage, data, errors=None, final=False, /)\n"
 "--\n"
@@ -1346,6 +1385,38 @@ exit:
 
 #if defined(HAVE_MBCS)
 
+PyDoc_STRVAR(_codecs_oem_encode__doc__,
+"oem_encode($module, str, errors=None, /)\n"
+"--\n"
+"\n");
+
+#define _CODECS_OEM_ENCODE_METHODDEF    \
+    {"oem_encode", (PyCFunction)_codecs_oem_encode, METH_VARARGS, _codecs_oem_encode__doc__},
+
+static PyObject *
+_codecs_oem_encode_impl(PyObject *module, PyObject *str, const char *errors);
+
+static PyObject *
+_codecs_oem_encode(PyObject *module, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *str;
+    const char *errors = NULL;
+
+    if (!PyArg_ParseTuple(args, "U|z:oem_encode",
+        &str, &errors)) {
+        goto exit;
+    }
+    return_value = _codecs_oem_encode_impl(module, str, errors);
+
+exit:
+    return return_value;
+}
+
+#endif /* defined(HAVE_MBCS) */
+
+#if defined(HAVE_MBCS)
+
 PyDoc_STRVAR(_codecs_code_page_encode__doc__,
 "code_page_encode($module, code_page, str, errors=None, /)\n"
 "--\n"
@@ -1446,6 +1517,10 @@ exit:
     #define _CODECS_MBCS_DECODE_METHODDEF
 #endif /* !defined(_CODECS_MBCS_DECODE_METHODDEF) */
 
+#ifndef _CODECS_OEM_DECODE_METHODDEF
+    #define _CODECS_OEM_DECODE_METHODDEF
+#endif /* !defined(_CODECS_OEM_DECODE_METHODDEF) */
+
 #ifndef _CODECS_CODE_PAGE_DECODE_METHODDEF
     #define _CODECS_CODE_PAGE_DECODE_METHODDEF
 #endif /* !defined(_CODECS_CODE_PAGE_DECODE_METHODDEF) */
@@ -1454,7 +1529,11 @@ exit:
     #define _CODECS_MBCS_ENCODE_METHODDEF
 #endif /* !defined(_CODECS_MBCS_ENCODE_METHODDEF) */
 
+#ifndef _CODECS_OEM_ENCODE_METHODDEF
+    #define _CODECS_OEM_ENCODE_METHODDEF
+#endif /* !defined(_CODECS_OEM_ENCODE_METHODDEF) */
+
 #ifndef _CODECS_CODE_PAGE_ENCODE_METHODDEF
     #define _CODECS_CODE_PAGE_ENCODE_METHODDEF
 #endif /* !defined(_CODECS_CODE_PAGE_ENCODE_METHODDEF) */
-/*[clinic end generated code: output=0221e4eece62c905 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=7874e2d559d49368 input=a9049054013a1b77]*/
-- 
cgit v1.2.1


From 9c9a45c1f0a264d3006971b8211d948d6883a05b Mon Sep 17 00:00:00 2001
From: Steve Dower <steve.dower@microsoft.com>
Date: Thu, 8 Sep 2016 10:35:16 -0700
Subject: Issue #27781: Change file system encoding on Windows to UTF-8 (PEP
 529)

---
 Modules/clinic/_codecsmodule.c.h | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

(limited to 'Modules/clinic/_codecsmodule.c.h')

diff --git a/Modules/clinic/_codecsmodule.c.h b/Modules/clinic/_codecsmodule.c.h
index 6a63cec66c..c7fd66ffb8 100644
--- a/Modules/clinic/_codecsmodule.c.h
+++ b/Modules/clinic/_codecsmodule.c.h
@@ -764,7 +764,7 @@ exit:
     return return_value;
 }
 
-#if defined(HAVE_MBCS)
+#if defined(MS_WINDOWS)
 
 PyDoc_STRVAR(_codecs_mbcs_decode__doc__,
 "mbcs_decode($module, data, errors=None, final=False, /)\n"
@@ -801,9 +801,9 @@ exit:
     return return_value;
 }
 
-#endif /* defined(HAVE_MBCS) */
+#endif /* defined(MS_WINDOWS) */
 
-#if defined(HAVE_MBCS)
+#if defined(MS_WINDOWS)
 
 PyDoc_STRVAR(_codecs_oem_decode__doc__,
 "oem_decode($module, data, errors=None, final=False, /)\n"
@@ -840,9 +840,9 @@ exit:
     return return_value;
 }
 
-#endif /* defined(HAVE_MBCS) */
+#endif /* defined(MS_WINDOWS) */
 
-#if defined(HAVE_MBCS)
+#if defined(MS_WINDOWS)
 
 PyDoc_STRVAR(_codecs_code_page_decode__doc__,
 "code_page_decode($module, codepage, data, errors=None, final=False, /)\n"
@@ -880,7 +880,7 @@ exit:
     return return_value;
 }
 
-#endif /* defined(HAVE_MBCS) */
+#endif /* defined(MS_WINDOWS) */
 
 PyDoc_STRVAR(_codecs_readbuffer_encode__doc__,
 "readbuffer_encode($module, data, errors=None, /)\n"
@@ -1351,7 +1351,7 @@ exit:
     return return_value;
 }
 
-#if defined(HAVE_MBCS)
+#if defined(MS_WINDOWS)
 
 PyDoc_STRVAR(_codecs_mbcs_encode__doc__,
 "mbcs_encode($module, str, errors=None, /)\n"
@@ -1381,9 +1381,9 @@ exit:
     return return_value;
 }
 
-#endif /* defined(HAVE_MBCS) */
+#endif /* defined(MS_WINDOWS) */
 
-#if defined(HAVE_MBCS)
+#if defined(MS_WINDOWS)
 
 PyDoc_STRVAR(_codecs_oem_encode__doc__,
 "oem_encode($module, str, errors=None, /)\n"
@@ -1413,9 +1413,9 @@ exit:
     return return_value;
 }
 
-#endif /* defined(HAVE_MBCS) */
+#endif /* defined(MS_WINDOWS) */
 
-#if defined(HAVE_MBCS)
+#if defined(MS_WINDOWS)
 
 PyDoc_STRVAR(_codecs_code_page_encode__doc__,
 "code_page_encode($module, code_page, str, errors=None, /)\n"
@@ -1447,7 +1447,7 @@ exit:
     return return_value;
 }
 
-#endif /* defined(HAVE_MBCS) */
+#endif /* defined(MS_WINDOWS) */
 
 PyDoc_STRVAR(_codecs_register_error__doc__,
 "register_error($module, errors, handler, /)\n"
@@ -1536,4 +1536,4 @@ exit:
 #ifndef _CODECS_CODE_PAGE_ENCODE_METHODDEF
     #define _CODECS_CODE_PAGE_ENCODE_METHODDEF
 #endif /* !defined(_CODECS_CODE_PAGE_ENCODE_METHODDEF) */
-/*[clinic end generated code: output=7874e2d559d49368 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=ebe313ab417b17bb input=a9049054013a1b77]*/
-- 
cgit v1.2.1


From daa2ed44798ad45ac665321cae21a23661d0e044 Mon Sep 17 00:00:00 2001
From: Victor Stinner <victor.stinner@gmail.com>
Date: Fri, 9 Sep 2016 20:00:13 -0700
Subject: Issue #27810: Rerun Argument Clinic on all modules

---
 Modules/clinic/_codecsmodule.c.h | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'Modules/clinic/_codecsmodule.c.h')

diff --git a/Modules/clinic/_codecsmodule.c.h b/Modules/clinic/_codecsmodule.c.h
index c7fd66ffb8..056287d06a 100644
--- a/Modules/clinic/_codecsmodule.c.h
+++ b/Modules/clinic/_codecsmodule.c.h
@@ -55,14 +55,14 @@ PyDoc_STRVAR(_codecs_encode__doc__,
 "codecs.register_error that can handle ValueErrors.");
 
 #define _CODECS_ENCODE_METHODDEF    \
-    {"encode", (PyCFunction)_codecs_encode, METH_VARARGS|METH_KEYWORDS, _codecs_encode__doc__},
+    {"encode", (PyCFunction)_codecs_encode, METH_FASTCALL, _codecs_encode__doc__},
 
 static PyObject *
 _codecs_encode_impl(PyObject *module, PyObject *obj, const char *encoding,
                     const char *errors);
 
 static PyObject *
-_codecs_encode(PyObject *module, PyObject *args, PyObject *kwargs)
+_codecs_encode(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     static const char * const _keywords[] = {"obj", "encoding", "errors", NULL};
@@ -71,7 +71,7 @@ _codecs_encode(PyObject *module, PyObject *args, PyObject *kwargs)
     const char *encoding = NULL;
     const char *errors = NULL;
 
-    if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
+    if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
         &obj, &encoding, &errors)) {
         goto exit;
     }
@@ -94,14 +94,14 @@ PyDoc_STRVAR(_codecs_decode__doc__,
 "codecs.register_error that can handle ValueErrors.");
 
 #define _CODECS_DECODE_METHODDEF    \
-    {"decode", (PyCFunction)_codecs_decode, METH_VARARGS|METH_KEYWORDS, _codecs_decode__doc__},
+    {"decode", (PyCFunction)_codecs_decode, METH_FASTCALL, _codecs_decode__doc__},
 
 static PyObject *
 _codecs_decode_impl(PyObject *module, PyObject *obj, const char *encoding,
                     const char *errors);
 
 static PyObject *
-_codecs_decode(PyObject *module, PyObject *args, PyObject *kwargs)
+_codecs_decode(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     static const char * const _keywords[] = {"obj", "encoding", "errors", NULL};
@@ -110,7 +110,7 @@ _codecs_decode(PyObject *module, PyObject *args, PyObject *kwargs)
     const char *encoding = NULL;
     const char *errors = NULL;
 
-    if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
+    if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser,
         &obj, &encoding, &errors)) {
         goto exit;
     }
@@ -1536,4 +1536,4 @@ exit:
 #ifndef _CODECS_CODE_PAGE_ENCODE_METHODDEF
     #define _CODECS_CODE_PAGE_ENCODE_METHODDEF
 #endif /* !defined(_CODECS_CODE_PAGE_ENCODE_METHODDEF) */
-/*[clinic end generated code: output=ebe313ab417b17bb input=a9049054013a1b77]*/
+/*[clinic end generated code: output=6d6afcabde10ed79 input=a9049054013a1b77]*/
-- 
cgit v1.2.1