pythongh-110289: C API: Add PyUnicode_EqualToString() function

Doc/c-api/unicode.rst

@@ -1396,6 +1396,16 @@ They all return ``NULL`` or ``-1`` if an exception occurs.
    :c:func:`PyErr_Occurred` to check for errors.
 
 
+.. c:function:: int PyUnicode_EqualToString(PyObject *unicode, const char *string)
+
+   Compare a Unicode object with a UTF-8 encoded C string and return true
+   if they are equal and false otherwise.
+
+   This function does not raise exceptions.
+
+   .. versionadded:: 3.13
+
+
 .. c:function:: int PyUnicode_CompareWithASCIIString(PyObject *uni, const char *string)
 
    Compare a Unicode object, *uni*, with *string* and return ``-1``, ``0``, ``1`` for less

Doc/whatsnew/3.13.rst

@@ -1001,6 +1001,13 @@ New Features
   :c:macro:`Py_TPFLAGS_MANAGED_DICT` flag.
   (Contributed by Victor Stinner in :gh:`107073`.)
 
+* Add :c:func:`PyUnicode_EqualToString` function: compare Unicode object with
+  a :c:expr:`const char*` UTF-8 encoded bytes string and return true if they
+  are equal or false otherwise.
+  This function does not raise exceptions.
+  (Contributed by Serhiy Storchaka in :gh:`110289`.)
+
+
 Porting to Python 3.13
 ----------------------
 

Include/unicodeobject.h

@@ -957,6 +957,14 @@ PyAPI_FUNC(int) PyUnicode_CompareWithASCIIString(
     const char *right           /* ASCII-encoded string */
     );
 
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030D0000
+/* Compare a Unicode object with UTF-8 encoded C string and return 1 for equal
+   and 0 otherwise.
+   This function does not raise exceptions. */
+
+PyAPI_FUNC(int) PyUnicode_EqualToString(PyObject *, const char *);
+#endif
+
 /* Rich compare two strings and return one of the following:
 
    - NULL in case an exception was raised

Misc/NEWS.d/next/C API/2023-10-03-19-01-20.gh-issue-110289.YBIHEz.rst

@@ -0,0 +1 @@
+Add :c:func:`PyUnicode_EqualToString` function.

Misc/stable_abi.toml

@@ -2460,3 +2460,5 @@
     added = '3.13'
 [function.PyMapping_HasKeyStringWithError]
     added = '3.13'
+[function.PyUnicode_EqualToString]
+    added = '3.13'

Objects/unicodeobject.c

@@ -10673,6 +10673,67 @@ PyUnicode_CompareWithASCIIString(PyObject* uni, const char* str)
     }
 }
 
+int
+PyUnicode_EqualToString(PyObject *unicode, const char *str)
+{
+    assert(_PyUnicode_CHECK(unicode));
+    assert(str);
+    if (PyUnicode_IS_ASCII(unicode)) {
+        size_t len = (size_t)PyUnicode_GET_LENGTH(unicode);
+        return strlen(str) == len &&
+            memcmp(PyUnicode_1BYTE_DATA(unicode), str, len) == 0;
+    }
+    if (PyUnicode_UTF8(unicode) != NULL) {
+        size_t len = (size_t)PyUnicode_UTF8_LENGTH(unicode);
+        return strlen(str) == len &&
+            memcmp(PyUnicode_UTF8(unicode), str, len) == 0;
+    }
+
+    Py_UCS4 ch;
+    Py_ssize_t len = PyUnicode_GET_LENGTH(unicode);
+    int kind = PyUnicode_KIND(unicode);
+    const void *data = PyUnicode_DATA(unicode);
+    /* Compare Unicode string and UTF-8 string */
+    for (Py_ssize_t i = 0; i < len; i++) {
+        ch = PyUnicode_READ(kind, data, i);
+        if (ch == 0x80) {
+            return 0;
+        }
+        else if (ch < 0x80) {
+            if (ch != (unsigned char)*str++) {
+                return 0;
+            }
+        }
+        else if (ch < 0x800) {
+            if ((0xc0 | (ch >> 6)) != (unsigned char)*str++ ||
+                (0x80 | (ch & 0x3f)) != (unsigned char)*str++)
+            {
+                return 0;
+            }
+        }
+        else if (ch < 0x10000) {
+            if (Py_UNICODE_IS_SURROGATE(ch) ||
+                (0xe0 | (ch >> 12)) != (unsigned char)*str++ ||
+                (0x80 | ((ch >> 6) & 0x3f)) != (unsigned char)*str++ ||
+                (0x80 | (ch & 0x3f)) != (unsigned char)*str++)
+            {
+                return 0;
+            }
+        }
+        else {
+            assert(ch <= MAX_UNICODE);
+            if ((0xf0 | (ch >> 18)) != (unsigned char)*str++ ||
+                (0x80 | ((ch >> 12) & 0x3f)) != (unsigned char)*str++ ||
+                (0x80 | ((ch >> 6) & 0x3f)) != (unsigned char)*str++ ||
+                (0x80 | (ch & 0x3f)) != (unsigned char)*str++)
+            {
+                return 0;
+            }
+        }
+    }
+    return *str == 0;
+}
+
 int
 _PyUnicode_EqualToASCIIString(PyObject *unicode, const char *str)
 {