diff --git a/Tools/clinic/clinic.py b/Tools/clinic/clinic.py index 7525c1ca524003..0d712236a25f26 100755 --- a/Tools/clinic/clinic.py +++ b/Tools/clinic/clinic.py @@ -3049,40 +3049,37 @@ def pre_render(self) -> None: pass def parse_arg(self, argname: str, displayname: str) -> str | None: + paramname, converter = self.parser_name, self.converter if self.format_unit == 'O&': - return """ + return f""" if (!{converter}({argname}, &{paramname})) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name, - converter=self.converter) + """ if self.format_unit == 'O!': cast = '(%s)' % self.type if self.type != 'PyObject *' else '' if self.subclass_of in type_checks: typecheck, typename = type_checks[self.subclass_of] - return """ + return f""" if (!{typecheck}({argname})) {{{{ _PyArg_BadArgument("{{name}}", {displayname}, "{typename}", {argname}); goto exit; }}}} {paramname} = {cast}{argname}; - """.format(argname=argname, paramname=self.parser_name, - displayname=displayname, typecheck=typecheck, - typename=typename, cast=cast) - return """ + """ + subclass_of = self.subclass_of + return f""" if (!PyObject_TypeCheck({argname}, {subclass_of})) {{{{ _PyArg_BadArgument("{{name}}", {displayname}, ({subclass_of})->tp_name, {argname}); goto exit; }}}} {paramname} = {cast}{argname}; - """.format(argname=argname, paramname=self.parser_name, - subclass_of=self.subclass_of, cast=cast, - displayname=displayname) + """ if self.format_unit == 'O': cast = '(%s)' % self.type if self.type != 'PyObject *' else '' - return """ + return f""" {paramname} = {cast}{argname}; - """.format(argname=argname, paramname=self.parser_name, cast=cast) + """ return None def set_template_dict(self, template_dict: TemplateDict) -> None: @@ -3152,22 +3149,24 @@ def converter_init(self, *, accept: TypeSet = {object}) -> None: self.c_default = str(int(self.default)) def parse_arg(self, argname: str, displayname: str) -> str | None: + paramname = self.parser_name if self.format_unit == 'i': - return """ + return f""" {paramname} = _PyLong_AsInt({argname}); if ({paramname} == -1 && PyErr_Occurred()) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name) + """ elif self.format_unit == 'p': - return """ + return f""" {paramname} = PyObject_IsTrue({argname}); if ({paramname} < 0) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) + class defining_class_converter(CConverter): """ A special-case converter: @@ -3204,7 +3203,8 @@ def converter_init(self) -> None: def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'c': - return """ + paramname = self.parser_name + return f""" if (PyBytes_Check({argname}) && PyBytes_GET_SIZE({argname}) == 1) {{{{ {paramname} = PyBytes_AS_STRING({argname})[0]; }}}} @@ -3215,8 +3215,7 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: _PyArg_BadArgument("{{name}}", {displayname}, "a byte string of length 1", {argname}); goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name, - displayname=displayname) + """ return super().parse_arg(argname, displayname) @@ -3232,8 +3231,9 @@ def converter_init(self, *, bitwise: bool = False) -> None: self.format_unit = 'B' def parse_arg(self, argname: str, displayname: str) -> str | None: + paramname = self.parser_name if self.format_unit == 'b': - return """ + return f""" {{{{ long ival = PyLong_AsLong({argname}); if (ival == -1 && PyErr_Occurred()) {{{{ @@ -3253,9 +3253,9 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: {paramname} = (unsigned char) ival; }}}} }}}} - """.format(argname=argname, paramname=self.parser_name) + """ elif self.format_unit == 'B': - return """ + return f""" {{{{ unsigned long ival = PyLong_AsUnsignedLongMask({argname}); if (ival == (unsigned long)-1 && PyErr_Occurred()) {{{{ @@ -3265,7 +3265,7 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: {paramname} = (unsigned char) ival; }}}} }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) class byte_converter(unsigned_char_converter): pass @@ -3278,7 +3278,8 @@ class short_converter(CConverter): def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'h': - return """ + paramname = self.parser_name + return f""" {{{{ long ival = PyLong_AsLong({argname}); if (ival == -1 && PyErr_Occurred()) {{{{ @@ -3298,7 +3299,7 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: {paramname} = (short) ival; }}}} }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) class unsigned_short_converter(CConverter): @@ -3314,12 +3315,13 @@ def converter_init(self, *, bitwise: bool = False) -> None: def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'H': - return """ + paramname = self.parser_name + return f""" {paramname} = (unsigned short)PyLong_AsUnsignedLongMask({argname}); if ({paramname} == (unsigned short)-1 && PyErr_Occurred()) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) @add_legacy_c_converter('C', accept={str}) @@ -3340,15 +3342,16 @@ def converter_init( self.type = type def parse_arg(self, argname: str, displayname: str) -> str | None: + paramname = self.parser_name if self.format_unit == 'i': - return """ + return f""" {paramname} = _PyLong_AsInt({argname}); if ({paramname} == -1 && PyErr_Occurred()) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name) + """ elif self.format_unit == 'C': - return """ + return f""" if (!PyUnicode_Check({argname})) {{{{ _PyArg_BadArgument("{{name}}", {displayname}, "a unicode character", {argname}); goto exit; @@ -3358,8 +3361,7 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: goto exit; }}}} {paramname} = PyUnicode_READ_CHAR({argname}, 0); - """.format(argname=argname, paramname=self.parser_name, - displayname=displayname) + """ return super().parse_arg(argname, displayname) class unsigned_int_converter(CConverter): @@ -3375,12 +3377,13 @@ def converter_init(self, *, bitwise: bool = False) -> None: def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'I': - return """ + paramname = self.parser_name + return f""" {paramname} = (unsigned int)PyLong_AsUnsignedLongMask({argname}); if ({paramname} == (unsigned int)-1 && PyErr_Occurred()) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) class long_converter(CConverter): @@ -3391,12 +3394,13 @@ class long_converter(CConverter): def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'l': - return """ + paramname = self.parser_name + return f""" {paramname} = PyLong_AsLong({argname}); if ({paramname} == -1 && PyErr_Occurred()) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) class unsigned_long_converter(CConverter): @@ -3412,14 +3416,14 @@ def converter_init(self, *, bitwise: bool = False) -> None: def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'k': - return """ + paramname = self.parser_name + return f""" if (!PyLong_Check({argname})) {{{{ _PyArg_BadArgument("{{name}}", {displayname}, "int", {argname}); goto exit; }}}} {paramname} = PyLong_AsUnsignedLongMask({argname}); - """.format(argname=argname, paramname=self.parser_name, - displayname=displayname) + """ return super().parse_arg(argname, displayname) class long_long_converter(CConverter): @@ -3430,12 +3434,13 @@ class long_long_converter(CConverter): def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'L': - return """ + paramname = self.parser_name + return f""" {paramname} = PyLong_AsLongLong({argname}); if ({paramname} == -1 && PyErr_Occurred()) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) class unsigned_long_long_converter(CConverter): @@ -3451,14 +3456,14 @@ def converter_init(self, *, bitwise: bool = False) -> None: def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'K': - return """ + paramname = self.parser_name + return f""" if (!PyLong_Check({argname})) {{{{ _PyArg_BadArgument("{{name}}", {displayname}, "int", {argname}); goto exit; }}}} {paramname} = PyLong_AsUnsignedLongLongMask({argname}); - """.format(argname=argname, paramname=self.parser_name, - displayname=displayname) + """ return super().parse_arg(argname, displayname) class Py_ssize_t_converter(CConverter): @@ -3476,7 +3481,8 @@ def converter_init(self, *, accept: TypeSet = {int}) -> None: def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'n': - return """ + paramname = self.parser_name + return f""" {{{{ Py_ssize_t ival = -1; PyObject *iobj = _PyNumber_Index({argname}); @@ -3489,7 +3495,7 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: }}}} {paramname} = ival; }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) @@ -3511,12 +3517,13 @@ class size_t_converter(CConverter): def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'n': - return """ + paramname = self.parser_name + return f""" {paramname} = PyNumber_AsSsize_t({argname}, PyExc_OverflowError); if ({paramname} == -1 && PyErr_Occurred()) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) @@ -3525,12 +3532,13 @@ class fildes_converter(CConverter): converter = '_PyLong_FileDescriptor_Converter' def _parse_arg(self, argname: str, displayname: str) -> str | None: - return """ + paramname = self.name + return f""" {paramname} = PyObject_AsFileDescriptor({argname}); if ({paramname} == -1) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.name) + """ class float_converter(CConverter): @@ -3541,7 +3549,8 @@ class float_converter(CConverter): def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'f': - return """ + paramname = self.parser_name + return f""" if (PyFloat_CheckExact({argname})) {{{{ {paramname} = (float) (PyFloat_AS_DOUBLE({argname})); }}}} @@ -3552,7 +3561,7 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: goto exit; }}}} }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) class double_converter(CConverter): @@ -3563,7 +3572,8 @@ class double_converter(CConverter): def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'd': - return """ + paramname = self.parser_name + return f""" if (PyFloat_CheckExact({argname})) {{{{ {paramname} = PyFloat_AS_DOUBLE({argname}); }}}} @@ -3574,7 +3584,7 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: goto exit; }}}} }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) @@ -3586,12 +3596,13 @@ class Py_complex_converter(CConverter): def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'D': - return """ + paramname = self.parser_name + return f""" {paramname} = PyComplex_AsCComplex({argname}); if (PyErr_Occurred()) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name) + """ return super().parse_arg(argname, displayname) @@ -3678,8 +3689,9 @@ def post_parsing(self) -> str: return "" def parse_arg(self, argname: str, displayname: str) -> str | None: + paramname = self.parser_name if self.format_unit == 's': - return """ + return f""" if (!PyUnicode_Check({argname})) {{{{ _PyArg_BadArgument("{{name}}", {displayname}, "str", {argname}); goto exit; @@ -3693,10 +3705,9 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: PyErr_SetString(PyExc_ValueError, "embedded null character"); goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name, - displayname=displayname) + """ if self.format_unit == 'z': - return """ + return f""" if ({argname} == Py_None) {{{{ {paramname} = NULL; }}}} @@ -3715,8 +3726,7 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: _PyArg_BadArgument("{{name}}", {displayname}, "str or None", {argname}); goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name, - displayname=displayname) + """ return super().parse_arg(argname, displayname) # @@ -3781,14 +3791,13 @@ class PyBytesObject_converter(CConverter): def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'S': - return """ + return f""" if (!PyBytes_Check({argname})) {{{{ _PyArg_BadArgument("{{name}}", {displayname}, "bytes", {argname}); goto exit; }}}} - {paramname} = ({type}){argname}; - """.format(argname=argname, paramname=self.parser_name, - type=self.type, displayname=displayname) + {self.parser_name} = ({self.type}){argname}; + """ return super().parse_arg(argname, displayname) class PyByteArrayObject_converter(CConverter): @@ -3798,14 +3807,13 @@ class PyByteArrayObject_converter(CConverter): def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'Y': - return """ + return f""" if (!PyByteArray_Check({argname})) {{{{ _PyArg_BadArgument("{{name}}", {displayname}, "bytearray", {argname}); goto exit; }}}} - {paramname} = ({type}){argname}; - """.format(argname=argname, paramname=self.parser_name, - type=self.type, displayname=displayname) + {self.parser_name} = ({self.type}){argname}; + """ return super().parse_arg(argname, displayname) class unicode_converter(CConverter): @@ -3815,14 +3823,14 @@ class unicode_converter(CConverter): def parse_arg(self, argname: str, displayname: str) -> str | None: if self.format_unit == 'U': - return """ + paramname = self.parser_name + return f""" if (!PyUnicode_Check({argname})) {{{{ _PyArg_BadArgument("{{name}}", {displayname}, "str", {argname}); goto exit; }}}} {paramname} = {argname}; - """.format(argname=argname, paramname=self.parser_name, - displayname=displayname) + """ return super().parse_arg(argname, displayname) @add_legacy_c_converter('u') @@ -3857,14 +3865,13 @@ def cleanup(self) -> str: if self.length: return "" else: - return """\ -PyMem_Free((void *){name}); -""".format(name=self.name) + return f"PyMem_Free((void *){self.name});\n" def parse_arg(self, argname: str, argnum: str) -> str | None: if not self.length: + paramname = self.name if self.accept == {str}: - return """ + return f""" if (!PyUnicode_Check({argname})) {{{{ _PyArg_BadArgument("{{name}}", {argnum}, "str", {argname}); goto exit; @@ -3873,9 +3880,9 @@ def parse_arg(self, argname: str, argnum: str) -> str | None: if ({paramname} == NULL) {{{{ goto exit; }}}} - """.format(argname=argname, paramname=self.name, argnum=argnum) + """ elif self.accept == {str, NoneType}: - return """ + return f""" if ({argname} == Py_None) {{{{ {paramname} = NULL; }}}} @@ -3889,7 +3896,7 @@ def parse_arg(self, argname: str, argnum: str) -> str | None: _PyArg_BadArgument("{{name}}", {argnum}, "str or None", {argname}); goto exit; }}}} - """.format(argname=argname, paramname=self.name, argnum=argnum) + """ return super().parse_arg(argname, argnum) @add_legacy_c_converter('s*', accept={str, buffer}) @@ -3925,8 +3932,9 @@ def cleanup(self) -> str: return "".join(["if (", name, ".obj) {\n PyBuffer_Release(&", name, ");\n}\n"]) def parse_arg(self, argname: str, displayname: str) -> str | None: + paramname = self.parser_name if self.format_unit == 'y*': - return """ + return f""" if (PyObject_GetBuffer({argname}, &{paramname}, PyBUF_SIMPLE) != 0) {{{{ goto exit; }}}} @@ -3934,10 +3942,9 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: _PyArg_BadArgument("{{name}}", {displayname}, "contiguous buffer", {argname}); goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name, - displayname=displayname) + """ elif self.format_unit == 's*': - return """ + return f""" if (PyUnicode_Check({argname})) {{{{ Py_ssize_t len; const char *ptr = PyUnicode_AsUTF8AndSize({argname}, &len); @@ -3955,10 +3962,9 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: goto exit; }}}} }}}} - """.format(argname=argname, paramname=self.parser_name, - displayname=displayname) + """ elif self.format_unit == 'w*': - return """ + return f""" if (PyObject_GetBuffer({argname}, &{paramname}, PyBUF_WRITABLE) < 0) {{{{ PyErr_Clear(); _PyArg_BadArgument("{{name}}", {displayname}, "read-write bytes-like object", {argname}); @@ -3968,8 +3974,7 @@ def parse_arg(self, argname: str, displayname: str) -> str | None: _PyArg_BadArgument("{{name}}", {displayname}, "contiguous buffer", {argname}); goto exit; }}}} - """.format(argname=argname, paramname=self.parser_name, - displayname=displayname) + """ return super().parse_arg(argname, displayname)