GH-103082: Rename PY_MONITORING_EVENTS to _PY_MONITORING_EVENTS (#107069)

vstinner · web-flow · commit 0927a2b25c05 · 2023-07-22T21:35:27.000Z
Rename private C API constants:

* Rename PY_MONITORING_UNGROUPED_EVENTS to _PY_MONITORING_UNGROUPED_EVENTS
* Rename PY_MONITORING_EVENTS to _PY_MONITORING_EVENTS
diff --git a/Include/cpython/code.h b/Include/cpython/code.h
@@ -10,13 +10,13 @@ extern "C" {
 
 
 /* Count of all "real" monitoring events (not derived from other events) */
-#define PY_MONITORING_UNGROUPED_EVENTS 14
+#define _PY_MONITORING_UNGROUPED_EVENTS 14
 /* Count of all  monitoring events */
-#define PY_MONITORING_EVENTS 16
+#define _PY_MONITORING_EVENTS 16
 
 /* Table of which tools are active for each monitored event. */
 typedef struct _Py_Monitors {
-    uint8_t tools[PY_MONITORING_UNGROUPED_EVENTS];
+    uint8_t tools[_PY_MONITORING_UNGROUPED_EVENTS];
 } _Py_Monitors;
 
 /* Each instruction in a code object is a fixed-width value,
diff --git a/Include/internal/pycore_interp.h b/Include/internal/pycore_interp.h
@@ -25,7 +25,7 @@ extern "C" {
 #include "pycore_gc.h"            // struct _gc_runtime_state
 #include "pycore_global_objects.h"  // struct _Py_interp_static_objects
 #include "pycore_import.h"        // struct _import_state
-#include "pycore_instruments.h"   // PY_MONITORING_EVENTS
+#include "pycore_instruments.h"   // _PY_MONITORING_EVENTS
 #include "pycore_list.h"          // struct _Py_list_state
 #include "pycore_object_state.h"   // struct _py_object_state
 #include "pycore_obmalloc.h"      // struct obmalloc_state
@@ -190,7 +190,7 @@ struct _is {
     bool sys_trace_initialized;
     Py_ssize_t sys_profiling_threads; /* Count of threads with c_profilefunc set */
     Py_ssize_t sys_tracing_threads; /* Count of threads with c_tracefunc set */
-    PyObject *monitoring_callables[PY_MONITORING_TOOL_IDS][PY_MONITORING_EVENTS];
+    PyObject *monitoring_callables[PY_MONITORING_TOOL_IDS][_PY_MONITORING_EVENTS];
     PyObject *monitoring_tool_names[PY_MONITORING_TOOL_IDS];
 
     struct _Py_interp_cached_objects cached_objects;
diff --git a/Python/ceval.c b/Python/ceval.c
@@ -1914,7 +1914,7 @@ static int
 do_monitor_exc(PyThreadState *tstate, _PyInterpreterFrame *frame,
                _Py_CODEUNIT *instr, int event)
 {
-    assert(event < PY_MONITORING_UNGROUPED_EVENTS);
+    assert(event < _PY_MONITORING_UNGROUPED_EVENTS);
     PyObject *exc = PyErr_GetRaisedException();
     assert(exc != NULL);
     int err = _Py_call_instrumentation_arg(tstate, event, frame, instr, exc);
diff --git a/Python/instrumentation.c b/Python/instrumentation.c
@@ -137,7 +137,7 @@ is_instrumented(int opcode)
 static inline bool
 monitors_equals(_Py_Monitors a, _Py_Monitors b)
 {
-    for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {
+    for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {
         if (a.tools[i] != b.tools[i]) {
             return false;
         }
@@ -150,7 +150,7 @@ static inline _Py_Monitors
 monitors_sub(_Py_Monitors a, _Py_Monitors b)
 {
     _Py_Monitors res;
-    for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {
+    for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {
         res.tools[i] = a.tools[i] & ~b.tools[i];
     }
     return res;
@@ -161,7 +161,7 @@ static inline _Py_Monitors
 monitors_and(_Py_Monitors a, _Py_Monitors b)
 {
     _Py_Monitors res;
-    for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {
+    for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {
         res.tools[i] = a.tools[i] & b.tools[i];
     }
     return res;
@@ -172,7 +172,7 @@ static inline _Py_Monitors
 monitors_or(_Py_Monitors a, _Py_Monitors b)
 {
     _Py_Monitors res;
-    for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {
+    for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {
         res.tools[i] = a.tools[i] | b.tools[i];
     }
     return res;
@@ -181,7 +181,7 @@ monitors_or(_Py_Monitors a, _Py_Monitors b)
 static inline bool
 monitors_are_empty(_Py_Monitors m)
 {
-    for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {
+    for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {
         if (m.tools[i]) {
             return false;
         }
@@ -192,7 +192,7 @@ monitors_are_empty(_Py_Monitors m)
 static inline bool
 multiple_tools(_Py_Monitors *m)
 {
-    for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {
+    for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {
         if (_Py_popcount32(m->tools[i]) > 1) {
             return true;
         }
@@ -204,7 +204,7 @@ static inline _PyMonitoringEventSet
 get_events(_Py_Monitors *m, int tool_id)
 {
     _PyMonitoringEventSet result = 0;
-    for (int e = 0; e < PY_MONITORING_UNGROUPED_EVENTS; e++) {
+    for (int e = 0; e < _PY_MONITORING_UNGROUPED_EVENTS; e++) {
         if ((m->tools[e] >> tool_id) & 1) {
             result |= (1 << e);
         }
@@ -339,7 +339,7 @@ static void
 dump_monitors(const char *prefix, _Py_Monitors monitors, FILE*out)
 {
     fprintf(out, "%s monitors:\n", prefix);
-    for (int event = 0; event < PY_MONITORING_UNGROUPED_EVENTS; event++) {
+    for (int event = 0; event < _PY_MONITORING_UNGROUPED_EVENTS; event++) {
         fprintf(out, "    Event %d: Tools %x\n", event, monitors.tools[event]);
     }
 }
@@ -907,7 +907,7 @@ get_tools_for_instruction(PyCodeObject *code, PyInterpreterState *interp, int i,
     uint8_t tools;
     assert(event != PY_MONITORING_EVENT_LINE);
     assert(event != PY_MONITORING_EVENT_INSTRUCTION);
-    if (event >= PY_MONITORING_UNGROUPED_EVENTS) {
+    if (event >= _PY_MONITORING_UNGROUPED_EVENTS) {
         assert(event == PY_MONITORING_EVENT_C_RAISE ||
                 event == PY_MONITORING_EVENT_C_RETURN);
         event = PY_MONITORING_EVENT_CALL;
@@ -1220,7 +1220,7 @@ _PyMonitoring_RegisterCallback(int tool_id, int event_id, PyObject *obj)
 {
     PyInterpreterState *is = _PyInterpreterState_GET();
     assert(0 <= tool_id && tool_id < PY_MONITORING_TOOL_IDS);
-    assert(0 <= event_id && event_id < PY_MONITORING_EVENTS);
+    assert(0 <= event_id && event_id < _PY_MONITORING_EVENTS);
     PyObject *callback = is->monitoring_callables[tool_id][event_id];
     is->monitoring_callables[tool_id][event_id] = Py_XNewRef(obj);
     return callback;
@@ -1653,7 +1653,7 @@ static void
 set_events(_Py_Monitors *m, int tool_id, _PyMonitoringEventSet events)
 {
     assert(0 <= tool_id && tool_id < PY_MONITORING_TOOL_IDS);
-    for (int e = 0; e < PY_MONITORING_UNGROUPED_EVENTS; e++) {
+    for (int e = 0; e < _PY_MONITORING_UNGROUPED_EVENTS; e++) {
         uint8_t *tools = &m->tools[e];
         int val = (events >> e) & 1;
         *tools &= ~(1 << tool_id);
@@ -1678,7 +1678,7 @@ _PyMonitoring_SetEvents(int tool_id, _PyMonitoringEventSet events)
 {
     assert(0 <= tool_id && tool_id < PY_MONITORING_TOOL_IDS);
     PyInterpreterState *interp = _PyInterpreterState_GET();
-    assert(events < (1 << PY_MONITORING_UNGROUPED_EVENTS));
+    assert(events < (1 << _PY_MONITORING_UNGROUPED_EVENTS));
     if (check_tool(interp, tool_id)) {
         return -1;
     }
@@ -1696,7 +1696,7 @@ _PyMonitoring_SetLocalEvents(PyCodeObject *code, int tool_id, _PyMonitoringEvent
 {
     assert(0 <= tool_id && tool_id < PY_MONITORING_TOOL_IDS);
     PyInterpreterState *interp = _PyInterpreterState_GET();
-    assert(events < (1 << PY_MONITORING_UNGROUPED_EVENTS));
+    assert(events < (1 << _PY_MONITORING_UNGROUPED_EVENTS));
     if (check_tool(interp, tool_id)) {
         return -1;
     }
@@ -1835,7 +1835,7 @@ monitoring_register_callback_impl(PyObject *module, int tool_id, int event,
         return NULL;
     }
     int event_id = _Py_bit_length(event)-1;
-    if (event_id < 0 || event_id >= PY_MONITORING_EVENTS) {
+    if (event_id < 0 || event_id >= _PY_MONITORING_EVENTS) {
         PyErr_Format(PyExc_ValueError, "invalid event %d", event);
         return NULL;
     }
@@ -1885,7 +1885,7 @@ monitoring_set_events_impl(PyObject *module, int tool_id, int event_set)
     if (check_valid_tool(tool_id))  {
         return NULL;
     }
-    if (event_set < 0 || event_set >= (1 << PY_MONITORING_EVENTS)) {
+    if (event_set < 0 || event_set >= (1 << _PY_MONITORING_EVENTS)) {
         PyErr_Format(PyExc_ValueError, "invalid event set 0x%x", event_set);
         return NULL;
     }
@@ -1927,7 +1927,7 @@ monitoring_get_local_events_impl(PyObject *module, int tool_id,
     _PyMonitoringEventSet event_set = 0;
     _PyCoMonitoringData *data = ((PyCodeObject *)code)->_co_monitoring;
     if (data != NULL) {
-        for (int e = 0; e < PY_MONITORING_UNGROUPED_EVENTS; e++) {
+        for (int e = 0; e < _PY_MONITORING_UNGROUPED_EVENTS; e++) {
             if ((data->local_monitors.tools[e] >> tool_id) & 1) {
                 event_set |= (1 << e);
             }
@@ -1961,7 +1961,7 @@ monitoring_set_local_events_impl(PyObject *module, int tool_id,
     if (check_valid_tool(tool_id))  {
         return NULL;
     }
-    if (event_set < 0 || event_set >= (1 << PY_MONITORING_EVENTS)) {
+    if (event_set < 0 || event_set >= (1 << _PY_MONITORING_EVENTS)) {
         PyErr_Format(PyExc_ValueError, "invalid event set 0x%x", event_set);
         return NULL;
     }
@@ -2042,7 +2042,7 @@ monitoring__all_events_impl(PyObject *module)
     if (res == NULL) {
         return NULL;
     }
-    for (int e = 0; e < PY_MONITORING_UNGROUPED_EVENTS; e++) {
+    for (int e = 0; e < _PY_MONITORING_UNGROUPED_EVENTS; e++) {
         uint8_t tools = interp->monitors.tools[e];
         if (tools == 0) {
             continue;
@@ -2101,7 +2101,7 @@ PyObject *_Py_CreateMonitoringObject(void)
     if (err) {
         goto error;
     }
-    for (int i = 0; i < PY_MONITORING_EVENTS; i++) {
+    for (int i = 0; i < _PY_MONITORING_EVENTS; i++) {
         if (add_power2_constant(events, event_names[i], i)) {
             goto error;
         }
diff --git a/Python/pystate.c b/Python/pystate.c
@@ -679,11 +679,11 @@ init_interpreter(PyInterpreterState *interp,
     _PyGC_InitState(&interp->gc);
     PyConfig_InitPythonConfig(&interp->config);
     _PyType_InitCache(interp);
-    for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {
+    for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {
         interp->monitors.tools[i] = 0;
     }
     for (int t = 0; t < PY_MONITORING_TOOL_IDS; t++) {
-        for (int e = 0; e < PY_MONITORING_EVENTS; e++) {
+        for (int e = 0; e < _PY_MONITORING_EVENTS; e++) {
             interp->monitoring_callables[t][e] = NULL;
 
         }
@@ -841,11 +841,11 @@ interpreter_clear(PyInterpreterState *interp, PyThreadState *tstate)
 
     Py_CLEAR(interp->audit_hooks);
 
-    for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {
+    for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {
         interp->monitors.tools[i] = 0;
     }
     for (int t = 0; t < PY_MONITORING_TOOL_IDS; t++) {
-        for (int e = 0; e < PY_MONITORING_EVENTS; e++) {
+        for (int e = 0; e < _PY_MONITORING_EVENTS; e++) {
             Py_CLEAR(interp->monitoring_callables[t][e]);
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -1914,7 +1914,7 @@ static int`
`1914`	`1914`	`do_monitor_exc(PyThreadState tstate, _PyInterpreterFrame frame,`
`1915`	`1915`	`_Py_CODEUNIT *instr, int event)`
`1916`	`1916`	`{`
`1917`		`- assert(event < PY_MONITORING_UNGROUPED_EVENTS);`
	`1917`	`+ assert(event < _PY_MONITORING_UNGROUPED_EVENTS);`
`1918`	`1918`	`PyObject *exc = PyErr_GetRaisedException();`
`1919`	`1919`	`assert(exc != NULL);`
`1920`	`1920`	`int err = _Py_call_instrumentation_arg(tstate, event, frame, instr, exc);`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ is_instrumented(int opcode)`
`137`	`137`	`static inline bool`
`138`	`138`	`monitors_equals(_Py_Monitors a, _Py_Monitors b)`
`139`	`139`	`{`
`140`		`- for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {`
	`140`	`+ for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {`
`141`	`141`	`if (a.tools[i] != b.tools[i]) {`
`142`	`142`	`return false;`
`143`	`143`	`}`
`@@ -150,7 +150,7 @@ static inline _Py_Monitors`
`150`	`150`	`monitors_sub(_Py_Monitors a, _Py_Monitors b)`
`151`	`151`	`{`
`152`	`152`	`_Py_Monitors res;`
`153`		`- for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {`
	`153`	`+ for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {`
`154`	`154`	`res.tools[i] = a.tools[i] & ~b.tools[i];`
`155`	`155`	`}`
`156`	`156`	`return res;`
`@@ -161,7 +161,7 @@ static inline _Py_Monitors`
`161`	`161`	`monitors_and(_Py_Monitors a, _Py_Monitors b)`
`162`	`162`	`{`
`163`	`163`	`_Py_Monitors res;`
`164`		`- for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {`
	`164`	`+ for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {`
`165`	`165`	`res.tools[i] = a.tools[i] & b.tools[i];`
`166`	`166`	`}`
`167`	`167`	`return res;`
`@@ -172,7 +172,7 @@ static inline _Py_Monitors`
`172`	`172`	`monitors_or(_Py_Monitors a, _Py_Monitors b)`
`173`	`173`	`{`
`174`	`174`	`_Py_Monitors res;`
`175`		`- for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {`
	`175`	`+ for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {`
`176`	`176`	`res.tools[i] = a.tools[i] \| b.tools[i];`
`177`	`177`	`}`
`178`	`178`	`return res;`
`@@ -181,7 +181,7 @@ monitors_or(_Py_Monitors a, _Py_Monitors b)`
`181`	`181`	`static inline bool`
`182`	`182`	`monitors_are_empty(_Py_Monitors m)`
`183`	`183`	`{`
`184`		`- for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {`
	`184`	`+ for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {`
`185`	`185`	`if (m.tools[i]) {`
`186`	`186`	`return false;`
`187`	`187`	`}`
`@@ -192,7 +192,7 @@ monitors_are_empty(_Py_Monitors m)`
`192`	`192`	`static inline bool`
`193`	`193`	`multiple_tools(_Py_Monitors *m)`
`194`	`194`	`{`
`195`		`- for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {`
	`195`	`+ for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {`
`196`	`196`	`if (_Py_popcount32(m->tools[i]) > 1) {`
`197`	`197`	`return true;`
`198`	`198`	`}`
`@@ -204,7 +204,7 @@ static inline _PyMonitoringEventSet`
`204`	`204`	`get_events(_Py_Monitors *m, int tool_id)`
`205`	`205`	`{`
`206`	`206`	`_PyMonitoringEventSet result = 0;`
`207`		`- for (int e = 0; e < PY_MONITORING_UNGROUPED_EVENTS; e++) {`
	`207`	`+ for (int e = 0; e < _PY_MONITORING_UNGROUPED_EVENTS; e++) {`
`208`	`208`	`if ((m->tools[e] >> tool_id) & 1) {`
`209`	`209`	`result \|= (1 << e);`
`210`	`210`	`}`
`@@ -339,7 +339,7 @@ static void`
`339`	`339`	`dump_monitors(const char prefix, _Py_Monitors monitors, FILEout)`
`340`	`340`	`{`
`341`	`341`	`fprintf(out, "%s monitors:\n", prefix);`
`342`		`- for (int event = 0; event < PY_MONITORING_UNGROUPED_EVENTS; event++) {`
	`342`	`+ for (int event = 0; event < _PY_MONITORING_UNGROUPED_EVENTS; event++) {`
`343`	`343`	`fprintf(out, " Event %d: Tools %x\n", event, monitors.tools[event]);`
`344`	`344`	`}`
`345`	`345`	`}`
`@@ -907,7 +907,7 @@ get_tools_for_instruction(PyCodeObject code, PyInterpreterState interp, int i,`
`907`	`907`	`uint8_t tools;`
`908`	`908`	`assert(event != PY_MONITORING_EVENT_LINE);`
`909`	`909`	`assert(event != PY_MONITORING_EVENT_INSTRUCTION);`
`910`		`- if (event >= PY_MONITORING_UNGROUPED_EVENTS) {`
	`910`	`+ if (event >= _PY_MONITORING_UNGROUPED_EVENTS) {`
`911`	`911`	`assert(event == PY_MONITORING_EVENT_C_RAISE \|\|`
`912`	`912`	`event == PY_MONITORING_EVENT_C_RETURN);`
`913`	`913`	`event = PY_MONITORING_EVENT_CALL;`
`@@ -1220,7 +1220,7 @@ _PyMonitoring_RegisterCallback(int tool_id, int event_id, PyObject *obj)`
`1220`	`1220`	`{`
`1221`	`1221`	`PyInterpreterState *is = _PyInterpreterState_GET();`
`1222`	`1222`	`assert(0 <= tool_id && tool_id < PY_MONITORING_TOOL_IDS);`
`1223`		`- assert(0 <= event_id && event_id < PY_MONITORING_EVENTS);`
	`1223`	`+ assert(0 <= event_id && event_id < _PY_MONITORING_EVENTS);`
`1224`	`1224`	`PyObject *callback = is->monitoring_callables[tool_id][event_id];`
`1225`	`1225`	`is->monitoring_callables[tool_id][event_id] = Py_XNewRef(obj);`
`1226`	`1226`	`return callback;`
`@@ -1653,7 +1653,7 @@ static void`
`1653`	`1653`	`set_events(_Py_Monitors *m, int tool_id, _PyMonitoringEventSet events)`
`1654`	`1654`	`{`
`1655`	`1655`	`assert(0 <= tool_id && tool_id < PY_MONITORING_TOOL_IDS);`
`1656`		`- for (int e = 0; e < PY_MONITORING_UNGROUPED_EVENTS; e++) {`
	`1656`	`+ for (int e = 0; e < _PY_MONITORING_UNGROUPED_EVENTS; e++) {`
`1657`	`1657`	`uint8_t *tools = &m->tools[e];`
`1658`	`1658`	`int val = (events >> e) & 1;`
`1659`	`1659`	`*tools &= ~(1 << tool_id);`
`@@ -1678,7 +1678,7 @@ _PyMonitoring_SetEvents(int tool_id, _PyMonitoringEventSet events)`
`1678`	`1678`	`{`
`1679`	`1679`	`assert(0 <= tool_id && tool_id < PY_MONITORING_TOOL_IDS);`
`1680`	`1680`	`PyInterpreterState *interp = _PyInterpreterState_GET();`
`1681`		`- assert(events < (1 << PY_MONITORING_UNGROUPED_EVENTS));`
	`1681`	`+ assert(events < (1 << _PY_MONITORING_UNGROUPED_EVENTS));`
`1682`	`1682`	`if (check_tool(interp, tool_id)) {`
`1683`	`1683`	`return -1;`
`1684`	`1684`	`}`
`@@ -1696,7 +1696,7 @@ _PyMonitoring_SetLocalEvents(PyCodeObject *code, int tool_id, _PyMonitoringEvent`
`1696`	`1696`	`{`
`1697`	`1697`	`assert(0 <= tool_id && tool_id < PY_MONITORING_TOOL_IDS);`
`1698`	`1698`	`PyInterpreterState *interp = _PyInterpreterState_GET();`
`1699`		`- assert(events < (1 << PY_MONITORING_UNGROUPED_EVENTS));`
	`1699`	`+ assert(events < (1 << _PY_MONITORING_UNGROUPED_EVENTS));`
`1700`	`1700`	`if (check_tool(interp, tool_id)) {`
`1701`	`1701`	`return -1;`
`1702`	`1702`	`}`
`@@ -1835,7 +1835,7 @@ monitoring_register_callback_impl(PyObject *module, int tool_id, int event,`
`1835`	`1835`	`return NULL;`
`1836`	`1836`	`}`
`1837`	`1837`	`int event_id = _Py_bit_length(event)-1;`
`1838`		`- if (event_id < 0 \|\| event_id >= PY_MONITORING_EVENTS) {`
	`1838`	`+ if (event_id < 0 \|\| event_id >= _PY_MONITORING_EVENTS) {`
`1839`	`1839`	`PyErr_Format(PyExc_ValueError, "invalid event %d", event);`
`1840`	`1840`	`return NULL;`
`1841`	`1841`	`}`
`@@ -1885,7 +1885,7 @@ monitoring_set_events_impl(PyObject *module, int tool_id, int event_set)`
`1885`	`1885`	`if (check_valid_tool(tool_id)) {`
`1886`	`1886`	`return NULL;`
`1887`	`1887`	`}`
`1888`		`- if (event_set < 0 \|\| event_set >= (1 << PY_MONITORING_EVENTS)) {`
	`1888`	`+ if (event_set < 0 \|\| event_set >= (1 << _PY_MONITORING_EVENTS)) {`
`1889`	`1889`	`PyErr_Format(PyExc_ValueError, "invalid event set 0x%x", event_set);`
`1890`	`1890`	`return NULL;`
`1891`	`1891`	`}`
`@@ -1927,7 +1927,7 @@ monitoring_get_local_events_impl(PyObject *module, int tool_id,`
`1927`	`1927`	`_PyMonitoringEventSet event_set = 0;`
`1928`	`1928`	`_PyCoMonitoringData data = ((PyCodeObject )code)->_co_monitoring;`
`1929`	`1929`	`if (data != NULL) {`
`1930`		`- for (int e = 0; e < PY_MONITORING_UNGROUPED_EVENTS; e++) {`
	`1930`	`+ for (int e = 0; e < _PY_MONITORING_UNGROUPED_EVENTS; e++) {`
`1931`	`1931`	`if ((data->local_monitors.tools[e] >> tool_id) & 1) {`
`1932`	`1932`	`event_set \|= (1 << e);`
`1933`	`1933`	`}`
`@@ -1961,7 +1961,7 @@ monitoring_set_local_events_impl(PyObject *module, int tool_id,`
`1961`	`1961`	`if (check_valid_tool(tool_id)) {`
`1962`	`1962`	`return NULL;`
`1963`	`1963`	`}`
`1964`		`- if (event_set < 0 \|\| event_set >= (1 << PY_MONITORING_EVENTS)) {`
	`1964`	`+ if (event_set < 0 \|\| event_set >= (1 << _PY_MONITORING_EVENTS)) {`
`1965`	`1965`	`PyErr_Format(PyExc_ValueError, "invalid event set 0x%x", event_set);`
`1966`	`1966`	`return NULL;`
`1967`	`1967`	`}`
`@@ -2042,7 +2042,7 @@ monitoring__all_events_impl(PyObject *module)`
`2042`	`2042`	`if (res == NULL) {`
`2043`	`2043`	`return NULL;`
`2044`	`2044`	`}`
`2045`		`- for (int e = 0; e < PY_MONITORING_UNGROUPED_EVENTS; e++) {`
	`2045`	`+ for (int e = 0; e < _PY_MONITORING_UNGROUPED_EVENTS; e++) {`
`2046`	`2046`	`uint8_t tools = interp->monitors.tools[e];`
`2047`	`2047`	`if (tools == 0) {`
`2048`	`2048`	`continue;`
`@@ -2101,7 +2101,7 @@ PyObject *_Py_CreateMonitoringObject(void)`
`2101`	`2101`	`if (err) {`
`2102`	`2102`	`goto error;`
`2103`	`2103`	`}`
`2104`		`- for (int i = 0; i < PY_MONITORING_EVENTS; i++) {`
	`2104`	`+ for (int i = 0; i < _PY_MONITORING_EVENTS; i++) {`
`2105`	`2105`	`if (add_power2_constant(events, event_names[i], i)) {`
`2106`	`2106`	`goto error;`
`2107`	`2107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -679,11 +679,11 @@ init_interpreter(PyInterpreterState *interp,`
`679`	`679`	`_PyGC_InitState(&interp->gc);`
`680`	`680`	`PyConfig_InitPythonConfig(&interp->config);`
`681`	`681`	`_PyType_InitCache(interp);`
`682`		`- for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {`
	`682`	`+ for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {`
`683`	`683`	`interp->monitors.tools[i] = 0;`
`684`	`684`	`}`
`685`	`685`	`for (int t = 0; t < PY_MONITORING_TOOL_IDS; t++) {`
`686`		`- for (int e = 0; e < PY_MONITORING_EVENTS; e++) {`
	`686`	`+ for (int e = 0; e < _PY_MONITORING_EVENTS; e++) {`
`687`	`687`	`interp->monitoring_callables[t][e] = NULL;`
`688`	`688`
`689`	`689`	`}`
`@@ -841,11 +841,11 @@ interpreter_clear(PyInterpreterState interp, PyThreadState tstate)`
`841`	`841`
`842`	`842`	`Py_CLEAR(interp->audit_hooks);`
`843`	`843`
`844`		`- for (int i = 0; i < PY_MONITORING_UNGROUPED_EVENTS; i++) {`
	`844`	`+ for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {`
`845`	`845`	`interp->monitors.tools[i] = 0;`
`846`	`846`	`}`
`847`	`847`	`for (int t = 0; t < PY_MONITORING_TOOL_IDS; t++) {`
`848`		`- for (int e = 0; e < PY_MONITORING_EVENTS; e++) {`
	`848`	`+ for (int e = 0; e < _PY_MONITORING_EVENTS; e++) {`
`849`	`849`	`Py_CLEAR(interp->monitoring_callables[t][e]);`
`850`	`850`	`}`
`851`	`851`	`}`