refactor macros

python · picnixz · Jul 6, 2024 · Jul 6, 2024 · Jul 6, 2024 · Jul 6, 2024
commit 3a0567670225b993aea7e029d6b436ae94405faa
diff --git a/Modules/_fnmatch/macros.h b/Modules/_fnmatch/macros.h
@@ -9,15 +9,16 @@
 // ==== Macro definitions =====================================================
 
 /*
- * Check that INTVAL is >= 0 or execute 'goto abort'.
+ * Check that STATUS is >= 0 or execute 'goto abort'.
  *
  * This macro is provided for convenience and should be
  * carefully used if more resources should be released
  * before jumping to the 'abort' label.
  */
-#define CHECK_INTVAL_OR_ABORT(INTVAL)   \
+#define CHECK_RET_CODE_OR_ABORT(STATUS) \
     do {                                \
-        if ((INTVAL) < 0) {             \
+        if ((STATUS) < 0) {             \
+            assert(PyErr_Occurred());   \
             goto abort;                 \
         }                               \
     } while (0)
@@ -29,11 +30,11 @@
  * carefully used if more resources should be released
  * before jumping to the 'abort' label.
  */
-#define CHECK_NON_NULL_OR_ABORT(OBJ)  \
-    do {                        \
-        if ((OBJ) == NULL) {    \
-            goto abort;         \
-        }                       \
+#define CHECK_NOT_NULL_OR_ABORT(OBJ)    \
+    do {                                \
+        if ((OBJ) == NULL) {            \
+            goto abort;                 \
+        }                               \
     } while (0)
 
 // The following _WRITE_* and _WRITE_*_OR macros do NOT check their inputs
@@ -54,67 +55,41 @@
     _PyUnicodeWriter_WriteStr((_PyUnicodeWriter *)(WRITER), (STRING))
 
 /* Cast WRITER and call _PyUnicodeWriter_WriteSubstring(). */
-#define _WRITE_BLOCK(WRITER, STRING, START, STOP)                   \
+#define _WRITE_SUBSTRING(WRITER, STRING, START, STOP)               \
     _PyUnicodeWriter_WriteSubstring((_PyUnicodeWriter *)(WRITER),   \
                                     (STRING), (START), (STOP))
 
 // ----------------------------------------------------------------------------
 
-/* Write a character CHAR or execute the ON_ERROR statements if it fails. */
-#define _WRITE_CHAR_OR(WRITER, CHAR, ON_ERROR)      \
-    do {                                            \
-        if (_WRITE_CHAR((WRITER), (CHAR)) < 0) {    \
-            ON_ERROR;                               \
-        }                                           \
-    } while (0)
+/* Write the character CHAR or jump to the 'abort' label on failure. */
+#define WRITE_CHAR_OR_ABORT(WRITER, CHAR) \
+        CHECK_RET_CODE_OR_ABORT(_WRITE_CHAR((WRITER), (CHAR)))
 
 /*
  * Write an ASCII string STRING of given length LENGTH,
- * or execute the ON_ERROR statements if it fails.
+ * or jump to the 'abort' label on failure.
  */
-#define _WRITE_ASCII_OR(WRITER, ASCII, LENGTH, ON_ERROR)        \
-    do {                                                        \
-        if (_WRITE_ASCII((WRITER), (ASCII), (LENGTH)) < 0) {    \
-            ON_ERROR;                                           \
-        }                                                       \
-    } while (0)
+#define WRITE_ASCII_OR_ABORT(WRITER, ASCII, LENGTH)  \
+    CHECK_RET_CODE_OR_ABORT(_WRITE_ASCII((WRITER), (ASCII), (LENGTH)))
 
-/* Write the string STRING or execute the ON_ERROR statements if it fails. */
-#define _WRITE_STRING_OR(WRITER, STRING, ON_ERROR)      \
-    do {                                                \
-        if (_WRITE_STRING((WRITER), (STRING)) < 0) {    \
-            ON_ERROR;                                   \
-        }                                               \
-    } while (0)
+/* Write the string STRING or jump to the 'abort' label on failure. */
+#define WRITE_STRING_OR_ABORT(WRITER, STRING)  \
+    CHECK_RET_CODE_OR_ABORT(_WRITE_STRING((WRITER), (STRING)))
 
 /*
- * Write the substring STRING[START:STOP] (no-op if the substring is empty)
- * or execute the ON_ERROR statements if it fails.
+ * Write the substring STRING[START:STOP] (no-op if empty)
+ * or jump to the 'abort' label on failure.
  */
-#define _WRITE_SUBSTRING_OR(WRITER, STRING, START, STOP, ON_ERROR)      \
+#define WRITE_SUBSTRING_OR_ABORT(WRITER, STRING, START, STOP)           \
     do {                                                                \
-        /* intermediate variables to allow in-place operations */       \
-        Py_ssize_t _i = (START), _j = (STOP);                           \
-        if (_i < _j && _WRITE_BLOCK((WRITER), (STRING), _i, _j) < 0) {  \
-            ON_ERROR;                                                   \
-        }                                                               \
+        const Py_ssize_t _START = (START);                              \
+        const Py_ssize_t _STOP = (STOP);                                \
+        int _RC = _WRITE_SUBSTRING((WRITER), (STRING), _START, _STOP);  \
+        CHECK_RET_CODE_OR_ABORT(_RC);                                   \
     } while (0)
 
 // ----------------------------------------------------------------------------
 
-// Macros which execute "goto abort" if an error occurs.
-
-#define WRITE_CHAR_OR_ABORT(WRITER, CHAR) \
-    _WRITE_CHAR_OR((WRITER), (CHAR), goto abort)
-#define WRITE_ASCII_OR_ABORT(WRITER, STRING, LENGTH) \
-    _WRITE_ASCII_OR((WRITER), (STRING), (LENGTH), goto abort)
-#define WRITE_STRING_OR_ABORT(WRITER, STRING) \
-    _WRITE_STRING_OR((WRITER), (STRING), goto abort)
-#define WRITE_BLOCK_OR_ABORT(WRITER, STRING, START, STOP) \
-    _WRITE_SUBSTRING_OR((WRITER), (STRING), (START), (STOP), goto abort)
-
-// ----------------------------------------------------------------------------
-
 /* Replace backslashes in STRING by escaped backslashes. */
 #define BACKSLASH_REPLACE(STATE, STRING)    \
     PyObject_CallMethodObjArgs(             \

diff --git a/Modules/_fnmatch/translate.c b/Modules/_fnmatch/translate.c
@@ -116,16 +116,16 @@ _Py_fnmatch_translate(PyObject *module, PyObject *pattern)
     PyObject *pattern_str_find_meth = NULL; // pattern.find()
     // ---- def local objects -------------------------------------------------
     wildcard_indices = PyList_New(0);
-    CHECK_NON_NULL_OR_ABORT(wildcard_indices);
+    CHECK_NOT_NULL_OR_ABORT(wildcard_indices);
     // The Python implementation always takes queries re.escape() and re.sub()
     // inside translate() and thus we should at least allow external users to
     // mock those functions (thus, we cannot cache them in the module's state).
     re_escape_func = PyObject_GetAttr(state->re_module, &_Py_ID(escape));
-    CHECK_NON_NULL_OR_ABORT(re_escape_func);
+    CHECK_NOT_NULL_OR_ABORT(re_escape_func);
     setops_re_subfn = get_setops_re_sub_method(state);
-    CHECK_NON_NULL_OR_ABORT(setops_re_subfn);
+    
6D40
CHECK_NOT_NULL_OR_ABORT(setops_re_subfn);
     pattern_str_find_meth = PyObject_GetAttr(pattern, &_Py_ID(find));
-    CHECK_NON_NULL_OR_ABORT(pattern_str_find_meth);
+    CHECK_NOT_NULL_OR_ABORT(pattern_str_find_meth);
     // ------------------------------------------------------------------------
     const int pattern_kind = PyUnicode_KIND(pattern);
     const void *const pattern_data = PyUnicode_DATA(pattern);
@@ -144,7 +144,9 @@ _Py_fnmatch_translate(PyObject *module, PyObject *pattern)
             Py_ssize_t t = escape_block(writer, pattern,        \
                                         escstart, (ESCSTOP),    \
                                         re_escape_func);        \
-            CHECK_INTVAL_OR_ABORT(t);                           \
+            if (t < 0) {                                        \
+                goto abort;                                     \
+            }                                                   \
             written += t;                                       \
             escstart = -1;                                      \
         }                                                       \
@@ -164,10 +166,10 @@ _Py_fnmatch_translate(PyObject *module, PyObject *pattern)
                 for (; i < maxind && READ_CHAR(i) == '*'; ++i);
                 // store the position of the wildcard
                 PyObject *wildcard_index = PyLong_FromSsize_t(written++);
-                CHECK_NON_NULL_OR_ABORT(wildcard_index);
+                CHECK_NOT_NULL_OR_ABORT(wildcard_index);
                 int rc = PyList_Append(wildcard_indices, wildcard_index);
                 Py_DECREF(wildcard_index);
-                CHECK_INTVAL_OR_ABORT(rc);
+                CHECK_RET_CODE_OR_ABORT(rc);
                 break;
             }
             case '?': {
@@ -198,19 +200,21 @@ _Py_fnmatch_translate(PyObject *module, PyObject *pattern)
                     PyObject *expr = NULL;
                     if (pos == -1) {
                         PyObject *tmp = PyUnicode_Substring(pattern, i, j);
-                        CHECK_NON_NULL_OR_ABORT(tmp);
+                        CHECK_NOT_NULL_OR_ABORT(tmp);
                         expr = BACKSLASH_REPLACE(state, tmp);
                         Py_DECREF(tmp);
                     }
                     else {
                         expr = translate_expression(state, pattern, i, j,
                                                     pattern_str_find_meth);
                     }
-                    CHECK_NON_NULL_OR_ABORT(expr);
+                    CHECK_NOT_NULL_OR_ABORT(expr);
                     Py_ssize_t expr_len = write_expression(state, writer, expr,
                                                            setops_re_subfn);
                     Py_DECREF(expr);
-                    CHECK_INTVAL_OR_ABORT(expr_len);
+                    if (expr_len < 0) {
+                        goto abort;
+                    }
                     written += expr_len;
                     i = j + 1;  // jump to the character after ']'
                     break;      // explicit early break for clarity
@@ -264,14 +268,14 @@ escape_block(PyUnicodeWriter *writer,
     }
 #endif
     PyObject *str = PyUnicode_Substring(pattern, start, stop);
-    CHECK_NON_NULL_OR_ABORT(str);
+    CHECK_NOT_NULL_OR_ABORT(str);
     PyObject *escaped = PyObject_CallOneArg(re_escape_func, str);
     Py_DECREF(str);
-    CHECK_NON_NULL_OR_ABORT(escaped);
+    CHECK_NOT_NULL_OR_ABORT(escaped);
     Py_ssize_t written = PyUnicode_GET_LENGTH(escaped);
     int rc = _WRITE_STRING(writer, escaped);
     Py_DECREF(escaped);
-    CHECK_INTVAL_OR_ABORT(rc);
+    CHECK_RET_CODE_OR_ABORT(rc);
     return written;
 abort:
     return -1;
@@ -294,18 +298,18 @@ split_expression(fnmatchmodule_state *state,
     PyObject *hyphen = state->hyphen_str;
     // ---- def local objects -------------------------------------------------
     chunks = PyList_New(0);
-    CHECK_NON_NULL_OR_ABORT(chunks);
+    CHECK_NOT_NULL_OR_ABORT(chunks);
     maxind = PyLong_FromSsize_t(stop);
-    CHECK_NON_NULL_OR_ABORT(maxind);
+    CHECK_NOT_NULL_OR_ABORT(maxind);
     // ---- def local macros --------------------------------------------------
     /* add pattern[START:STOP] to the list of chunks */
 #define ADD_CHUNK(START, STOP)                                              \
     do {                                                                    \
         PyObject *chunk = PyUnicode_Substring(pattern, (START), (STOP));    \
-        CHECK_NON_NULL_OR_ABORT(chunk);                                     \
+        CHECK_NOT_NULL_OR_ABORT(chunk);                                     \
         int rc = PyList_Append(chunks, chunk);                              \
         Py_DECREF(chunk);                                                   \
-        CHECK_INTVAL_OR_ABORT(rc);                                          \
+        CHECK_RET_CODE_OR_ABORT(rc);                                        \
     } while (0)
     // ------------------------------------------------------------------------
     Py_ssize_t chunk_start = start;
@@ -315,7 +319,7 @@ split_expression(fnmatchmodule_state *state,
     while (ind < stop) {
         PyObject *p_chunk_stop = PyObject_CallFunction(str_find_func, "OnO",
                                                        hyphen, ind, maxind);
-        CHECK_NON_NULL_OR_ABORT(p_chunk_stop);
+        CHECK_NOT_NULL_OR_ABORT(p_chunk_stop);
         Py_ssize_t chunk_stop = PyLong_AsSsize_t(p_chunk_stop);
         Py_DECREF(p_chunk_stop);
         if (chunk_stop < 0) {
@@ -396,14 +400,14 @@ simplify_expression(PyObject *chunks)
                 assert(c1len > 1);
                 assert(c2len > 1);
                 PyUnicodeWriter *writer = PyUnicodeWriter_Create(olen);
-                CHECK_NON_NULL_OR_ABORT(writer);
+                CHECK_NOT_NULL_OR_ABORT(writer);
                 // all but the last character in the first chunk
-                if (_WRITE_BLOCK(writer, c1, 0, c1len - 1) < 0) {
+                if (_WRITE_SUBSTRING(writer, c1, 0, c1len - 1) < 0) {
                     PyUnicodeWriter_Discard(writer);
                     goto abort;
                 }
                 // all but the first character in the second chunk
-                if (_WRITE_BLOCK(writer, c2, 1, c2len) < 0) {
+                if (_WRITE_SUBSTRING(writer, c2, 1, c2len) < 0) {
                     PyUnicodeWriter_Discard(writer);
                     goto abort;
                 }
@@ -416,7 +420,7 @@ simplify_expression(PyObject *chunks)
                 Py_XDECREF(str);
                 goto abort;
             }
-            CHECK_INTVAL_OR_ABORT(PySequence_DelItem(chunks, k));
+            CHECK_RET_CODE_OR_ABORT(PySequence_DelItem(chunks, k));
         }
     }
     return 0;
@@ -437,7 +441,7 @@ escape_expression(fnmatchmodule_state *state, PyObject *chunks)
         PyObject *s0 = PyList_GET_ITEM(chunks, c);
         assert(s0 != NULL);
         PyObject *s1 = BACKSLASH_REPLACE(state, s0);
-        CHECK_NON_NULL_OR_ABORT(s1);
+        CHECK_NOT_NULL_OR_ABORT(s1);
         PyObject *s2 = HYPHEN_REPLACE(state, s1);
         Py_DECREF(s1);
         // PyList_SetItem() does not create a new reference on 's2'
@@ -460,11 +464,11 @@ translate_expression(fnmatchmodule_state *state,
 {
     PyObject *chunks = split_expression(state, pattern, start, stop,
                                         pattern_str_find_meth);
-    CHECK_NON_NULL_OR_ABORT(chunks);
+    CHECK_NOT_NULL_OR_ABORT(chunks);
     // remove empty ranges
-    CHECK_INTVAL_OR_ABORT(simplify_expression(chunks));
+    CHECK_RET_CODE_OR_ABORT(simplify_expression(chunks));
     // escape backslashes and set differences
-    CHECK_INTVAL_OR_ABORT(escape_expression(state, chunks));
+    CHECK_RET_CODE_OR_ABORT(escape_expression(state, chunks));
     PyObject *res = PyUnicode_Join(state->hyphen_str, chunks);
     Py_DECREF(chunks);
     return res;
@@ -495,11 +499,11 @@ write_expression(fnmatchmodule_state *state,
     WRITE_CHAR_OR_ABORT(writer, '[');
     // escape set operations as late as possible
     safe_expression = SETOPS_REPLACE(state, expression, setops_re_sub_meth);
-    CHECK_NON_NULL_OR_ABORT(safe_expression);
+    CHECK_NOT_NULL_OR_ABORT(safe_expression);
     switch (token) {
         case '!': {
             WRITE_CHAR_OR_ABORT(writer, '^'); // replace '!' by '^'
-            WRITE_BLOCK_OR_ABORT(writer, safe_expression, 1, grouplen);
+            WRITE_SUBSTRING_OR_ABORT(writer, safe_expression, 1, grouplen);
             break;
         }
         case '^':
@@ -568,21 +572,21 @@ process_wildcards(PyObject *pattern, PyObject *indices)
         Py_ssize_t i = 0, j = -1;
         // process the optional PREFIX
         LOAD_WILDCARD_INDEX(j, 0);
-        WRITE_BLOCK_OR_ABORT(writer, pattern, 0, j);
+        WRITE_SUBSTRING_OR_ABORT(writer, pattern, i, j);
         i = j + 1;
         for (Py_ssize_t k = 1; k < m; ++k) {
             // process the (* INNER) groups
             LOAD_WILDCARD_INDEX(j, k);
             assert(i < j);
             // write the atomic RE group '(?>.*?' + INNER + ')'
             WRITE_ASCII_OR_ABORT(writer, "(?>.*?", 6);
-            WRITE_BLOCK_OR_ABORT(writer, pattern, i, j);
+            WRITE_SUBSTRING_OR_ABORT(writer, pattern, i, j);
             WRITE_CHAR_OR_ABORT(writer, ')');
             i = j + 1;
         }
         // handle the (*) [OUTER] part
         WRITE_ASCII_OR_ABORT(writer, ".*", 2);
-        WRITE_BLOCK_OR_ABORT(writer, pattern, i, n);
+        WRITE_SUBSTRING_OR_ABORT(writer, pattern, i, n);
     }
     WRITE_ASCII_OR_ABORT(writer, ")\\Z", 3);
     PyObject *res = PyUnicodeWriter_Finish(writer);