Marks a point where a recursive C-level call is about to be performed.
- The function then checks if the stack limit is reached. If this is the
+ If :c:macro:`!USE_STACKCHECK` is defined, this function checks if the OS
+ stack overflowed using :c:func:`PyOS_CheckStack`. If this is the case, it
+ sets a :exc:`MemoryError` and returns a nonzero value.
+
+ The function then checks if the recursion limit is reached. If this is the
case, a :exc:`RecursionError` is set and a nonzero value is returned.
Otherwise, zero is returned.
* we have headroom above the trigger limit */
#define Py_TRASHCAN_HEADROOM 50
-/* Helper function for Py_TRASHCAN_BEGIN */
-PyAPI_FUNC(int) _Py_ReachedRecursionLimitWithMargin(PyThreadState *tstate, int margin_count);
-
#define Py_TRASHCAN_BEGIN(op, dealloc) \
do { \
PyThreadState *tstate = PyThreadState_Get(); \
- if (_Py_ReachedRecursionLimitWithMargin(tstate, 1) && Py_TYPE(op)->tp_dealloc == (destructor)dealloc) { \
+ if (tstate->c_recursion_remaining <= Py_TRASHCAN_HEADROOM && Py_TYPE(op)->tp_dealloc == (destructor)dealloc) { \
_PyTrash_thread_deposit_object(tstate, (PyObject *)op); \
break; \
- }
+ } \
+ tstate->c_recursion_remaining--;
/* The body of the deallocator is here. */
#define Py_TRASHCAN_END \
- if (tstate->delete_later && !_Py_ReachedRecursionLimitWithMargin(tstate, 2)) { \
+ tstate->c_recursion_remaining++; \
+ if (tstate->delete_later && tstate->c_recursion_remaining > (Py_TRASHCAN_HEADROOM*2)) { \
_PyTrash_thread_destroy_chain(tstate); \
} \
} while (0);
int py_recursion_remaining;
int py_recursion_limit;
- int c_recursion_remaining; /* Retained for backwards compatibility. Do not use */
+ int c_recursion_remaining;
int recursion_headroom; /* Allow 50 more calls to handle any errors. */
/* 'tracing' keeps track of the execution depth when tracing/profiling.
PyObject *threading_local_sentinel;
};
-# define Py_C_RECURSION_LIMIT 5000
+#ifdef Py_DEBUG
+ // A debug build is likely built with low optimization level which implies
+ // higher stack memory usage than a release build: use a lower limit.
+# define Py_C_RECURSION_LIMIT 500
+#elif defined(__s390x__)
+# define Py_C_RECURSION_LIMIT 800
+#elif defined(_WIN32) && defined(_M_ARM64)
+# define Py_C_RECURSION_LIMIT 1000
+#elif defined(_WIN32)
+# define Py_C_RECURSION_LIMIT 3000
+#elif defined(__ANDROID__)
+ // On an ARM64 emulator, API level 34 was OK with 10000, but API level 21
+ // crashed in test_compiler_recursion_limit.
+# define Py_C_RECURSION_LIMIT 3000
+#elif defined(_Py_ADDRESS_SANITIZER)
+# define Py_C_RECURSION_LIMIT 4000
+#elif defined(__sparc__)
+ // test_descr crashed on sparc64 with >7000 but let's keep a margin of error.
+# define Py_C_RECURSION_LIMIT 4000
+#elif defined(__wasi__)
+ // Based on wasmtime 16.
+# define Py_C_RECURSION_LIMIT 5000
+#elif defined(__hppa__) || defined(__powerpc64__)
+ // test_descr crashed with >8000 but let's keep a margin of error.
+# define Py_C_RECURSION_LIMIT 5000
+#else
+ // This value is duplicated in Lib/test/support/__init__.py
+# define Py_C_RECURSION_LIMIT 10000
+#endif
+
/* other API */
return PyThreadState_GetUnchecked();
}
+
// Disable tracing and profiling.
PyAPI_FUNC(void) PyThreadState_EnterTracing(PyThreadState *tstate);
/* --- _Py_EnterRecursiveCall() ----------------------------------------- */
+#ifdef USE_STACKCHECK
+/* With USE_STACKCHECK macro defined, trigger stack checks in
+ _Py_CheckRecursiveCall() on every 64th call to _Py_EnterRecursiveCall. */
static inline int _Py_MakeRecCheck(PyThreadState *tstate) {
- char here;
- uintptr_t here_addr = (uintptr_t)&here;
- _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
- return here_addr < _tstate->c_stack_soft_limit;
+ return (tstate->c_recursion_remaining-- < 0
+ || (tstate->c_recursion_remaining & 63) == 0);
}
+#else
+static inline int _Py_MakeRecCheck(PyThreadState *tstate) {
+ return tstate->c_recursion_remaining-- < 0;
+}
+#endif
// Export for '_json' shared extension, used via _Py_EnterRecursiveCall()
// static inline function.
return (_Py_MakeRecCheck(tstate) && _Py_CheckRecursiveCall(tstate, where));
}
+static inline void _Py_EnterRecursiveCallTstateUnchecked(PyThreadState *tstate) {
+ assert(tstate->c_recursion_remaining > 0);
+ tstate->c_recursion_remaining--;
+}
+
static inline int _Py_EnterRecursiveCall(const char *where) {
PyThreadState *tstate = _PyThreadState_GET();
return _Py_EnterRecursiveCallTstate(tstate, where);
}
-static inline void _Py_LeaveRecursiveCallTstate(PyThreadState *tstate) {
- (void)tstate;
-}
-
-PyAPI_FUNC(void) _Py_InitializeRecursionLimits(PyThreadState *tstate);
-
-static inline int _Py_ReachedRecursionLimit(PyThreadState *tstate) {
- char here;
- uintptr_t here_addr = (uintptr_t)&here;
- _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
- if (here_addr > _tstate->c_stack_soft_limit) {
- return 0;
- }
- if (_tstate->c_stack_hard_limit == 0) {
- _Py_InitializeRecursionLimits(tstate);
- }
- return here_addr <= _tstate->c_stack_soft_limit;
+static inline void _Py_LeaveRecursiveCallTstate(PyThreadState *tstate) {
+ tstate->c_recursion_remaining++;
}
static inline void _Py_LeaveRecursiveCall(void) {
+ PyThreadState *tstate = _PyThreadState_GET();
+ _Py_LeaveRecursiveCallTstate(tstate);
}
extern struct _PyInterpreterFrame* _PyEval_GetFrame(void);
PyAPI_FUNC(PyObject *) _PyFloat_FromDouble_ConsumeInputs(_PyStackRef left, _PyStackRef right, double value);
+
#ifdef __cplusplus
}
#endif
PyObject *st_private; /* name of current class or NULL */
_PyFutureFeatures *st_future; /* module's future features that affect
the symbol table */
+ int recursion_depth; /* current recursion depth */
+ int recursion_limit; /* recursion limit */
};
typedef struct _symtable_entry {
// semi-public fields are in PyThreadState.
PyThreadState base;
- // These are addresses, but we need to convert to ints to avoid UB.
- uintptr_t c_stack_top;
- uintptr_t c_stack_soft_limit;
- uintptr_t c_stack_hard_limit;
-
PyObject *asyncio_running_loop; // Strong reference
PyObject *asyncio_running_task; // Strong reference
/* Stuff with no proper home (yet) */
PyAPI_DATA(int) (*PyOS_InputHook)(void);
-/* Stack size, in "pointers". This must be large enough, so
- * no two calls to check recursion depth are more than this far
- * apart. In practice, that means it must be larger than the C
- * stack consumption of PyEval_EvalDefault */
-#if defined(Py_DEBUG) && defined(WIN32)
-# define PYOS_STACK_MARGIN 3072
-#else
-# define PYOS_STACK_MARGIN 2048
-#endif
-#define PYOS_STACK_MARGIN_BYTES (PYOS_STACK_MARGIN * sizeof(void *))
-
-#if defined(WIN32)
+/* Stack size, in "pointers" (so we get extra safety margins
+ on 64-bit platforms). On a 32-bit platform, this translates
+ to an 8k margin. */
+#define PYOS_STACK_MARGIN 2048
+
+#if defined(WIN32) && !defined(MS_WIN64) && !defined(_M_ARM) && defined(_MSC_VER) && _MSC_VER >= 1300
+/* Enable stack checking under Microsoft C */
+// When changing the platforms, ensure PyOS_CheckStack() docs are still correct
#define USE_STACKCHECK
#endif
from functools import cmp_to_key
from test import seq_tests
-from test.support import ALWAYS_EQ, NEVER_EQ
-from test.support import skip_emscripten_stack_overflow, skip_wasi_stack_overflow
+from test.support import ALWAYS_EQ, NEVER_EQ, get_c_recursion_limit, skip_emscripten_stack_overflow
class CommonTest(seq_tests.CommonTest):
self.assertEqual(str(a2), "[0, 1, 2, [...], 3]")
self.assertEqual(repr(a2), "[0, 1, 2, [...], 3]")
- @skip_wasi_stack_overflow()
@skip_emscripten_stack_overflow()
def test_repr_deep(self):
a = self.type2test([])
- for i in range(100_000):
+ for i in range(get_c_recursion_limit() + 1):
a = self.type2test([a])
self.assertRaises(RecursionError, repr, a)
# tests common to dict and UserDict
import unittest
import collections
-from test import support
+from test.support import get_c_recursion_limit, skip_emscripten_stack_overflow
class BasicTestMappingProtocol(unittest.TestCase):
d = self._full_mapping({1: BadRepr()})
self.assertRaises(Exc, repr, d)
- @support.skip_wasi_stack_overflow()
- @support.skip_emscripten_stack_overflow()
+ @skip_emscripten_stack_overflow()
def test_repr_deep(self):
d = self._empty_mapping()
- for i in range(support.exceeds_recursion_limit()):
+ for i in range(get_c_recursion_limit() + 1):
d0 = d
d = self._empty_mapping()
d[1] = d0
for name in (
'LONG_MAX', # always 32-bit on Windows, 64-bit on 64-bit Unix
'PY_SSIZE_T_MAX',
+ 'Py_C_RECURSION_LIMIT',
'SIZEOF_TIME_T', # 32-bit or 64-bit depending on the platform
'SIZEOF_WCHAR_T', # 16-bit or 32-bit depending on the platform
):
"run_with_tz", "PGO", "missing_compiler_executable",
"ALWAYS_EQ", "NEVER_EQ", "LARGEST", "SMALLEST",
"LOOPBACK_TIMEOUT", "INTERNET_TIMEOUT", "SHORT_TIMEOUT", "LONG_TIMEOUT",
- "Py_DEBUG", "exceeds_recursion_limit", "skip_on_s390x",
+ "Py_DEBUG", "exceeds_recursion_limit", "get_c_recursion_limit",
+ "skip_on_s390x",
"requires_jit_enabled",
"requires_jit_disabled",
"force_not_colorized",
def skip_emscripten_stack_overflow():
return unittest.skipIf(is_emscripten, "Exhausts limited stack on Emscripten")
-def skip_wasi_stack_overflow():
- return unittest.skipIf(is_wasi, "Exhausts stack on WASI")
-
is_apple_mobile = sys.platform in {"ios", "tvos", "watchos"}
is_apple = is_apple_mobile or sys.platform == "darwin"
sys.set_int_max_str_digits(current)
+def get_c_recursion_limit():
+ try:
+ import _testcapi
+ return _testcapi.Py_C_RECURSION_LIMIT
+ except ImportError:
+ raise unittest.SkipTest('requires _testcapi')
+
+
def exceeds_recursion_limit():
"""For recursion tests, easily exceeds default recursion limit."""
- return 100_000
+ return get_c_recursion_limit() * 3
# Windows doesn't have os.uname() but it doesn't support s390x.
_testinternalcapi = None
from test import support
-from test.support import os_helper, script_helper
-from test.support import skip_emscripten_stack_overflow, skip_wasi_stack_overflow
+from test.support import os_helper, script_helper, skip_emscripten_stack_overflow
from test.support.ast_helper import ASTTestMixin
from test.test_ast.utils import to_tuple
from test.test_ast.snippets import (
enum._test_simple_enum(_Precedence, ast._Precedence)
@support.cpython_only
- @skip_wasi_stack_overflow()
@skip_emscripten_stack_overflow()
def test_ast_recursion_limit(self):
- crash_depth = 200_000
- success_depth = 200
+ fail_depth = support.exceeds_recursion_limit()
+ crash_depth = 100_000
+ success_depth = int(support.get_c_recursion_limit() * 0.8)
if _testinternalcapi is not None:
remaining = _testinternalcapi.get_c_recursion_remaining()
success_depth = min(success_depth, remaining)
def check_limit(prefix, repeated):
expect_ok = prefix + repeated * success_depth
ast.parse(expect_ok)
-
- broken = prefix + repeated * crash_depth
- details = "Compiling ({!r} + {!r} * {})".format(
- prefix, repeated, crash_depth)
- with self.assertRaises(RecursionError, msg=details):
- with support.infinite_recursion():
- ast.parse(broken)
+ for depth in (fail_depth, crash_depth):
+ broken = prefix + repeated * depth
+ details = "Compiling ({!r} + {!r} * {})".format(
+ prefix, repeated, depth)
+ with self.assertRaises(RecursionError, msg=details):
+ with support.infinite_recursion():
+ ast.parse(broken)
check_limit("a", "()")
check_limit("a", ".b")
import unittest
from test.support import (cpython_only, is_wasi, requires_limited_api, Py_DEBUG,
- set_recursion_limit, skip_on_s390x, exceeds_recursion_limit, skip_emscripten_stack_overflow,
+ set_recursion_limit, skip_on_s390x, skip_emscripten_stack_overflow,
skip_if_sanitizer, import_helper)
try:
import _testcapi
recurse(90_000)
with self.assertRaises(RecursionError):
recurse(101_000)
- c_recurse(50)
+ c_recurse(100)
with self.assertRaises(RecursionError):
c_recurse(90_000)
- c_py_recurse(50)
+ c_py_recurse(90)
with self.assertRaises(RecursionError):
c_py_recurse(100_000)
# activated when its tp_dealloc is being called by a subclass
from _testcapi import MyList
L = None
- for i in range(100):
+ for i in range(1000):
L = MyList((L,))
@support.requires_resource('cpu')
from test import support
from test.support import (script_helper, requires_debug_ranges, run_code,
- requires_specialization)
+ requires_specialization, get_c_recursion_limit)
from test.support.bytecode_helper import instructions_with_positions
from test.support.os_helper import FakePath
@unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
@support.skip_emscripten_stack_overflow()
def test_extended_arg(self):
- repeat = 100
+ repeat = int(get_c_recursion_limit() * 0.9)
longexpr = 'x = x or ' + '-x' * repeat
g = {}
code = textwrap.dedent('''
@unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
@support.skip_emscripten_stack_overflow()
def test_compiler_recursion_limit(self):
- # Compiler frames are small
- limit = 100
- fail_depth = limit * 1000
- crash_depth = limit * 2000
- success_depth = limit
+ # Expected limit is Py_C_RECURSION_LIMIT
+ limit = get_c_recursion_limit()
+ fail_depth = limit + 1
+ crash_depth = limit * 100
+ success_depth = int(limit * 0.8)
def check_limit(prefix, repeated, mode="single"):
expect_ok = prefix + repeated * success_depth
import unittest
import weakref
from test import support
-from test.support import import_helper
+from test.support import import_helper, get_c_recursion_limit
class DictTest(unittest.TestCase):
d = {1: BadRepr()}
self.assertRaises(Exc, repr, d)
- @support.skip_wasi_stack_overflow()
@support.skip_emscripten_stack_overflow()
def test_repr_deep(self):
d = {}
- for i in range(support.exceeds_recursion_limit()):
+ for i in range(get_c_recursion_limit() + 1):
d = {1: d}
self.assertRaises(RecursionError, repr, d)
import copy
import pickle
import unittest
-from test.support import skip_emscripten_stack_overflow, skip_wasi_stack_overflow, exceeds_recursion_limit
+from test.support import get_c_recursion_limit, skip_emscripten_stack_overflow
class DictSetTest(unittest.TestCase):
# Again.
self.assertIsInstance(r, str)
- @skip_wasi_stack_overflow()
@skip_emscripten_stack_overflow()
def test_deeply_nested_repr(self):
d = {}
- for i in range(exceeds_recursion_limit()):
+ for i in range(get_c_recursion_limit()//2 + 100):
d = {42: d.values()}
self.assertRaises(RecursionError, repr, d)
import collections.abc
import types
import unittest
-from test.support import skip_emscripten_stack_overflow, exceeds_recursion_limit
+from test.support import get_c_recursion_limit, skip_emscripten_stack_overflow
class TestExceptionGroupTypeHierarchy(unittest.TestCase):
def test_exception_group_types(self):
class DeepRecursionInSplitAndSubgroup(unittest.TestCase):
def make_deep_eg(self):
e = TypeError(1)
- for i in range(exceeds_recursion_limit()):
+ for i in range(get_c_recursion_limit() + 1):
e = ExceptionGroup('eg', [e])
return e
"""
rc, out, err = script_helper.assert_python_failure("-c", code)
self.assertEqual(rc, 1)
- expected = b'RecursionError'
+ expected = b'RecursionError: maximum recursion depth exceeded'
self.assertTrue(expected in err, msg=f"{expected!r} not found in {err[:3_000]!r}... (truncated)")
self.assertIn(b'Done.', out)
r"does not match opening parenthesis '\('",
["f'{a(4}'",
])
- self.assertRaises(SyntaxError, eval, "f'{" + "("*20 + "}'")
+ self.assertRaises(SyntaxError, eval, "f'{" + "("*500 + "}'")
@unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
def test_fstring_nested_too_deeply(self):
- def raises_syntax_or_memory_error(txt):
- try:
- eval(txt)
- except SyntaxError:
- pass
- except MemoryError:
- pass
- except Exception as ex:
- self.fail(f"Should raise SyntaxError or MemoryError, not {type(ex)}")
- else:
- self.fail("No exception raised")
-
- raises_syntax_or_memory_error('f"{1+2:{1+2:{1+1:{1}}}}"')
+ self.assertAllRaise(SyntaxError,
+ "f-string: expressions nested too deeply",
+ ['f"{1+2:{1+2:{1+1:{1}}}}"'])
def create_nested_fstring(n):
if n == 0:
prev = create_nested_fstring(n-1)
return f'f"{{{prev}}}"'
- raises_syntax_or_memory_error(create_nested_fstring(160))
- raises_syntax_or_memory_error("f'{" + "("*100 + "}'")
- raises_syntax_or_memory_error("f'{" + "("*1000 + "}'")
- raises_syntax_or_memory_error("f'{" + "("*10_000 + "}'")
+ self.assertAllRaise(SyntaxError,
+ "too many nested f-strings",
+ [create_nested_fstring(160)])
def test_syntax_error_in_nested_fstring(self):
# See gh-104016 for more information on this crash
return n
return fib(n-1) + fib(n-2)
- fib(100)
+ if not support.Py_DEBUG:
+ depth = support.get_c_recursion_limit()*2//7
+ with support.infinite_recursion():
+ fib(depth)
if self.module == c_functools:
fib.cache_clear()
with support.infinite_recursion():
with self.assertRaises(RecursionError):
- fib(support.exceeds_recursion_limit())
+ fib(10000)
@py_functools.lru_cache()
def test_subclass_recursion_limit(self):
# make sure that issubclass raises RecursionError before the C stack is
# blown
- self.assertRaises(RecursionError, blowstack, issubclass, str, str)
+ with support.infinite_recursion():
+ self.assertRaises(RecursionError, blowstack, issubclass, str, str)
@support.skip_emscripten_stack_overflow()
def test_isinstance_recursion_limit(self):
# make sure that issubclass raises RecursionError before the C stack is
# blown
- self.assertRaises(RecursionError, blowstack, isinstance, '', str)
+ with support.infinite_recursion():
+ self.assertRaises(RecursionError, blowstack, isinstance, '', str)
def test_subclass_with_union(self):
self.assertTrue(issubclass(int, int | float | int))
# Make sure that calling isinstance with a deeply nested tuple for its
# argument will raise RecursionError eventually.
tuple_arg = (compare_to,)
- while True:
- for _ in range(100):
- tuple_arg = (tuple_arg,)
+ for cnt in range(support.exceeds_recursion_limit()):
+ tuple_arg = (tuple_arg,)
fxn(arg, tuple_arg)
with support.infinite_recursion():
self.loads('[' * 100000 + '1' + ']' * 100000)
- @support.skip_wasi_stack_overflow()
@support.skip_emscripten_stack_overflow()
def test_highly_nested_objects_encoding(self):
# See #12051
def test_many_codeobjects(self):
# Issue2957: bad recursion count on code objects
# more than MAX_MARSHAL_STACK_DEPTH
- codes = (ExceptionTestCase.test_exceptions.__code__,) * 10_000
+ count = support.exceeds_recursion_limit()
+ codes = (ExceptionTestCase.test_exceptions.__code__,) * count
marshal.loads(marshal.dumps(codes))
def test_different_filenames(self):
def test_trace_lots_of_globals(self):
- count = 1000
+ count = min(1000, int(support.get_c_recursion_limit() * 0.8))
code = """if 1:
def f():
return (
{}
)
- """.format("\n,\n".join(f"var{i}\n" for i in range(count)))
+ """.format("\n+\n".join(f"var{i}\n" for i in range(count)))
ns = {f"var{i}": i for i in range(count)}
exec(code, ns)
counts = self.count_traces(ns["f"])
- self.assertEqual(counts, {'call': 1, 'line': count * 2 + 1, 'return': 1})
+ self.assertEqual(counts, {'call': 1, 'line': count * 2, 'return': 1})
class TestEdgeCases(unittest.TestCase):
with self.subTest(case=case):
self.assertRaises(tokenize.TokenError, get_tokens, case)
- @support.skip_wasi_stack_overflow()
def test_max_indent(self):
MAXINDENT = 100
else:
self.fail("g[42] didn't raise KeyError")
- test_repr_deep = mapping_tests.TestHashMappingProtocol.test_repr_deep
+ # Decorate existing test with recursion limit, because
+ # the test is for C structure, but `UserDict` is a Python structure.
+ test_repr_deep = support.infinite_recursion(25)(
+ mapping_tests.TestHashMappingProtocol.test_repr_deep,
+ )
if __name__ == "__main__":
# Decorate existing test with recursion limit, because
# the test is for C structure, but `UserList` is a Python structure.
- test_repr_deep = list_tests.CommonTest.test_repr_deep
+ test_repr_deep = support.infinite_recursion(25)(
+ list_tests.CommonTest.test_repr_deep,
+ )
if __name__ == "__main__":
unittest.main()
del element.attrib
self.assertEqual(element.attrib, {'A': 'B', 'C': 'D'})
- @support.skip_wasi_stack_overflow()
@unittest.skipIf(support.is_emscripten, "segfaults")
def test_trashcan(self):
# If this test fails, it will most likely die via segfault.
+++ /dev/null
-Change C stack overflow protection to consider the amount of stack consumed,
-rather than a counter. This allows deeper recursion in many cases, but
-remains safe.
PyModule_AddObject(m, "instancemethod", (PyObject *)&PyInstanceMethod_Type);
PyModule_AddIntConstant(m, "the_number_three", 3);
+ PyModule_AddIntMacro(m, Py_C_RECURSION_LIMIT);
PyModule_AddObject(m, "INT32_MIN", PyLong_FromInt32(INT32_MIN));
PyModule_AddObject(m, "INT32_MAX", PyLong_FromInt32(INT32_MAX));
PyModule_AddObject(m, "UINT32_MAX", PyLong_FromUInt32(UINT32_MAX));
get_c_recursion_remaining(PyObject *self, PyObject *Py_UNUSED(args))
{
PyThreadState *tstate = _PyThreadState_GET();
- char here;
- uintptr_t here_addr = (uintptr_t)&here;
- _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
- int remaining = (int)((here_addr - _tstate->c_stack_soft_limit)/PYOS_STACK_MARGIN_BYTES * 50);
- return PyLong_FromLong(remaining);
+ return PyLong_FromLong(tstate->c_recursion_remaining);
}
int write_error = 0;
if (PyErr_CheckSignals())
return -1;
- if (_Py_EnterRecursiveCall(" printing an object")) {
+#ifdef USE_STACKCHECK
+ if (PyOS_CheckStack()) {
+ PyErr_SetString(PyExc_MemoryError, "stack overflow");
return -1;
}
+#endif
clearerr(fp); /* Clear any previous error condition */
if (op == NULL) {
Py_BEGIN_ALLOW_THREADS
PyObject *res;
if (PyErr_CheckSignals())
return NULL;
+#ifdef USE_STACKCHECK
+ if (PyOS_CheckStack()) {
+ PyErr_SetString(PyExc_MemoryError, "stack overflow");
+ return NULL;
+ }
+#endif
if (v == NULL)
return PyUnicode_FromString("<NULL>");
if (Py_TYPE(v)->tp_repr == NULL)
PyObject *res;
if (PyErr_CheckSignals())
return NULL;
+#ifdef USE_STACKCHECK
+ if (PyOS_CheckStack()) {
+ PyErr_SetString(PyExc_MemoryError, "stack overflow");
+ return NULL;
+ }
+#endif
if (v == NULL)
return PyUnicode_FromString("<NULL>");
if (PyUnicode_CheckExact(v)) {
void
_PyTrash_thread_destroy_chain(PyThreadState *tstate)
{
+ /* We need to increase c_recursion_remaining here, otherwise,
+ _PyTrash_thread_destroy_chain will be called recursively
+ and then possibly crash. An example that may crash without
+ increase:
+ N = 500000 # need to be large enough
+ ob = object()
+ tups = [(ob,) for i in range(N)]
+ for i in range(49):
+ tups = [(tup,) for tup in tups]
+ del tups
+ */
+ assert(tstate->c_recursion_remaining > Py_TRASHCAN_HEADROOM);
+ tstate->c_recursion_remaining--;
while (tstate->delete_later) {
PyObject *op = tstate->delete_later;
destructor dealloc = Py_TYPE(op)->tp_dealloc;
_PyObject_ASSERT(op, Py_REFCNT(op) == 0);
(*dealloc)(op);
}
+ tstate->c_recursion_remaining++;
}
void _Py_NO_RETURN
class PyTypesDeclareVisitor(PickleVisitor):
def visitProduct(self, prod, name):
- self.emit("static PyObject* ast2obj_%s(struct ast_state *state, void*);" % name, 0)
+ self.emit("static PyObject* ast2obj_%s(struct ast_state *state, struct validator *vstate, void*);" % name, 0)
if prod.attributes:
self.emit("static const char * const %s_attributes[] = {" % name, 0)
for a in prod.attributes:
ptype = "void*"
if is_simple(sum):
ptype = get_c_type(name)
- self.emit("static PyObject* ast2obj_%s(struct ast_state *state, %s);" % (name, ptype), 0)
+ self.emit("static PyObject* ast2obj_%s(struct ast_state *state, struct validator *vstate, %s);" % (name, ptype), 0)
for t in sum.types:
self.visitConstructor(t, name)
/* Conversion AST -> Python */
-static PyObject* ast2obj_list(struct ast_state *state, asdl_seq *seq,
- PyObject* (*func)(struct ast_state *state, void*))
+static PyObject* ast2obj_list(struct ast_state *state, struct validator *vstate, asdl_seq *seq,
+ PyObject* (*func)(struct ast_state *state, struct validator *vstate, void*))
{
Py_ssize_t i, n = asdl_seq_LEN(seq);
PyObject *result = PyList_New(n);
if (!result)
return NULL;
for (i = 0; i < n; i++) {
- value = func(state, asdl_seq_GET_UNTYPED(seq, i));
+ value = func(state, vstate, asdl_seq_GET_UNTYPED(seq, i));
if (!value) {
Py_DECREF(result);
return NULL;
return result;
}
-static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), void *o)
+static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), struct validator *Py_UNUSED(vstate), void *o)
{
PyObject *op = (PyObject*)o;
if (!op) {
#define ast2obj_identifier ast2obj_object
#define ast2obj_string ast2obj_object
-static PyObject* ast2obj_int(struct ast_state *Py_UNUSED(state), long b)
+static PyObject* ast2obj_int(struct ast_state *Py_UNUSED(state), struct validator *Py_UNUSED(vstate), long b)
{
return PyLong_FromLong(b);
}
def func_begin(self, name):
ctype = get_c_type(name)
self.emit("PyObject*", 0)
- self.emit("ast2obj_%s(struct ast_state *state, void* _o)" % (name), 0)
+ self.emit("ast2obj_%s(struct ast_state *state, struct validator *vstate, void* _o)" % (name), 0)
self.emit("{", 0)
self.emit("%s o = (%s)_o;" % (ctype, ctype), 1)
self.emit("PyObject *result = NULL, *value = NULL;", 1)
self.emit('if (!o) {', 1)
self.emit("Py_RETURN_NONE;", 2)
self.emit("}", 1)
- self.emit('if (Py_EnterRecursiveCall("during ast construction")) {', 1)
+ self.emit("if (++vstate->recursion_depth > vstate->recursion_limit) {", 1)
+ self.emit("PyErr_SetString(PyExc_RecursionError,", 2)
+ self.emit('"maximum recursion depth exceeded during ast construction");', 3)
self.emit("return NULL;", 2)
self.emit("}", 1)
def func_end(self):
- self.emit("Py_LeaveRecursiveCall();", 1)
+ self.emit("vstate->recursion_depth--;", 1)
self.emit("return result;", 1)
self.emit("failed:", 0)
- self.emit("Py_LeaveRecursiveCall();", 1)
+ self.emit("vstate->recursion_depth--;", 1)
self.emit("Py_XDECREF(value);", 1)
self.emit("Py_XDECREF(result);", 1)
self.emit("return NULL;", 1)
self.visitConstructor(t, i + 1, name)
self.emit("}", 1)
for a in sum.attributes:
- self.emit("value = ast2obj_%s(state, o->%s);" % (a.type, a.name), 1)
+ self.emit("value = ast2obj_%s(state, vstate, o->%s);" % (a.type, a.name), 1)
self.emit("if (!value) goto failed;", 1)
self.emit('if (PyObject_SetAttr(result, state->%s, value) < 0)' % a.name, 1)
self.emit('goto failed;', 2)
self.func_end()
def simpleSum(self, sum, name):
- self.emit("PyObject* ast2obj_%s(struct ast_state *state, %s_ty o)" % (name, name), 0)
+ self.emit("PyObject* ast2obj_%s(struct ast_state *state, struct validator *vstate, %s_ty o)" % (name, name), 0)
self.emit("{", 0)
self.emit("switch(o) {", 1)
for t in sum.types:
for field in prod.fields:
self.visitField(field, name, 1, True)
for a in prod.attributes:
- self.emit("value = ast2obj_%s(state, o->%s);" % (a.type, a.name), 1)
+ self.emit("value = ast2obj_%s(state, vstate, o->%s);" % (a.type, a.name), 1)
self.emit("if (!value) goto failed;", 1)
self.emit("if (PyObject_SetAttr(result, state->%s, value) < 0)" % a.name, 1)
self.emit('goto failed;', 2)
self.emit("for(i = 0; i < n; i++)", depth+1)
# This cannot fail, so no need for error handling
self.emit(
- "PyList_SET_ITEM(value, i, ast2obj_{0}(state, ({0}_ty)asdl_seq_GET({1}, i)));".format(
+ "PyList_SET_ITEM(value, i, ast2obj_{0}(state, vstate, ({0}_ty)asdl_seq_GET({1}, i)));".format(
field.type,
value
),
)
self.emit("}", depth)
else:
- self.emit("value = ast2obj_list(state, (asdl_seq*)%s, ast2obj_%s);" % (value, field.type), depth)
+ self.emit("value = ast2obj_list(state, vstate, (asdl_seq*)%s, ast2obj_%s);" % (value, field.type), depth)
else:
- self.emit("value = ast2obj_%s(state, %s);" % (field.type, value), depth, reflow=False)
+ self.emit("value = ast2obj_%s(state, vstate, %s);" % (field.type, value), depth, reflow=False)
class PartingShots(StaticVisitor):
if (state == NULL) {
return NULL;
}
- PyObject *result = ast2obj_mod(state, t);
+ int starting_recursion_depth;
+ /* Be careful here to prevent overflow. */
+ PyThreadState *tstate = _PyThreadState_GET();
+ if (!tstate) {
+ return NULL;
+ }
+ struct validator vstate;
+ vstate.recursion_limit = Py_C_RECURSION_LIMIT;
+ int recursion_depth = Py_C_RECURSION_LIMIT - tstate->c_recursion_remaining;
+ starting_recursion_depth = recursion_depth;
+ vstate.recursion_depth = starting_recursion_depth;
+
+ PyObject *result = ast2obj_mod(state, &vstate, t);
+
+ /* Check that the recursion depth counting balanced correctly */
+ if (result && vstate.recursion_depth != starting_recursion_depth) {
+ PyErr_Format(PyExc_SystemError,
+ "AST constructor recursion depth mismatch (before=%d, after=%d)",
+ starting_recursion_depth, vstate.recursion_depth);
+ return NULL;
+ }
return result;
}
#include "structmember.h"
#include <stddef.h>
+ struct validator {
+ int recursion_depth; /* current recursion depth */
+ int recursion_limit; /* recursion limit */
+ };
+
// Forward declaration
static int init_types(void *arg);
# define MAXSTACK 4000
# endif
#else
-# define MAXSTACK 4000
+# define MAXSTACK 6000
#endif
static const int n_keyword_lists = 9;
static KeywordToken *reserved_keywords[] = {
static mod_ty
file_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static mod_ty
interactive_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static mod_ty
eval_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static mod_ty
func_type_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_stmt_seq*
statements_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_stmt_seq*
statement_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_stmt_seq*
statement_newline_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_stmt_seq*
simple_stmts_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
simple_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
compound_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
assignment_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
annotated_rhs_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static AugOperator*
augassign_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
return_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
raise_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
pass_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
break_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
continue_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
global_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
nonlocal_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
del_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
yield_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
assert_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
import_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
import_name_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
import_from_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_alias_seq*
import_from_targets_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_alias_seq*
import_from_as_names_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static alias_ty
import_from_as_name_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_alias_seq*
dotted_as_names_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static alias_ty
dotted_as_name_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
dotted_name_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
expr_ty _res = NULL;
static expr_ty
dotted_name_raw(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_stmt_seq*
block_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_expr_seq*
decorators_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
class_def_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
class_def_raw_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
function_def_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
function_def_raw_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arguments_ty
params_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arguments_ty
parameters_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_arg_seq*
slash_no_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static SlashWithDefault*
slash_with_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static StarEtc*
star_etc_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arg_ty
kwds_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arg_ty
param_no_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arg_ty
param_no_default_star_annotation_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static NameDefaultPair*
param_with_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static NameDefaultPair*
param_maybe_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arg_ty
param_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arg_ty
param_star_annotation_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
annotation_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
star_annotation_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
if_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
elif_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_stmt_seq*
else_block_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
while_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
for_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
with_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static withitem_ty
with_item_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
try_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static excepthandler_ty
except_block_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static excepthandler_ty
except_star_block_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_stmt_seq*
finally_block_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
match_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
subject_expr_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static match_case_ty
case_block_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
guard_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
patterns_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
as_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
or_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
closed_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
literal_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
literal_expr_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
complex_number_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
signed_number_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
signed_real_number_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
real_number_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
imaginary_number_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
capture_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
pattern_capture_target_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
wildcard_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
value_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
attr_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
expr_ty _res = NULL;
static expr_ty
attr_raw(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
name_or_attr_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
group_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
sequence_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq*
open_sequence_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq*
maybe_sequence_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
maybe_star_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
star_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
mapping_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq*
items_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static KeyPatternPair*
key_value_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
double_star_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static pattern_ty
class_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_pattern_seq*
positional_patterns_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq*
keyword_patterns_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static KeyPatternPair*
keyword_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static stmt_ty
type_alias_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_type_param_seq*
type_params_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_type_param_seq*
type_param_seq_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static type_param_ty
type_param_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
type_param_bound_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
type_param_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
type_param_starred_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
expressions_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
expression_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
yield_expr_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
star_expressions_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
star_expression_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_expr_seq*
star_named_expressions_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
star_named_expression_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
assignment_expression_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
named_expression_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
disjunction_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
conjunction_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
inversion_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
comparison_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static CmpopExprPair*
compare_op_bitwise_or_pair_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static CmpopExprPair*
eq_bitwise_or_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static CmpopExprPair*
noteq_bitwise_or_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static CmpopExprPair*
lte_bitwise_or_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static CmpopExprPair*
lt_bitwise_or_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static CmpopExprPair*
gte_bitwise_or_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static CmpopExprPair*
gt_bitwise_or_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static CmpopExprPair*
notin_bitwise_or_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static CmpopExprPair*
in_bitwise_or_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static CmpopExprPair*
isnot_bitwise_or_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static CmpopExprPair*
is_bitwise_or_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
bitwise_or_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
expr_ty _res = NULL;
static expr_ty
bitwise_or_raw(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
bitwise_xor_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
expr_ty _res = NULL;
static expr_ty
bitwise_xor_raw(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
bitwise_and_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
expr_ty _res = NULL;
static expr_ty
bitwise_and_raw(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
shift_expr_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
expr_ty _res = NULL;
static expr_ty
shift_expr_raw(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
sum_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
expr_ty _res = NULL;
static expr_ty
sum_raw(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
term_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
expr_ty _res = NULL;
static expr_ty
term_raw(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
factor_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
power_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
await_primary_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
primary_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
expr_ty _res = NULL;
static expr_ty
primary_raw(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
slices_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
slice_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
atom_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
group_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
lambdef_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arguments_ty
lambda_params_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arguments_ty
lambda_parameters_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_arg_seq*
lambda_slash_no_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static SlashWithDefault*
lambda_slash_with_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static StarEtc*
lambda_star_etc_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arg_ty
lambda_kwds_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arg_ty
lambda_param_no_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static NameDefaultPair*
lambda_param_with_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static NameDefaultPair*
lambda_param_maybe_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static arg_ty
lambda_param_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
fstring_middle_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
fstring_replacement_field_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static ResultTokenWithMetadata*
fstring_conversion_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static ResultTokenWithMetadata*
fstring_full_format_spec_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
fstring_format_spec_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
fstring_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
string_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
strings_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
list_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
tuple_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
set_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
dict_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq*
double_starred_kvpairs_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static KeyValuePair*
double_starred_kvpair_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static KeyValuePair*
kvpair_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_comprehension_seq*
for_if_clauses_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static comprehension_ty
for_if_clause_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
listcomp_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
setcomp_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
genexp_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
dictcomp_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
arguments_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
args_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq*
kwargs_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
starred_expression_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static KeywordOrStarred*
kwarg_or_starred_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static KeywordOrStarred*
kwarg_or_double_starred_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
star_targets_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_expr_seq*
star_targets_list_seq_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_expr_seq*
star_targets_tuple_seq_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
star_target_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
target_with_star_atom_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
star_atom_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
single_target_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
single_subscript_attribute_target_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
t_primary_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
expr_ty _res = NULL;
static expr_ty
t_primary_raw(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
t_lookahead_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_expr_seq*
del_targets_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
del_target_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
del_t_atom_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_expr_seq*
type_expressions_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static Token*
func_type_comment_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_arguments_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_kwarg_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
{
int _prev_call_invalid = p->call_invalid_rules;
p->call_invalid_rules = 0;
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_legacy_expression_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_type_param_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_expression_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_named_expression_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_assignment_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static expr_ty
invalid_ann_assign_target_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_del_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_block_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_comprehension_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_dict_comprehension_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_parameters_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_default_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_star_etc_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_kwds_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_parameters_helper_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_lambda_parameters_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_lambda_parameters_helper_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_lambda_star_etc_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_lambda_kwds_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_double_type_comments_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_with_item_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_for_if_clause_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_for_target_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_group_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_import_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_import_from_targets_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_with_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_with_stmt_indent_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_try_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_except_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_except_star_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_finally_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_except_stmt_indent_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_except_star_stmt_indent_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_match_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_case_block_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_as_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_class_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_pattern_seq*
invalid_class_argument_pattern_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_if_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_elif_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_else_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_while_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_for_stmt_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_def_raw_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_class_def_raw_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_double_starred_kvpairs_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_kvpair_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_starred_expression_unpacking_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_starred_expression_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_replacement_field_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_conversion_character_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_arithmetic_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_factor_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
invalid_type_params_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_1_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_2_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_3_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_4_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_5_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_6_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_7_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_8_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_9_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_10_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_11_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_12_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_13_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_14_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_15_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_16_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_17_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_18_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_19_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_20_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_21_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_22_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_23_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_24_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_25_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_26_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_27_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_28_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_29_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_30_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_31_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_32_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_33_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_34_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_35_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_36_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_37_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_38_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_39_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_40_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_41_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_42_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_43_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_44_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_45_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_46_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_47_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_48_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_49_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_50_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_51_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_52_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_53_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_54_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_55_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_56_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_57_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_58_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_59_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_60_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_61_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_62_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_63_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_64_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_65_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_66_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_67_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_68_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_69_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_70_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_71_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_72_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_73_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_74_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_75_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_76_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_77_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_78_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_79_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_80_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_81_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_82_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_83_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_84_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_85_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_86_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_87_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_88_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_89_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_90_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_91_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_92_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_93_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_94_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_95_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_96_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_97_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_98_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_99_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_100_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_101_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_102_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_103_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_104_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_105_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_106_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_107_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_108_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_109_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_110_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop1_111_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_112_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_113_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_114_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_115_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_116_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_117_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_118_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_119_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_120_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_121_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_122_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_123_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_124_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_125_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_126_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_127_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_128_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_129_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_130_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_131_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_132_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_133_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_134_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_135_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_136_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_137_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_138_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_gather_139_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_140_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_141_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_142_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_143_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_144_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_145_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_146_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_147_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_148_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_149_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_150_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_151_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_152_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_153_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_154_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_155_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_156_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_157_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_158_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_159_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_160_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_161_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_162_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_163_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_164_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_165_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_166_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_167_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static asdl_seq *
_loop0_168_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_169_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_170_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_171_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
static void *
_tmp_172_rule(Parser *p)
{
- if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {
+ if (p->level++ == MAXSTACK) {
_Pypegen_stack_overflow(p);
}
if (p->error_indicator) {
#include "structmember.h"
#include <stddef.h>
+struct validator {
+ int recursion_depth; /* current recursion depth */
+ int recursion_limit; /* recursion limit */
+};
+
// Forward declaration
static int init_types(void *arg);
GENERATE_ASDL_SEQ_CONSTRUCTOR(type_ignore, type_ignore_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(type_param, type_param_ty)
-static PyObject* ast2obj_mod(struct ast_state *state, void*);
+static PyObject* ast2obj_mod(struct ast_state *state, struct validator *vstate,
+ void*);
static const char * const Module_fields[]={
"body",
"type_ignores",
"end_lineno",
"end_col_offset",
};
-static PyObject* ast2obj_stmt(struct ast_state *state, void*);
+static PyObject* ast2obj_stmt(struct ast_state *state, struct validator
+ *vstate, void*);
static const char * const FunctionDef_fields[]={
"name",
"args",
"end_lineno",
"end_col_offset",
};
-static PyObject* ast2obj_expr(struct ast_state *state, void*);
+static PyObject* ast2obj_expr(struct ast_state *state, struct validator
+ *vstate, void*);
static const char * const BoolOp_fields[]={
"op",
"values",
"upper",
"step",
};
-static PyObject* ast2obj_expr_context(struct ast_state *state, expr_context_ty);
-static PyObject* ast2obj_boolop(struct ast_state *state, boolop_ty);
-static PyObject* ast2obj_operator(struct ast_state *state, operator_ty);
-static PyObject* ast2obj_unaryop(struct ast_state *state, unaryop_ty);
-static PyObject* ast2obj_cmpop(struct ast_state *state, cmpop_ty);
-static PyObject* ast2obj_comprehension(struct ast_state *state, void*);
+static PyObject* ast2obj_expr_context(struct ast_state *state, struct validator
+ *vstate, expr_context_ty);
+static PyObject* ast2obj_boolop(struct ast_state *state, struct validator
+ *vstate, boolop_ty);
+static PyObject* ast2obj_operator(struct ast_state *state, struct validator
+ *vstate, operator_ty);
+static PyObject* ast2obj_unaryop(struct ast_state *state, struct validator
+ *vstate, unaryop_ty);
+static PyObject* ast2obj_cmpop(struct ast_state *state, struct validator
+ *vstate, cmpop_ty);
+static PyObject* ast2obj_comprehension(struct ast_state *state, struct
+ validator *vstate, void*);
static const char * const comprehension_fields[]={
"target",
"iter",
"end_lineno",
"end_col_offset",
};
-static PyObject* ast2obj_excepthandler(struct ast_state *state, void*);
+static PyObject* ast2obj_excepthandler(struct ast_state *state, struct
+ validator *vstate, void*);
static const char * const ExceptHandler_fields[]={
"type",
"name",
"body",
};
-static PyObject* ast2obj_arguments(struct ast_state *state, void*);
+static PyObject* ast2obj_arguments(struct ast_state *state, struct validator
+ *vstate, void*);
static const char * const arguments_fields[]={
"posonlyargs",
"args",
"kwarg",
"defaults",
};
-static PyObject* ast2obj_arg(struct ast_state *state, void*);
+static PyObject* ast2obj_arg(struct ast_state *state, struct validator *vstate,
+ void*);
static const char * const arg_attributes[] = {
"lineno",
"col_offset",
"annotation",
"type_comment",
};
-static PyObject* ast2obj_keyword(struct ast_state *state, void*);
+static PyObject* ast2obj_keyword(struct ast_state *state, struct validator
+ *vstate, void*);
static const char * const keyword_attributes[] = {
"lineno",
"col_offset",
"arg",
"value",
};
-static PyObject* ast2obj_alias(struct ast_state *state, void*);
+static PyObject* ast2obj_alias(struct ast_state *state, struct validator
+ *vstate, void*);
static const char * const alias_attributes[] = {
"lineno",
"col_offset",
"name",
"asname",
};
-static PyObject* ast2obj_withitem(struct ast_state *state, void*);
+static PyObject* ast2obj_withitem(struct ast_state *state, struct validator
+ *vstate, void*);
static const char * const withitem_fields[]={
"context_expr",
"optional_vars",
};
-static PyObject* ast2obj_match_case(struct ast_state *state, void*);
+static PyObject* ast2obj_match_case(struct ast_state *state, struct validator
+ *vstate, void*);
static const char * const match_case_fields[]={
"pattern",
"guard",
"end_lineno",
"end_col_offset",
};
-static PyObject* ast2obj_pattern(struct ast_state *state, void*);
+static PyObject* ast2obj_pattern(struct ast_state *state, struct validator
+ *vstate, void*);
static const char * const MatchValue_fields[]={
"value",
};
static const char * const MatchOr_fields[]={
"patterns",
};
-static PyObject* ast2obj_type_ignore(struct ast_state *state, void*);
+static PyObject* ast2obj_type_ignore(struct ast_state *state, struct validator
+ *vstate, void*);
static const char * const TypeIgnore_fields[]={
"lineno",
"tag",
"end_lineno",
"end_col_offset",
};
-static PyObject* ast2obj_type_param(struct ast_state *state, void*);
+static PyObject* ast2obj_type_param(struct ast_state *state, struct validator
+ *vstate, void*);
static const char * const TypeVar_fields[]={
"name",
"bound",
/* Conversion AST -> Python */
-static PyObject* ast2obj_list(struct ast_state *state, asdl_seq *seq,
- PyObject* (*func)(struct ast_state *state, void*))
+static PyObject* ast2obj_list(struct ast_state *state, struct validator *vstate, asdl_seq *seq,
+ PyObject* (*func)(struct ast_state *state, struct validator *vstate, void*))
{
Py_ssize_t i, n = asdl_seq_LEN(seq);
PyObject *result = PyList_New(n);
if (!result)
return NULL;
for (i = 0; i < n; i++) {
- value = func(state, asdl_seq_GET_UNTYPED(seq, i));
+ value = func(state, vstate, asdl_seq_GET_UNTYPED(seq, i));
if (!value) {
Py_DECREF(result);
return NULL;
return result;
}
-static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), void *o)
+static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), struct validator *Py_UNUSED(vstate), void *o)
{
PyObject *op = (PyObject*)o;
if (!op) {
#define ast2obj_identifier ast2obj_object
#define ast2obj_string ast2obj_object
-static PyObject* ast2obj_int(struct ast_state *Py_UNUSED(state), long b)
+static PyObject* ast2obj_int(struct ast_state *Py_UNUSED(state), struct validator *Py_UNUSED(vstate), long b)
{
return PyLong_FromLong(b);
}
PyObject*
-ast2obj_mod(struct ast_state *state, void* _o)
+ast2obj_mod(struct ast_state *state, struct validator *vstate, void* _o)
{
mod_ty o = (mod_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
switch (o->kind) {
tp = (PyTypeObject *)state->Module_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.Module.body, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Module.body,
+ ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.Module.type_ignores,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.Module.type_ignores,
ast2obj_type_ignore);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_ignores, value) == -1)
tp = (PyTypeObject *)state->Interactive_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.Interactive.body,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Interactive.body,
ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
tp = (PyTypeObject *)state->Expression_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Expression.body);
+ value = ast2obj_expr(state, vstate, o->v.Expression.body);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
tp = (PyTypeObject *)state->FunctionType_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.FunctionType.argtypes,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.FunctionType.argtypes,
ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->argtypes, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.FunctionType.returns);
+ value = ast2obj_expr(state, vstate, o->v.FunctionType.returns);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->returns, value) == -1)
goto failed;
Py_DECREF(value);
break;
}
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_stmt(struct ast_state *state, void* _o)
+ast2obj_stmt(struct ast_state *state, struct validator *vstate, void* _o)
{
stmt_ty o = (stmt_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
switch (o->kind) {
tp = (PyTypeObject *)state->FunctionDef_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_identifier(state, o->v.FunctionDef.name);
+ value = ast2obj_identifier(state, vstate, o->v.FunctionDef.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_arguments(state, o->v.FunctionDef.args);
+ value = ast2obj_arguments(state, vstate, o->v.FunctionDef.args);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->args, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.FunctionDef.body,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.FunctionDef.body,
ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.FunctionDef.decorator_list,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.FunctionDef.decorator_list,
ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.FunctionDef.returns);
+ value = ast2obj_expr(state, vstate, o->v.FunctionDef.returns);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->returns, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_string(state, o->v.FunctionDef.type_comment);
+ value = ast2obj_string(state, vstate, o->v.FunctionDef.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_comment, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.FunctionDef.type_params,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.FunctionDef.type_params,
ast2obj_type_param);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_params, value) == -1)
tp = (PyTypeObject *)state->AsyncFunctionDef_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_identifier(state, o->v.AsyncFunctionDef.name);
+ value = ast2obj_identifier(state, vstate, o->v.AsyncFunctionDef.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_arguments(state, o->v.AsyncFunctionDef.args);
+ value = ast2obj_arguments(state, vstate, o->v.AsyncFunctionDef.args);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->args, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.AsyncFunctionDef.body,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.AsyncFunctionDef.body,
ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state,
+ value = ast2obj_list(state, vstate,
(asdl_seq*)o->v.AsyncFunctionDef.decorator_list,
ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.AsyncFunctionDef.returns);
+ value = ast2obj_expr(state, vstate, o->v.AsyncFunctionDef.returns);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->returns, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_string(state, o->v.AsyncFunctionDef.type_comment);
+ value = ast2obj_string(state, vstate, o->v.AsyncFunctionDef.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_comment, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state,
+ value = ast2obj_list(state, vstate,
(asdl_seq*)o->v.AsyncFunctionDef.type_params,
ast2obj_type_param);
if (!value) goto failed;
tp = (PyTypeObject *)state->ClassDef_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_identifier(state, o->v.ClassDef.name);
+ value = ast2obj_identifier(state, vstate, o->v.ClassDef.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.bases,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.ClassDef.bases,
ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->bases, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.keywords,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.ClassDef.keywords,
ast2obj_keyword);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->keywords, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.body,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.ClassDef.body,
ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.decorator_list,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.ClassDef.decorator_list,
ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->decorator_list, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.type_params,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.ClassDef.type_params,
ast2obj_type_param);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_params, value) == -1)
tp = (PyTypeObject *)state->Return_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Return.value);
+ value = ast2obj_expr(state, vstate, o->v.Return.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Delete_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.Delete.targets,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Delete.targets,
ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->targets, value) == -1)
tp = (PyTypeObject *)state->Assign_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.Assign.targets,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Assign.targets,
ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->targets, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.Assign.value);
+ value = ast2obj_expr(state, vstate, o->v.Assign.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_string(state, o->v.Assign.type_comment);
+ value = ast2obj_string(state, vstate, o->v.Assign.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_comment, value) == -1)
goto failed;
tp = (PyTypeObject *)state->TypeAlias_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.TypeAlias.name);
+ value = ast2obj_expr(state, vstate, o->v.TypeAlias.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.TypeAlias.type_params,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.TypeAlias.type_params,
ast2obj_type_param);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_params, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.TypeAlias.value);
+ value = ast2obj_expr(state, vstate, o->v.TypeAlias.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
tp = (PyTypeObject *)state->AugAssign_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.AugAssign.target);
+ value = ast2obj_expr(state, vstate, o->v.AugAssign.target);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->target, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_operator(state, o->v.AugAssign.op);
+ value = ast2obj_operator(state, vstate, o->v.AugAssign.op);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->op, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.AugAssign.value);
+ value = ast2obj_expr(state, vstate, o->v.AugAssign.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
tp = (PyTypeObject *)state->AnnAssign_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.AnnAssign.target);
+ value = ast2obj_expr(state, vstate, o->v.AnnAssign.target);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->target, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.AnnAssign.annotation);
+ value = ast2obj_expr(state, vstate, o->v.AnnAssign.annotation);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->annotation, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.AnnAssign.value);
+ value = ast2obj_expr(state, vstate, o->v.AnnAssign.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->v.AnnAssign.simple);
+ value = ast2obj_int(state, vstate, o->v.AnnAssign.simple);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->simple, value) == -1)
goto failed;
tp = (PyTypeObject *)state->For_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.For.target);
+ value = ast2obj_expr(state, vstate, o->v.For.target);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->target, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.For.iter);
+ value = ast2obj_expr(state, vstate, o->v.For.iter);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->iter, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.For.body, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.For.body,
+ ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.For.orelse, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.For.orelse,
+ ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->orelse, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_string(state, o->v.For.type_comment);
+ value = ast2obj_string(state, vstate, o->v.For.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_comment, value) == -1)
goto failed;
tp = (PyTypeObject *)state->AsyncFor_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.AsyncFor.target);
+ value = ast2obj_expr(state, vstate, o->v.AsyncFor.target);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->target, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.AsyncFor.iter);
+ value = ast2obj_expr(state, vstate, o->v.AsyncFor.iter);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->iter, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.AsyncFor.body,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.AsyncFor.body,
ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.AsyncFor.orelse,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.AsyncFor.orelse,
ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->orelse, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_string(state, o->v.AsyncFor.type_comment);
+ value = ast2obj_string(state, vstate, o->v.AsyncFor.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_comment, value) == -1)
goto failed;
tp = (PyTypeObject *)state->While_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.While.test);
+ value = ast2obj_expr(state, vstate, o->v.While.test);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->test, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.While.body, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.While.body,
+ ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.While.orelse, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.While.orelse,
+ ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->orelse, value) == -1)
goto failed;
tp = (PyTypeObject *)state->If_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.If.test);
+ value = ast2obj_expr(state, vstate, o->v.If.test);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->test, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.If.body, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.If.body,
+ ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.If.orelse, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.If.orelse,
+ ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->orelse, value) == -1)
goto failed;
tp = (PyTypeObject *)state->With_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.With.items,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.With.items,
ast2obj_withitem);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->items, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.With.body, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.With.body,
+ ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_string(state, o->v.With.type_comment);
+ value = ast2obj_string(state, vstate, o->v.With.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_comment, value) == -1)
goto failed;
tp = (PyTypeObject *)state->AsyncWith_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.AsyncWith.items,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.AsyncWith.items,
ast2obj_withitem);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->items, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.AsyncWith.body,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.AsyncWith.body,
ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_string(state, o->v.AsyncWith.type_comment);
+ value = ast2obj_string(state, vstate, o->v.AsyncWith.type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_comment, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Match_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Match.subject);
+ value = ast2obj_expr(state, vstate, o->v.Match.subject);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->subject, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.Match.cases,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Match.cases,
ast2obj_match_case);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->cases, value) == -1)
tp = (PyTypeObject *)state->Raise_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Raise.exc);
+ value = ast2obj_expr(state, vstate, o->v.Raise.exc);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->exc, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.Raise.cause);
+ value = ast2obj_expr(state, vstate, o->v.Raise.cause);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->cause, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Try_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.Try.body, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Try.body,
+ ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.Try.handlers,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Try.handlers,
ast2obj_excepthandler);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->handlers, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.Try.orelse, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Try.orelse,
+ ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->orelse, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.Try.finalbody,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Try.finalbody,
ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->finalbody, value) == -1)
tp = (PyTypeObject *)state->TryStar_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.body, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.TryStar.body,
+ ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.handlers,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.TryStar.handlers,
ast2obj_excepthandler);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->handlers, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.orelse,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.TryStar.orelse,
ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->orelse, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.TryStar.finalbody,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.TryStar.finalbody,
ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->finalbody, value) == -1)
tp = (PyTypeObject *)state->Assert_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Assert.test);
+ value = ast2obj_expr(state, vstate, o->v.Assert.test);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->test, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.Assert.msg);
+ value = ast2obj_expr(state, vstate, o->v.Assert.msg);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->msg, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Import_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.Import.names,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Import.names,
ast2obj_alias);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->names, value) == -1)
tp = (PyTypeObject *)state->ImportFrom_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_identifier(state, o->v.ImportFrom.module);
+ value = ast2obj_identifier(state, vstate, o->v.ImportFrom.module);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->module, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.ImportFrom.names,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.ImportFrom.names,
ast2obj_alias);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->names, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->v.ImportFrom.level);
+ value = ast2obj_int(state, vstate, o->v.ImportFrom.level);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->level, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Global_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.Global.names,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Global.names,
ast2obj_identifier);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->names, value) == -1)
tp = (PyTypeObject *)state->Nonlocal_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.Nonlocal.names,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Nonlocal.names,
ast2obj_identifier);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->names, value) == -1)
tp = (PyTypeObject *)state->Expr_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Expr.value);
+ value = ast2obj_expr(state, vstate, o->v.Expr.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
if (!result) goto failed;
break;
}
- value = ast2obj_int(state, o->lineno);
+ value = ast2obj_int(state, vstate, o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->col_offset);
+ value = ast2obj_int(state, vstate, o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_lineno);
+ value = ast2obj_int(state, vstate, o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_col_offset);
+ value = ast2obj_int(state, vstate, o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_expr(struct ast_state *state, void* _o)
+ast2obj_expr(struct ast_state *state, struct validator *vstate, void* _o)
{
expr_ty o = (expr_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
switch (o->kind) {
tp = (PyTypeObject *)state->BoolOp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_boolop(state, o->v.BoolOp.op);
+ value = ast2obj_boolop(state, vstate, o->v.BoolOp.op);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->op, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.BoolOp.values,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.BoolOp.values,
ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->values, value) == -1)
tp = (PyTypeObject *)state->NamedExpr_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.NamedExpr.target);
+ value = ast2obj_expr(state, vstate, o->v.NamedExpr.target);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->target, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.NamedExpr.value);
+ value = ast2obj_expr(state, vstate, o->v.NamedExpr.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
tp = (PyTypeObject *)state->BinOp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.BinOp.left);
+ value = ast2obj_expr(state, vstate, o->v.BinOp.left);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->left, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_operator(state, o->v.BinOp.op);
+ value = ast2obj_operator(state, vstate, o->v.BinOp.op);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->op, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.BinOp.right);
+ value = ast2obj_expr(state, vstate, o->v.BinOp.right);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->right, value) == -1)
goto failed;
tp = (PyTypeObject *)state->UnaryOp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_unaryop(state, o->v.UnaryOp.op);
+ value = ast2obj_unaryop(state, vstate, o->v.UnaryOp.op);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->op, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.UnaryOp.operand);
+ value = ast2obj_expr(state, vstate, o->v.UnaryOp.operand);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->operand, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Lambda_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_arguments(state, o->v.Lambda.args);
+ value = ast2obj_arguments(state, vstate, o->v.Lambda.args);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->args, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.Lambda.body);
+ value = ast2obj_expr(state, vstate, o->v.Lambda.body);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
tp = (PyTypeObject *)state->IfExp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.IfExp.test);
+ value = ast2obj_expr(state, vstate, o->v.IfExp.test);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->test, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.IfExp.body);
+ value = ast2obj_expr(state, vstate, o->v.IfExp.body);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.IfExp.orelse);
+ value = ast2obj_expr(state, vstate, o->v.IfExp.orelse);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->orelse, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Dict_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.Dict.keys, ast2obj_expr);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Dict.keys,
+ ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->keys, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.Dict.values, ast2obj_expr);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Dict.values,
+ ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->values, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Set_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.Set.elts, ast2obj_expr);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Set.elts,
+ ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->elts, value) == -1)
goto failed;
tp = (PyTypeObject *)state->ListComp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.ListComp.elt);
+ value = ast2obj_expr(state, vstate, o->v.ListComp.elt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->elt, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.ListComp.generators,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.ListComp.generators,
ast2obj_comprehension);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->generators, value) == -1)
tp = (PyTypeObject *)state->SetComp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.SetComp.elt);
+ value = ast2obj_expr(state, vstate, o->v.SetComp.elt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->elt, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.SetComp.generators,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.SetComp.generators,
ast2obj_comprehension);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->generators, value) == -1)
tp = (PyTypeObject *)state->DictComp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.DictComp.key);
+ value = ast2obj_expr(state, vstate, o->v.DictComp.key);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->key, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.DictComp.value);
+ value = ast2obj_expr(state, vstate, o->v.DictComp.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.DictComp.generators,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.DictComp.generators,
ast2obj_comprehension);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->generators, value) == -1)
tp = (PyTypeObject *)state->GeneratorExp_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.GeneratorExp.elt);
+ value = ast2obj_expr(state, vstate, o->v.GeneratorExp.elt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->elt, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.GeneratorExp.generators,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.GeneratorExp.generators,
ast2obj_comprehension);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->generators, value) == -1)
tp = (PyTypeObject *)state->Await_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Await.value);
+ value = ast2obj_expr(state, vstate, o->v.Await.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Yield_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Yield.value);
+ value = ast2obj_expr(state, vstate, o->v.Yield.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
tp = (PyTypeObject *)state->YieldFrom_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.YieldFrom.value);
+ value = ast2obj_expr(state, vstate, o->v.YieldFrom.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Compare_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Compare.left);
+ value = ast2obj_expr(state, vstate, o->v.Compare.left);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->left, value) == -1)
goto failed;
value = PyList_New(n);
if (!value) goto failed;
for(i = 0; i < n; i++)
- PyList_SET_ITEM(value, i, ast2obj_cmpop(state, (cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i)));
+ PyList_SET_ITEM(value, i, ast2obj_cmpop(state, vstate, (cmpop_ty)asdl_seq_GET(o->v.Compare.ops, i)));
}
if (!value) goto failed;
if (PyObject_SetAttr(result, state->ops, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.Compare.comparators,
- ast2obj_expr);
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.Compare.comparators, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->comparators, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Call_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Call.func);
+ value = ast2obj_expr(state, vstate, o->v.Call.func);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->func, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.Call.args, ast2obj_expr);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Call.args,
+ ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->args, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.Call.keywords,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Call.keywords,
ast2obj_keyword);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->keywords, value) == -1)
tp = (PyTypeObject *)state->FormattedValue_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.FormattedValue.value);
+ value = ast2obj_expr(state, vstate, o->v.FormattedValue.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->v.FormattedValue.conversion);
+ value = ast2obj_int(state, vstate, o->v.FormattedValue.conversion);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->conversion, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.FormattedValue.format_spec);
+ value = ast2obj_expr(state, vstate, o->v.FormattedValue.format_spec);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->format_spec, value) == -1)
goto failed;
tp = (PyTypeObject *)state->JoinedStr_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.JoinedStr.values,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.JoinedStr.values,
ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->values, value) == -1)
tp = (PyTypeObject *)state->Constant_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_constant(state, o->v.Constant.value);
+ value = ast2obj_constant(state, vstate, o->v.Constant.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_string(state, o->v.Constant.kind);
+ value = ast2obj_string(state, vstate, o->v.Constant.kind);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->kind, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Attribute_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Attribute.value);
+ value = ast2obj_expr(state, vstate, o->v.Attribute.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_identifier(state, o->v.Attribute.attr);
+ value = ast2obj_identifier(state, vstate, o->v.Attribute.attr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->attr, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr_context(state, o->v.Attribute.ctx);
+ value = ast2obj_expr_context(state, vstate, o->v.Attribute.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->ctx, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Subscript_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Subscript.value);
+ value = ast2obj_expr(state, vstate, o->v.Subscript.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.Subscript.slice);
+ value = ast2obj_expr(state, vstate, o->v.Subscript.slice);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->slice, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr_context(state, o->v.Subscript.ctx);
+ value = ast2obj_expr_context(state, vstate, o->v.Subscript.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->ctx, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Starred_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Starred.value);
+ value = ast2obj_expr(state, vstate, o->v.Starred.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr_context(state, o->v.Starred.ctx);
+ value = ast2obj_expr_context(state, vstate, o->v.Starred.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->ctx, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Name_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_identifier(state, o->v.Name.id);
+ value = ast2obj_identifier(state, vstate, o->v.Name.id);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->id, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr_context(state, o->v.Name.ctx);
+ value = ast2obj_expr_context(state, vstate, o->v.Name.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->ctx, value) == -1)
goto failed;
tp = (PyTypeObject *)state->List_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.List.elts, ast2obj_expr);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.List.elts,
+ ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->elts, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr_context(state, o->v.List.ctx);
+ value = ast2obj_expr_context(state, vstate, o->v.List.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->ctx, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Tuple_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.Tuple.elts, ast2obj_expr);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.Tuple.elts,
+ ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->elts, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr_context(state, o->v.Tuple.ctx);
+ value = ast2obj_expr_context(state, vstate, o->v.Tuple.ctx);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->ctx, value) == -1)
goto failed;
tp = (PyTypeObject *)state->Slice_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.Slice.lower);
+ value = ast2obj_expr(state, vstate, o->v.Slice.lower);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->lower, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.Slice.upper);
+ value = ast2obj_expr(state, vstate, o->v.Slice.upper);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->upper, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.Slice.step);
+ value = ast2obj_expr(state, vstate, o->v.Slice.step);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->step, value) == -1)
goto failed;
Py_DECREF(value);
break;
}
- value = ast2obj_int(state, o->lineno);
+ value = ast2obj_int(state, vstate, o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->col_offset);
+ value = ast2obj_int(state, vstate, o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_lineno);
+ value = ast2obj_int(state, vstate, o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_col_offset);
+ value = ast2obj_int(state, vstate, o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
-PyObject* ast2obj_expr_context(struct ast_state *state, expr_context_ty o)
+PyObject* ast2obj_expr_context(struct ast_state *state, struct validator
+ *vstate, expr_context_ty o)
{
switch(o) {
case Load:
}
Py_UNREACHABLE();
}
-PyObject* ast2obj_boolop(struct ast_state *state, boolop_ty o)
+PyObject* ast2obj_boolop(struct ast_state *state, struct validator *vstate,
+ boolop_ty o)
{
switch(o) {
case And:
}
Py_UNREACHABLE();
}
-PyObject* ast2obj_operator(struct ast_state *state, operator_ty o)
+PyObject* ast2obj_operator(struct ast_state *state, struct validator *vstate,
+ operator_ty o)
{
switch(o) {
case Add:
}
Py_UNREACHABLE();
}
-PyObject* ast2obj_unaryop(struct ast_state *state, unaryop_ty o)
+PyObject* ast2obj_unaryop(struct ast_state *state, struct validator *vstate,
+ unaryop_ty o)
{
switch(o) {
case Invert:
}
Py_UNREACHABLE();
}
-PyObject* ast2obj_cmpop(struct ast_state *state, cmpop_ty o)
+PyObject* ast2obj_cmpop(struct ast_state *state, struct validator *vstate,
+ cmpop_ty o)
{
switch(o) {
case Eq:
Py_UNREACHABLE();
}
PyObject*
-ast2obj_comprehension(struct ast_state *state, void* _o)
+ast2obj_comprehension(struct ast_state *state, struct validator *vstate, void*
+ _o)
{
comprehension_ty o = (comprehension_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
tp = (PyTypeObject *)state->comprehension_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
- value = ast2obj_expr(state, o->target);
+ value = ast2obj_expr(state, vstate, o->target);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->target, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->iter);
+ value = ast2obj_expr(state, vstate, o->iter);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->iter, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->ifs, ast2obj_expr);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->ifs, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->ifs, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->is_async);
+ value = ast2obj_int(state, vstate, o->is_async);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->is_async, value) == -1)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_excepthandler(struct ast_state *state, void* _o)
+ast2obj_excepthandler(struct ast_state *state, struct validator *vstate, void*
+ _o)
{
excepthandler_ty o = (excepthandler_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
switch (o->kind) {
tp = (PyTypeObject *)state->ExceptHandler_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.ExceptHandler.type);
+ value = ast2obj_expr(state, vstate, o->v.ExceptHandler.type);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_identifier(state, o->v.ExceptHandler.name);
+ value = ast2obj_identifier(state, vstate, o->v.ExceptHandler.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.ExceptHandler.body,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.ExceptHandler.body,
ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
Py_DECREF(value);
break;
}
- value = ast2obj_int(state, o->lineno);
+ value = ast2obj_int(state, vstate, o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->col_offset);
+ value = ast2obj_int(state, vstate, o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_lineno);
+ value = ast2obj_int(state, vstate, o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_col_offset);
+ value = ast2obj_int(state, vstate, o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_arguments(struct ast_state *state, void* _o)
+ast2obj_arguments(struct ast_state *state, struct validator *vstate, void* _o)
{
arguments_ty o = (arguments_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
tp = (PyTypeObject *)state->arguments_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
- value = ast2obj_list(state, (asdl_seq*)o->posonlyargs, ast2obj_arg);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->posonlyargs, ast2obj_arg);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->posonlyargs, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->args, ast2obj_arg);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->args, ast2obj_arg);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->args, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_arg(state, o->vararg);
+ value = ast2obj_arg(state, vstate, o->vararg);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->vararg, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->kwonlyargs, ast2obj_arg);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->kwonlyargs, ast2obj_arg);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->kwonlyargs, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->kw_defaults, ast2obj_expr);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->kw_defaults,
+ ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->kw_defaults, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_arg(state, o->kwarg);
+ value = ast2obj_arg(state, vstate, o->kwarg);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->kwarg, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->defaults, ast2obj_expr);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->defaults, ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->defaults, value) == -1)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_arg(struct ast_state *state, void* _o)
+ast2obj_arg(struct ast_state *state, struct validator *vstate, void* _o)
{
arg_ty o = (arg_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
tp = (PyTypeObject *)state->arg_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
- value = ast2obj_identifier(state, o->arg);
+ value = ast2obj_identifier(state, vstate, o->arg);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->arg, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->annotation);
+ value = ast2obj_expr(state, vstate, o->annotation);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->annotation, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_string(state, o->type_comment);
+ value = ast2obj_string(state, vstate, o->type_comment);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->type_comment, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->lineno);
+ value = ast2obj_int(state, vstate, o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->col_offset);
+ value = ast2obj_int(state, vstate, o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_lineno);
+ value = ast2obj_int(state, vstate, o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_col_offset);
+ value = ast2obj_int(state, vstate, o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_keyword(struct ast_state *state, void* _o)
+ast2obj_keyword(struct ast_state *state, struct validator *vstate, void* _o)
{
keyword_ty o = (keyword_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
tp = (PyTypeObject *)state->keyword_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
- value = ast2obj_identifier(state, o->arg);
+ value = ast2obj_identifier(state, vstate, o->arg);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->arg, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->value);
+ value = ast2obj_expr(state, vstate, o->value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->lineno);
+ value = ast2obj_int(state, vstate, o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->col_offset);
+ value = ast2obj_int(state, vstate, o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_lineno);
+ value = ast2obj_int(state, vstate, o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_col_offset);
+ value = ast2obj_int(state, vstate, o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_alias(struct ast_state *state, void* _o)
+ast2obj_alias(struct ast_state *state, struct validator *vstate, void* _o)
{
alias_ty o = (alias_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
tp = (PyTypeObject *)state->alias_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
- value = ast2obj_identifier(state, o->name);
+ value = ast2obj_identifier(state, vstate, o->name);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_identifier(state, o->asname);
+ value = ast2obj_identifier(state, vstate, o->asname);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->asname, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->lineno);
+ value = ast2obj_int(state, vstate, o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->col_offset);
+ value = ast2obj_int(state, vstate, o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_lineno);
+ value = ast2obj_int(state, vstate, o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_col_offset);
+ value = ast2obj_int(state, vstate, o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_withitem(struct ast_state *state, void* _o)
+ast2obj_withitem(struct ast_state *state, struct validator *vstate, void* _o)
{
withitem_ty o = (withitem_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
tp = (PyTypeObject *)state->withitem_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
- value = ast2obj_expr(state, o->context_expr);
+ value = ast2obj_expr(state, vstate, o->context_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->context_expr, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->optional_vars);
+ value = ast2obj_expr(state, vstate, o->optional_vars);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->optional_vars, value) == -1)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_match_case(struct ast_state *state, void* _o)
+ast2obj_match_case(struct ast_state *state, struct validator *vstate, void* _o)
{
match_case_ty o = (match_case_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
tp = (PyTypeObject *)state->match_case_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) return NULL;
- value = ast2obj_pattern(state, o->pattern);
+ value = ast2obj_pattern(state, vstate, o->pattern);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->pattern, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->guard);
+ value = ast2obj_expr(state, vstate, o->guard);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->guard, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->body, ast2obj_stmt);
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->body, ast2obj_stmt);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->body, value) == -1)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_pattern(struct ast_state *state, void* _o)
+ast2obj_pattern(struct ast_state *state, struct validator *vstate, void* _o)
{
pattern_ty o = (pattern_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
switch (o->kind) {
tp = (PyTypeObject *)state->MatchValue_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.MatchValue.value);
+ value = ast2obj_expr(state, vstate, o->v.MatchValue.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
tp = (PyTypeObject *)state->MatchSingleton_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_constant(state, o->v.MatchSingleton.value);
+ value = ast2obj_constant(state, vstate, o->v.MatchSingleton.value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->value, value) == -1)
goto failed;
tp = (PyTypeObject *)state->MatchSequence_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.MatchSequence.patterns,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.MatchSequence.patterns,
ast2obj_pattern);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->patterns, value) == -1)
tp = (PyTypeObject *)state->MatchMapping_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.MatchMapping.keys,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.MatchMapping.keys,
ast2obj_expr);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->keys, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.MatchMapping.patterns,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.MatchMapping.patterns,
ast2obj_pattern);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->patterns, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_identifier(state, o->v.MatchMapping.rest);
+ value = ast2obj_identifier(state, vstate, o->v.MatchMapping.rest);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->rest, value) == -1)
goto failed;
tp = (PyTypeObject *)state->MatchClass_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_expr(state, o->v.MatchClass.cls);
+ value = ast2obj_expr(state, vstate, o->v.MatchClass.cls);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->cls, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.MatchClass.patterns,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.MatchClass.patterns,
ast2obj_pattern);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->patterns, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.MatchClass.kwd_attrs,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.MatchClass.kwd_attrs,
ast2obj_identifier);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->kwd_attrs, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_list(state, (asdl_seq*)o->v.MatchClass.kwd_patterns,
+ value = ast2obj_list(state, vstate,
+ (asdl_seq*)o->v.MatchClass.kwd_patterns,
ast2obj_pattern);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->kwd_patterns, value) == -1)
tp = (PyTypeObject *)state->MatchStar_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_identifier(state, o->v.MatchStar.name);
+ value = ast2obj_identifier(state, vstate, o->v.MatchStar.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed;
tp = (PyTypeObject *)state->MatchAs_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_pattern(state, o->v.MatchAs.pattern);
+ value = ast2obj_pattern(state, vstate, o->v.MatchAs.pattern);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->pattern, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_identifier(state, o->v.MatchAs.name);
+ value = ast2obj_identifier(state, vstate, o->v.MatchAs.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed;
tp = (PyTypeObject *)state->MatchOr_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_list(state, (asdl_seq*)o->v.MatchOr.patterns,
+ value = ast2obj_list(state, vstate, (asdl_seq*)o->v.MatchOr.patterns,
ast2obj_pattern);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->patterns, value) == -1)
Py_DECREF(value);
break;
}
- value = ast2obj_int(state, o->lineno);
+ value = ast2obj_int(state, vstate, o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->col_offset);
+ value = ast2obj_int(state, vstate, o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_lineno);
+ value = ast2obj_int(state, vstate, o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_col_offset);
+ value = ast2obj_int(state, vstate, o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_type_ignore(struct ast_state *state, void* _o)
+ast2obj_type_ignore(struct ast_state *state, struct validator *vstate, void* _o)
{
type_ignore_ty o = (type_ignore_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
switch (o->kind) {
tp = (PyTypeObject *)state->TypeIgnore_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_int(state, o->v.TypeIgnore.lineno);
+ value = ast2obj_int(state, vstate, o->v.TypeIgnore.lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->lineno, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_string(state, o->v.TypeIgnore.tag);
+ value = ast2obj_string(state, vstate, o->v.TypeIgnore.tag);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->tag, value) == -1)
goto failed;
Py_DECREF(value);
break;
}
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
}
PyObject*
-ast2obj_type_param(struct ast_state *state, void* _o)
+ast2obj_type_param(struct ast_state *state, struct validator *vstate, void* _o)
{
type_param_ty o = (type_param_ty)_o;
PyObject *result = NULL, *value = NULL;
if (!o) {
Py_RETURN_NONE;
}
- if (Py_EnterRecursiveCall("during ast construction")) {
+ if (++vstate->recursion_depth > vstate->recursion_limit) {
+ PyErr_SetString(PyExc_RecursionError,
+ "maximum recursion depth exceeded during ast construction");
return NULL;
}
switch (o->kind) {
tp = (PyTypeObject *)state->TypeVar_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_identifier(state, o->v.TypeVar.name);
+ value = ast2obj_identifier(state, vstate, o->v.TypeVar.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.TypeVar.bound);
+ value = ast2obj_expr(state, vstate, o->v.TypeVar.bound);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->bound, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.TypeVar.default_value);
+ value = ast2obj_expr(state, vstate, o->v.TypeVar.default_value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->default_value, value) == -1)
goto failed;
tp = (PyTypeObject *)state->ParamSpec_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_identifier(state, o->v.ParamSpec.name);
+ value = ast2obj_identifier(state, vstate, o->v.ParamSpec.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.ParamSpec.default_value);
+ value = ast2obj_expr(state, vstate, o->v.ParamSpec.default_value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->default_value, value) == -1)
goto failed;
tp = (PyTypeObject *)state->TypeVarTuple_type;
result = PyType_GenericNew(tp, NULL, NULL);
if (!result) goto failed;
- value = ast2obj_identifier(state, o->v.TypeVarTuple.name);
+ value = ast2obj_identifier(state, vstate, o->v.TypeVarTuple.name);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed;
Py_DECREF(value);
- value = ast2obj_expr(state, o->v.TypeVarTuple.default_value);
+ value = ast2obj_expr(state, vstate, o->v.TypeVarTuple.default_value);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->default_value, value) == -1)
goto failed;
Py_DECREF(value);
break;
}
- value = ast2obj_int(state, o->lineno);
+ value = ast2obj_int(state, vstate, o->lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->col_offset);
+ value = ast2obj_int(state, vstate, o->col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_lineno);
+ value = ast2obj_int(state, vstate, o->end_lineno);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_lineno, value) < 0)
goto failed;
Py_DECREF(value);
- value = ast2obj_int(state, o->end_col_offset);
+ value = ast2obj_int(state, vstate, o->end_col_offset);
if (!value) goto failed;
if (PyObject_SetAttr(result, state->end_col_offset, value) < 0)
goto failed;
Py_DECREF(value);
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
return result;
failed:
- Py_LeaveRecursiveCall();
+ vstate->recursion_depth--;
Py_XDECREF(value);
Py_XDECREF(result);
return NULL;
if (state == NULL) {
return NULL;
}
- PyObject *result = ast2obj_mod(state, t);
+ int starting_recursion_depth;
+ /* Be careful here to prevent overflow. */
+ PyThreadState *tstate = _PyThreadState_GET();
+ if (!tstate) {
+ return NULL;
+ }
+ struct validator vstate;
+ vstate.recursion_limit = Py_C_RECURSION_LIMIT;
+ int recursion_depth = Py_C_RECURSION_LIMIT - tstate->c_recursion_remaining;
+ starting_recursion_depth = recursion_depth;
+ vstate.recursion_depth = starting_recursion_depth;
+
+ PyObject *result = ast2obj_mod(state, &vstate, t);
+
+ /* Check that the recursion depth counting balanced correctly */
+ if (result && vstate.recursion_depth != starting_recursion_depth) {
+ PyErr_Format(PyExc_SystemError,
+ "AST constructor recursion depth mismatch (before=%d, after=%d)",
+ starting_recursion_depth, vstate.recursion_depth);
+ return NULL;
+ }
return result;
}
#include <assert.h>
#include <stdbool.h>
-#define ENTER_RECURSIVE() \
-if (Py_EnterRecursiveCall(" during compilation")) { \
- return 0; \
-}
+struct validator {
+ int recursion_depth; /* current recursion depth */
+ int recursion_limit; /* recursion limit */
+};
+
+#define ENTER_RECURSIVE(ST) \
+ do { \
+ if (++(ST)->recursion_depth > (ST)->recursion_limit) { \
+ PyErr_SetString(PyExc_RecursionError, \
+ "maximum recursion depth exceeded during compilation"); \
+ return 0; \
+ } \
+ } while(0)
-#define LEAVE_RECURSIVE() Py_LeaveRecursiveCall();
+#define LEAVE_RECURSIVE(ST) \
+ do { \
+ --(ST)->recursion_depth; \
+ } while(0)
-static int validate_stmts(asdl_stmt_seq *);
-static int validate_exprs(asdl_expr_seq *, expr_context_ty, int);
-static int validate_patterns(asdl_pattern_seq *, int);
-static int validate_type_params(asdl_type_param_seq *);
+static int validate_stmts(struct validator *, asdl_stmt_seq *);
+static int validate_exprs(struct validator *, asdl_expr_seq *, expr_context_ty, int);
+static int validate_patterns(struct validator *, asdl_pattern_seq *, int);
+static int validate_type_params(struct validator *, asdl_type_param_seq *);
static int _validate_nonempty_seq(asdl_seq *, const char *, const char *);
-static int validate_stmt(stmt_ty);
-static int validate_expr(expr_ty, expr_context_ty);
-static int validate_pattern(pattern_ty, int);
-static int validate_typeparam(type_param_ty);
+static int validate_stmt(struct validator *, stmt_ty);
+static int validate_expr(struct validator *, expr_ty, expr_context_ty);
+static int validate_pattern(struct validator *, pattern_ty, int);
+static int validate_typeparam(struct validator *, type_param_ty);
#define VALIDATE_POSITIONS(node) \
if (node->lineno > node->end_lineno) { \
}
static int
-validate_comprehension(asdl_comprehension_seq *gens)
+validate_comprehension(struct validator *state, asdl_comprehension_seq *gens)
{
assert(!PyErr_Occurred());
if (!asdl_seq_LEN(gens)) {
}
for (Py_ssize_t i = 0; i < asdl_seq_LEN(gens); i++) {
comprehension_ty comp = asdl_seq_GET(gens, i);
- if (!validate_expr(comp->target, Store) ||
- !validate_expr(comp->iter, Load) ||
- !validate_exprs(comp->ifs, Load, 0))
+ if (!validate_expr(state, comp->target, Store) ||
+ !validate_expr(state, comp->iter, Load) ||
+ !validate_exprs(state, comp->ifs, Load, 0))
return 0;
}
return 1;
}
static int
-validate_keywords(asdl_keyword_seq *keywords)
+validate_keywords(struct validator *state, asdl_keyword_seq *keywords)
{
assert(!PyErr_Occurred());
for (Py_ssize_t i = 0; i < asdl_seq_LEN(keywords); i++)
- if (!validate_expr((asdl_seq_GET(keywords, i))->value, Load))
+ if (!validate_expr(state, (asdl_seq_GET(keywords, i))->value, Load))
return 0;
return 1;
}
static int
-validate_args(asdl_arg_seq *args)
+validate_args(struct validator *state, asdl_arg_seq *args)
{
assert(!PyErr_Occurred());
for (Py_ssize_t i = 0; i < asdl_seq_LEN(args); i++) {
arg_ty arg = asdl_seq_GET(args, i);
VALIDATE_POSITIONS(arg);
- if (arg->annotation && !validate_expr(arg->annotation, Load))
+ if (arg->annotation && !validate_expr(state, arg->annotation, Load))
return 0;
}
return 1;
}
static int
-validate_arguments(arguments_ty args)
+validate_arguments(struct validator *state, arguments_ty args)
{
assert(!PyErr_Occurred());
- if (!validate_args(args->posonlyargs) || !validate_args(args->args)) {
+ if (!validate_args(state, args->posonlyargs) || !validate_args(state, args->args)) {
return 0;
}
if (args->vararg && args->vararg->annotation
- && !validate_expr(args->vararg->annotation, Load)) {
+ && !validate_expr(state, args->vararg->annotation, Load)) {
return 0;
}
- if (!validate_args(args->kwonlyargs))
+ if (!validate_args(state, args->kwonlyargs))
return 0;
if (args->kwarg && args->kwarg->annotation
- && !validate_expr(args->kwarg->annotation, Load)) {
+ && !validate_expr(state, args->kwarg->annotation, Load)) {
return 0;
}
if (asdl_seq_LEN(args->defaults) > asdl_seq_LEN(args->posonlyargs) + asdl_seq_LEN(args->args)) {
"kw_defaults on arguments");
return 0;
}
- return validate_exprs(args->defaults, Load, 0) && validate_exprs(args->kw_defaults, Load, 1);
+ return validate_exprs(state, args->defaults, Load, 0) && validate_exprs(state, args->kw_defaults, Load, 1);
}
static int
-validate_constant(PyObject *value)
+validate_constant(struct validator *state, PyObject *value)
{
assert(!PyErr_Occurred());
if (value == Py_None || value == Py_Ellipsis)
return 1;
if (PyTuple_CheckExact(value) || PyFrozenSet_CheckExact(value)) {
- ENTER_RECURSIVE();
+ ENTER_RECURSIVE(state);
PyObject *it = PyObject_GetIter(value);
if (it == NULL)
break;
}
- if (!validate_constant(item)) {
+ if (!validate_constant(state, item)) {
Py_DECREF(it);
Py_DECREF(item);
return 0;
}
Py_DECREF(it);
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(state);
return 1;
}
}
static int
-validate_expr(expr_ty exp, expr_context_ty ctx)
+validate_expr(struct validator *state, expr_ty exp, expr_context_ty ctx)
{
assert(!PyErr_Occurred());
VALIDATE_POSITIONS(exp);
int ret = -1;
- ENTER_RECURSIVE();
+ ENTER_RECURSIVE(state);
int check_ctx = 1;
expr_context_ty actual_ctx;
PyErr_SetString(PyExc_ValueError, "BoolOp with less than 2 values");
return 0;
}
- ret = validate_exprs(exp->v.BoolOp.values, Load, 0);
+ ret = validate_exprs(state, exp->v.BoolOp.values, Load, 0);
break;
case BinOp_kind:
- ret = validate_expr(exp->v.BinOp.left, Load) &&
- validate_expr(exp->v.BinOp.right, Load);
+ ret = validate_expr(state, exp->v.BinOp.left, Load) &&
+ validate_expr(state, exp->v.BinOp.right, Load);
break;
case UnaryOp_kind:
- ret = validate_expr(exp->v.UnaryOp.operand, Load);
+ ret = validate_expr(state, exp->v.UnaryOp.operand, Load);
break;
case Lambda_kind:
- ret = validate_arguments(exp->v.Lambda.args) &&
- validate_expr(exp->v.Lambda.body, Load);
+ ret = validate_arguments(state, exp->v.Lambda.args) &&
+ validate_expr(state, exp->v.Lambda.body, Load);
break;
case IfExp_kind:
- ret = validate_expr(exp->v.IfExp.test, Load) &&
- validate_expr(exp->v.IfExp.body, Load) &&
- validate_expr(exp->v.IfExp.orelse, Load);
+ ret = validate_expr(state, exp->v.IfExp.test, Load) &&
+ validate_expr(state, exp->v.IfExp.body, Load) &&
+ validate_expr(state, exp->v.IfExp.orelse, Load);
break;
case Dict_kind:
if (asdl_seq_LEN(exp->v.Dict.keys) != asdl_seq_LEN(exp->v.Dict.values)) {
}
/* null_ok=1 for keys expressions to allow dict unpacking to work in
dict literals, i.e. ``{**{a:b}}`` */
- ret = validate_exprs(exp->v.Dict.keys, Load, /*null_ok=*/ 1) &&
- validate_exprs(exp->v.Dict.values, Load, /*null_ok=*/ 0);
+ ret = validate_exprs(state, exp->v.Dict.keys, Load, /*null_ok=*/ 1) &&
+ validate_exprs(state, exp->v.Dict.values, Load, /*null_ok=*/ 0);
break;
case Set_kind:
- ret = validate_exprs(exp->v.Set.elts, Load, 0);
+ ret = validate_exprs(state, exp->v.Set.elts, Load, 0);
break;
#define COMP(NAME) \
case NAME ## _kind: \
- ret = validate_comprehension(exp->v.NAME.generators) && \
- validate_expr(exp->v.NAME.elt, Load); \
+ ret = validate_comprehension(state, exp->v.NAME.generators) && \
+ validate_expr(state, exp->v.NAME.elt, Load); \
break;
COMP(ListComp)
COMP(SetComp)
COMP(GeneratorExp)
#undef COMP
case DictComp_kind:
- ret = validate_comprehension(exp->v.DictComp.generators) &&
- validate_expr(exp->v.DictComp.key, Load) &&
- validate_expr(exp->v.DictComp.value, Load);
+ ret = validate_comprehension(state, exp->v.DictComp.generators) &&
+ validate_expr(state, exp->v.DictComp.key, Load) &&
+ validate_expr(state, exp->v.DictComp.value, Load);
break;
case Yield_kind:
- ret = !exp->v.Yield.value || validate_expr(exp->v.Yield.value, Load);
+ ret = !exp->v.Yield.value || validate_expr(state, exp->v.Yield.value, Load);
break;
case YieldFrom_kind:
- ret = validate_expr(exp->v.YieldFrom.value, Load);
+ ret = validate_expr(state, exp->v.YieldFrom.value, Load);
break;
case Await_kind:
- ret = validate_expr(exp->v.Await.value, Load);
+ ret = validate_expr(state, exp->v.Await.value, Load);
break;
case Compare_kind:
if (!asdl_seq_LEN(exp->v.Compare.comparators)) {
"of comparators and operands");
return 0;
}
- ret = validate_exprs(exp->v.Compare.comparators, Load, 0) &&
- validate_expr(exp->v.Compare.left, Load);
+ ret = validate_exprs(state, exp->v.Compare.comparators, Load, 0) &&
+ validate_expr(state, exp->v.Compare.left, Load);
break;
case Call_kind:
- ret = validate_expr(exp->v.Call.func, Load) &&
- validate_exprs(exp->v.Call.args, Load, 0) &&
- validate_keywords(exp->v.Call.keywords);
+ ret = validate_expr(state, exp->v.Call.func, Load) &&
+ validate_exprs(state, exp->v.Call.args, Load, 0) &&
+ validate_keywords(state, exp->v.Call.keywords);
break;
case Constant_kind:
- if (!validate_constant(exp->v.Constant.value)) {
+ if (!validate_constant(state, exp->v.Constant.value)) {
return 0;
}
ret = 1;
break;
case JoinedStr_kind:
- ret = validate_exprs(exp->v.JoinedStr.values, Load, 0);
+ ret = validate_exprs(state, exp->v.JoinedStr.values, Load, 0);
break;
case FormattedValue_kind:
- if (validate_expr(exp->v.FormattedValue.value, Load) == 0)
+ if (validate_expr(state, exp->v.FormattedValue.value, Load) == 0)
return 0;
if (exp->v.FormattedValue.format_spec) {
- ret = validate_expr(exp->v.FormattedValue.format_spec, Load);
+ ret = validate_expr(state, exp->v.FormattedValue.format_spec, Load);
break;
}
ret = 1;
break;
case Attribute_kind:
- ret = validate_expr(exp->v.Attribute.value, Load);
+ ret = validate_expr(state, exp->v.Attribute.value, Load);
break;
case Subscript_kind:
- ret = validate_expr(exp->v.Subscript.slice, Load) &&
- validate_expr(exp->v.Subscript.value, Load);
+ ret = validate_expr(state, exp->v.Subscript.slice, Load) &&
+ validate_expr(state, exp->v.Subscript.value, Load);
break;
case Starred_kind:
- ret = validate_expr(exp->v.Starred.value, ctx);
+ ret = validate_expr(state, exp->v.Starred.value, ctx);
break;
case Slice_kind:
- ret = (!exp->v.Slice.lower || validate_expr(exp->v.Slice.lower, Load)) &&
- (!exp->v.Slice.upper || validate_expr(exp->v.Slice.upper, Load)) &&
- (!exp->v.Slice.step || validate_expr(exp->v.Slice.step, Load));
+ ret = (!exp->v.Slice.lower || validate_expr(state, exp->v.Slice.lower, Load)) &&
+ (!exp->v.Slice.upper || validate_expr(state, exp->v.Slice.upper, Load)) &&
+ (!exp->v.Slice.step || validate_expr(state, exp->v.Slice.step, Load));
break;
case List_kind:
- ret = validate_exprs(exp->v.List.elts, ctx, 0);
+ ret = validate_exprs(state, exp->v.List.elts, ctx, 0);
break;
case Tuple_kind:
- ret = validate_exprs(exp->v.Tuple.elts, ctx, 0);
+ ret = validate_exprs(state, exp->v.Tuple.elts, ctx, 0);
break;
case NamedExpr_kind:
if (exp->v.NamedExpr.target->kind != Name_kind) {
"NamedExpr target must be a Name");
return 0;
}
- ret = validate_expr(exp->v.NamedExpr.value, Load);
+ ret = validate_expr(state, exp->v.NamedExpr.value, Load);
break;
/* This last case doesn't have any checking. */
case Name_kind:
PyErr_SetString(PyExc_SystemError, "unexpected expression");
ret = 0;
}
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(state);
return ret;
}
}
static int
-validate_pattern_match_value(expr_ty exp)
+validate_pattern_match_value(struct validator *state, expr_ty exp)
{
assert(!PyErr_Occurred());
- if (!validate_expr(exp, Load)) {
+ if (!validate_expr(state, exp, Load)) {
return 0;
}
/* Ellipsis and immutable sequences are not allowed.
For True, False and None, MatchSingleton() should
be used */
- if (!validate_expr(exp, Load)) {
+ if (!validate_expr(state, exp, Load)) {
return 0;
}
PyObject *literal = exp->v.Constant.value;
}
static int
-validate_pattern(pattern_ty p, int star_ok)
+validate_pattern(struct validator *state, pattern_ty p, int star_ok)
{
assert(!PyErr_Occurred());
VALIDATE_POSITIONS(p);
int ret = -1;
- ENTER_RECURSIVE();
+ ENTER_RECURSIVE(state);
switch (p->kind) {
case MatchValue_kind:
- ret = validate_pattern_match_value(p->v.MatchValue.value);
+ ret = validate_pattern_match_value(state, p->v.MatchValue.value);
break;
case MatchSingleton_kind:
ret = p->v.MatchSingleton.value == Py_None || PyBool_Check(p->v.MatchSingleton.value);
}
break;
case MatchSequence_kind:
- ret = validate_patterns(p->v.MatchSequence.patterns, /*star_ok=*/1);
+ ret = validate_patterns(state, p->v.MatchSequence.patterns, /*star_ok=*/1);
break;
case MatchMapping_kind:
if (asdl_seq_LEN(p->v.MatchMapping.keys) != asdl_seq_LEN(p->v.MatchMapping.patterns)) {
continue;
}
}
- if (!validate_pattern_match_value(key)) {
+ if (!validate_pattern_match_value(state, key)) {
ret = 0;
break;
}
if (ret == 0) {
break;
}
- ret = validate_patterns(p->v.MatchMapping.patterns, /*star_ok=*/0);
+ ret = validate_patterns(state, p->v.MatchMapping.patterns, /*star_ok=*/0);
break;
case MatchClass_kind:
if (asdl_seq_LEN(p->v.MatchClass.kwd_attrs) != asdl_seq_LEN(p->v.MatchClass.kwd_patterns)) {
ret = 0;
break;
}
- if (!validate_expr(p->v.MatchClass.cls, Load)) {
+ if (!validate_expr(state, p->v.MatchClass.cls, Load)) {
ret = 0;
break;
}
break;
}
- if (!validate_patterns(p->v.MatchClass.patterns, /*star_ok=*/0)) {
+ if (!validate_patterns(state, p->v.MatchClass.patterns, /*star_ok=*/0)) {
ret = 0;
break;
}
- ret = validate_patterns(p->v.MatchClass.kwd_patterns, /*star_ok=*/0);
+ ret = validate_patterns(state, p->v.MatchClass.kwd_patterns, /*star_ok=*/0);
break;
case MatchStar_kind:
if (!star_ok) {
ret = 0;
}
else {
- ret = validate_pattern(p->v.MatchAs.pattern, /*star_ok=*/0);
+ ret = validate_pattern(state, p->v.MatchAs.pattern, /*star_ok=*/0);
}
break;
case MatchOr_kind:
ret = 0;
break;
}
- ret = validate_patterns(p->v.MatchOr.patterns, /*star_ok=*/0);
+ ret = validate_patterns(state, p->v.MatchOr.patterns, /*star_ok=*/0);
break;
// No default case, so the compiler will emit a warning if new pattern
// kinds are added without being handled here
PyErr_SetString(PyExc_SystemError, "unexpected pattern");
ret = 0;
}
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(state);
return ret;
}
#define validate_nonempty_seq(seq, what, owner) _validate_nonempty_seq((asdl_seq*)seq, what, owner)
static int
-validate_assignlist(asdl_expr_seq *targets, expr_context_ty ctx)
+validate_assignlist(struct validator *state, asdl_expr_seq *targets, expr_context_ty ctx)
{
assert(!PyErr_Occurred());
return validate_nonempty_seq(targets, "targets", ctx == Del ? "Delete" : "Assign") &&
- validate_exprs(targets, ctx, 0);
+ validate_exprs(state, targets, ctx, 0);
}
static int
-validate_body(asdl_stmt_seq *body, const char *owner)
+validate_body(struct validator *state, asdl_stmt_seq *body, const char *owner)
{
assert(!PyErr_Occurred());
- return validate_nonempty_seq(body, "body", owner) && validate_stmts(body);
+ return validate_nonempty_seq(body, "body", owner) && validate_stmts(state, body);
}
static int
-validate_stmt(stmt_ty stmt)
+validate_stmt(struct validator *state, stmt_ty stmt)
{
assert(!PyErr_Occurred());
VALIDATE_POSITIONS(stmt);
int ret = -1;
- ENTER_RECURSIVE();
+ ENTER_RECURSIVE(state);
switch (stmt->kind) {
case FunctionDef_kind:
- ret = validate_body(stmt->v.FunctionDef.body, "FunctionDef") &&
- validate_type_params(stmt->v.FunctionDef.type_params) &&
- validate_arguments(stmt->v.FunctionDef.args) &&
- validate_exprs(stmt->v.FunctionDef.decorator_list, Load, 0) &&
+ ret = validate_body(state, stmt->v.FunctionDef.body, "FunctionDef") &&
+ validate_type_params(state, stmt->v.FunctionDef.type_params) &&
+ validate_arguments(state, stmt->v.FunctionDef.args) &&
+ validate_exprs(state, stmt->v.FunctionDef.decorator_list, Load, 0) &&
(!stmt->v.FunctionDef.returns ||
- validate_expr(stmt->v.FunctionDef.returns, Load));
+ validate_expr(state, stmt->v.FunctionDef.returns, Load));
break;
case ClassDef_kind:
- ret = validate_body(stmt->v.ClassDef.body, "ClassDef") &&
- validate_type_params(stmt->v.ClassDef.type_params) &&
- validate_exprs(stmt->v.ClassDef.bases, Load, 0) &&
- validate_keywords(stmt->v.ClassDef.keywords) &&
- validate_exprs(stmt->v.ClassDef.decorator_list, Load, 0);
+ ret = validate_body(state, stmt->v.ClassDef.body, "ClassDef") &&
+ validate_type_params(state, stmt->v.ClassDef.type_params) &&
+ validate_exprs(state, stmt->v.ClassDef.bases, Load, 0) &&
+ validate_keywords(state, stmt->v.ClassDef.keywords) &&
+ validate_exprs(state, stmt->v.ClassDef.decorator_list, Load, 0);
break;
case Return_kind:
- ret = !stmt->v.Return.value || validate_expr(stmt->v.Return.value, Load);
+ ret = !stmt->v.Return.value || validate_expr(state, stmt->v.Return.value, Load);
break;
case Delete_kind:
- ret = validate_assignlist(stmt->v.Delete.targets, Del);
+ ret = validate_assignlist(state, stmt->v.Delete.targets, Del);
break;
case Assign_kind:
- ret = validate_assignlist(stmt->v.Assign.targets, Store) &&
- validate_expr(stmt->v.Assign.value, Load);
+ ret = validate_assignlist(state, stmt->v.Assign.targets, Store) &&
+ validate_expr(state, stmt->v.Assign.value, Load);
break;
case AugAssign_kind:
- ret = validate_expr(stmt->v.AugAssign.target, Store) &&
- validate_expr(stmt->v.AugAssign.value, Load);
+ ret = validate_expr(state, stmt->v.AugAssign.target, Store) &&
+ validate_expr(state, stmt->v.AugAssign.value, Load);
break;
case AnnAssign_kind:
if (stmt->v.AnnAssign.target->kind != Name_kind &&
"AnnAssign with simple non-Name target");
return 0;
}
- ret = validate_expr(stmt->v.AnnAssign.target, Store) &&
+ ret = validate_expr(state, stmt->v.AnnAssign.target, Store) &&
(!stmt->v.AnnAssign.value ||
- validate_expr(stmt->v.AnnAssign.value, Load)) &&
- validate_expr(stmt->v.AnnAssign.annotation, Load);
+ validate_expr(state, stmt->v.AnnAssign.value, Load)) &&
+ validate_expr(state, stmt->v.AnnAssign.annotation, Load);
break;
case TypeAlias_kind:
if (stmt->v.TypeAlias.name->kind != Name_kind) {
"TypeAlias with non-Name name");
return 0;
}
- ret = validate_expr(stmt->v.TypeAlias.name, Store) &&
- validate_type_params(stmt->v.TypeAlias.type_params) &&
- validate_expr(stmt->v.TypeAlias.value, Load);
+ ret = validate_expr(state, stmt->v.TypeAlias.name, Store) &&
+ validate_type_params(state, stmt->v.TypeAlias.type_params) &&
+ validate_expr(state, stmt->v.TypeAlias.value, Load);
break;
case For_kind:
- ret = validate_expr(stmt->v.For.target, Store) &&
- validate_expr(stmt->v.For.iter, Load) &&
- validate_body(stmt->v.For.body, "For") &&
- validate_stmts(stmt->v.For.orelse);
+ ret = validate_expr(state, stmt->v.For.target, Store) &&
+ validate_expr(state, stmt->v.For.iter, Load) &&
+ validate_body(state, stmt->v.For.body, "For") &&
+ validate_stmts(state, stmt->v.For.orelse);
break;
case AsyncFor_kind:
- ret = validate_expr(stmt->v.AsyncFor.target, Store) &&
- validate_expr(stmt->v.AsyncFor.iter, Load) &&
- validate_body(stmt->v.AsyncFor.body, "AsyncFor") &&
- validate_stmts(stmt->v.AsyncFor.orelse);
+ ret = validate_expr(state, stmt->v.AsyncFor.target, Store) &&
+ validate_expr(state, stmt->v.AsyncFor.iter, Load) &&
+ validate_body(state, stmt->v.AsyncFor.body, "AsyncFor") &&
+ validate_stmts(state, stmt->v.AsyncFor.orelse);
break;
case While_kind:
- ret = validate_expr(stmt->v.While.test, Load) &&
- validate_body(stmt->v.While.body, "While") &&
- validate_stmts(stmt->v.While.orelse);
+ ret = validate_expr(state, stmt->v.While.test, Load) &&
+ validate_body(state, stmt->v.While.body, "While") &&
+ validate_stmts(state, stmt->v.While.orelse);
break;
case If_kind:
- ret = validate_expr(stmt->v.If.test, Load) &&
- validate_body(stmt->v.If.body, "If") &&
- validate_stmts(stmt->v.If.orelse);
+ ret = validate_expr(state, stmt->v.If.test, Load) &&
+ validate_body(state, stmt->v.If.body, "If") &&
+ validate_stmts(state, stmt->v.If.orelse);
break;
case With_kind:
if (!validate_nonempty_seq(stmt->v.With.items, "items", "With"))
return 0;
for (Py_ssize_t i = 0; i < asdl_seq_LEN(stmt->v.With.items); i++) {
withitem_ty item = asdl_seq_GET(stmt->v.With.items, i);
- if (!validate_expr(item->context_expr, Load) ||
- (item->optional_vars && !validate_expr(item->optional_vars, Store)))
+ if (!validate_expr(state, item->context_expr, Load) ||
+ (item->optional_vars && !validate_expr(state, item->optional_vars, Store)))
return 0;
}
- ret = validate_body(stmt->v.With.body, "With");
+ ret = validate_body(state, stmt->v.With.body, "With");
break;
case AsyncWith_kind:
if (!validate_nonempty_seq(stmt->v.AsyncWith.items, "items", "AsyncWith"))
return 0;
for (Py_ssize_t i = 0; i < asdl_seq_LEN(stmt->v.AsyncWith.items); i++) {
withitem_ty item = asdl_seq_GET(stmt->v.AsyncWith.items, i);
- if (!validate_expr(item->context_expr, Load) ||
- (item->optional_vars && !validate_expr(item->optional_vars, Store)))
+ if (!validate_expr(state, item->context_expr, Load) ||
+ (item->optional_vars && !validate_expr(state, item->optional_vars, Store)))
return 0;
}
- ret = validate_body(stmt->v.AsyncWith.body, "AsyncWith");
+ ret = validate_body(state, stmt->v.AsyncWith.body, "AsyncWith");
break;
case Match_kind:
- if (!validate_expr(stmt->v.Match.subject, Load)
+ if (!validate_expr(state, stmt->v.Match.subject, Load)
|| !validate_nonempty_seq(stmt->v.Match.cases, "cases", "Match")) {
return 0;
}
for (Py_ssize_t i = 0; i < asdl_seq_LEN(stmt->v.Match.cases); i++) {
match_case_ty m = asdl_seq_GET(stmt->v.Match.cases, i);
- if (!validate_pattern(m->pattern, /*star_ok=*/0)
- || (m->guard && !validate_expr(m->guard, Load))
- || !validate_body(m->body, "match_case")) {
+ if (!validate_pattern(state, m->pattern, /*star_ok=*/0)
+ || (m->guard && !validate_expr(state, m->guard, Load))
+ || !validate_body(state, m->body, "match_case")) {
return 0;
}
}
break;
case Raise_kind:
if (stmt->v.Raise.exc) {
- ret = validate_expr(stmt->v.Raise.exc, Load) &&
- (!stmt->v.Raise.cause || validate_expr(stmt->v.Raise.cause, Load));
+ ret = validate_expr(state, stmt->v.Raise.exc, Load) &&
+ (!stmt->v.Raise.cause || validate_expr(state, stmt->v.Raise.cause, Load));
break;
}
if (stmt->v.Raise.cause) {
ret = 1;
break;
case Try_kind:
- if (!validate_body(stmt->v.Try.body, "Try"))
+ if (!validate_body(state, stmt->v.Try.body, "Try"))
return 0;
if (!asdl_seq_LEN(stmt->v.Try.handlers) &&
!asdl_seq_LEN(stmt->v.Try.finalbody)) {
excepthandler_ty handler = asdl_seq_GET(stmt->v.Try.handlers, i);
VALIDATE_POSITIONS(handler);
if ((handler->v.ExceptHandler.type &&
- !validate_expr(handler->v.ExceptHandler.type, Load)) ||
- !validate_body(handler->v.ExceptHandler.body, "ExceptHandler"))
+ !validate_expr(state, handler->v.ExceptHandler.type, Load)) ||
+ !validate_body(state, handler->v.ExceptHandler.body, "ExceptHandler"))
return 0;
}
ret = (!asdl_seq_LEN(stmt->v.Try.finalbody) ||
- validate_stmts(stmt->v.Try.finalbody)) &&
+ validate_stmts(state, stmt->v.Try.finalbody)) &&
(!asdl_seq_LEN(stmt->v.Try.orelse) ||
- validate_stmts(stmt->v.Try.orelse));
+ validate_stmts(state, stmt->v.Try.orelse));
break;
case TryStar_kind:
- if (!validate_body(stmt->v.TryStar.body, "TryStar"))
+ if (!validate_body(state, stmt->v.TryStar.body, "TryStar"))
return 0;
if (!asdl_seq_LEN(stmt->v.TryStar.handlers) &&
!asdl_seq_LEN(stmt->v.TryStar.finalbody)) {
for (Py_ssize_t i = 0; i < asdl_seq_LEN(stmt->v.TryStar.handlers); i++) {
excepthandler_ty handler = asdl_seq_GET(stmt->v.TryStar.handlers, i);
if ((handler->v.ExceptHandler.type &&
- !validate_expr(handler->v.ExceptHandler.type, Load)) ||
- !validate_body(handler->v.ExceptHandler.body, "ExceptHandler"))
+ !validate_expr(state, handler->v.ExceptHandler.type, Load)) ||
+ !validate_body(state, handler->v.ExceptHandler.body, "ExceptHandler"))
return 0;
}
ret = (!asdl_seq_LEN(stmt->v.TryStar.finalbody) ||
- validate_stmts(stmt->v.TryStar.finalbody)) &&
+ validate_stmts(state, stmt->v.TryStar.finalbody)) &&
(!asdl_seq_LEN(stmt->v.TryStar.orelse) ||
- validate_stmts(stmt->v.TryStar.orelse));
+ validate_stmts(state, stmt->v.TryStar.orelse));
break;
case Assert_kind:
- ret = validate_expr(stmt->v.Assert.test, Load) &&
- (!stmt->v.Assert.msg || validate_expr(stmt->v.Assert.msg, Load));
+ ret = validate_expr(state, stmt->v.Assert.test, Load) &&
+ (!stmt->v.Assert.msg || validate_expr(state, stmt->v.Assert.msg, Load));
break;
case Import_kind:
ret = validate_nonempty_seq(stmt->v.Import.names, "names", "Import");
ret = validate_nonempty_seq(stmt->v.Nonlocal.names, "names", "Nonlocal");
break;
case Expr_kind:
- ret = validate_expr(stmt->v.Expr.value, Load);
+ ret = validate_expr(state, stmt->v.Expr.value, Load);
break;
case AsyncFunctionDef_kind:
- ret = validate_body(stmt->v.AsyncFunctionDef.body, "AsyncFunctionDef") &&
- validate_type_params(stmt->v.AsyncFunctionDef.type_params) &&
- validate_arguments(stmt->v.AsyncFunctionDef.args) &&
- validate_exprs(stmt->v.AsyncFunctionDef.decorator_list, Load, 0) &&
+ ret = validate_body(state, stmt->v.AsyncFunctionDef.body, "AsyncFunctionDef") &&
+ validate_type_params(state, stmt->v.AsyncFunctionDef.type_params) &&
+ validate_arguments(state, stmt->v.AsyncFunctionDef.args) &&
+ validate_exprs(state, stmt->v.AsyncFunctionDef.decorator_list, Load, 0) &&
(!stmt->v.AsyncFunctionDef.returns ||
- validate_expr(stmt->v.AsyncFunctionDef.returns, Load));
+ validate_expr(state, stmt->v.AsyncFunctionDef.returns, Load));
break;
case Pass_kind:
case Break_kind:
PyErr_SetString(PyExc_SystemError, "unexpected statement");
ret = 0;
}
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(state);
return ret;
}
static int
-validate_stmts(asdl_stmt_seq *seq)
+validate_stmts(struct validator *state, asdl_stmt_seq *seq)
{
assert(!PyErr_Occurred());
for (Py_ssize_t i = 0; i < asdl_seq_LEN(seq); i++) {
stmt_ty stmt = asdl_seq_GET(seq, i);
if (stmt) {
- if (!validate_stmt(stmt))
+ if (!validate_stmt(state, stmt))
return 0;
}
else {
}
static int
-validate_exprs(asdl_expr_seq *exprs, expr_context_ty ctx, int null_ok)
+validate_exprs(struct validator *state, asdl_expr_seq *exprs, expr_context_ty ctx, int null_ok)
{
assert(!PyErr_Occurred());
for (Py_ssize_t i = 0; i < asdl_seq_LEN(exprs); i++) {
expr_ty expr = asdl_seq_GET(exprs, i);
if (expr) {
- if (!validate_expr(expr, ctx))
+ if (!validate_expr(state, expr, ctx))
return 0;
}
else if (!null_ok) {
}
static int
-validate_patterns(asdl_pattern_seq *patterns, int star_ok)
+validate_patterns(struct validator *state, asdl_pattern_seq *patterns, int star_ok)
{
assert(!PyErr_Occurred());
for (Py_ssize_t i = 0; i < asdl_seq_LEN(patterns); i++) {
pattern_ty pattern = asdl_seq_GET(patterns, i);
- if (!validate_pattern(pattern, star_ok)) {
+ if (!validate_pattern(state, pattern, star_ok)) {
return 0;
}
}
}
static int
-validate_typeparam(type_param_ty tp)
+validate_typeparam(struct validator *state, type_param_ty tp)
{
VALIDATE_POSITIONS(tp);
int ret = -1;
case TypeVar_kind:
ret = validate_name(tp->v.TypeVar.name) &&
(!tp->v.TypeVar.bound ||
- validate_expr(tp->v.TypeVar.bound, Load)) &&
+ validate_expr(state, tp->v.TypeVar.bound, Load)) &&
(!tp->v.TypeVar.default_value ||
- validate_expr(tp->v.TypeVar.default_value, Load));
+ validate_expr(state, tp->v.TypeVar.default_value, Load));
break;
case ParamSpec_kind:
ret = validate_name(tp->v.ParamSpec.name) &&
(!tp->v.ParamSpec.default_value ||
- validate_expr(tp->v.ParamSpec.default_value, Load));
+ validate_expr(state, tp->v.ParamSpec.default_value, Load));
break;
case TypeVarTuple_kind:
ret = validate_name(tp->v.TypeVarTuple.name) &&
(!tp->v.TypeVarTuple.default_value ||
- validate_expr(tp->v.TypeVarTuple.default_value, Load));
+ validate_expr(state, tp->v.TypeVarTuple.default_value, Load));
break;
}
return ret;
}
static int
-validate_type_params(asdl_type_param_seq *tps)
+validate_type_params(struct validator *state, asdl_type_param_seq *tps)
{
Py_ssize_t i;
for (i = 0; i < asdl_seq_LEN(tps); i++) {
type_param_ty tp = asdl_seq_GET(tps, i);
if (tp) {
- if (!validate_typeparam(tp))
+ if (!validate_typeparam(state, tp))
return 0;
}
}
{
assert(!PyErr_Occurred());
int res = -1;
+ struct validator state;
+ PyThreadState *tstate;
+ int starting_recursion_depth;
+
+ /* Setup recursion depth check counters */
+ tstate = _PyThreadState_GET();
+ if (!tstate) {
+ return 0;
+ }
+ /* Be careful here to prevent overflow. */
+ int recursion_depth = Py_C_RECURSION_LIMIT - tstate->c_recursion_remaining;
+ starting_recursion_depth = recursion_depth;
+ state.recursion_depth = starting_recursion_depth;
+ state.recursion_limit = Py_C_RECURSION_LIMIT;
switch (mod->kind) {
case Module_kind:
- res = validate_stmts(mod->v.Module.body);
+ res = validate_stmts(&state, mod->v.Module.body);
break;
case Interactive_kind:
- res = validate_stmts(mod->v.Interactive.body);
+ res = validate_stmts(&state, mod->v.Interactive.body);
break;
case Expression_kind:
- res = validate_expr(mod->v.Expression.body, Load);
+ res = validate_expr(&state, mod->v.Expression.body, Load);
break;
case FunctionType_kind:
- res = validate_exprs(mod->v.FunctionType.argtypes, Load, /*null_ok=*/0) &&
- validate_expr(mod->v.FunctionType.returns, Load);
+ res = validate_exprs(&state, mod->v.FunctionType.argtypes, Load, /*null_ok=*/0) &&
+ validate_expr(&state, mod->v.FunctionType.returns, Load);
break;
// No default case so compiler emits warning for unhandled cases
}
PyErr_SetString(PyExc_SystemError, "impossible module node");
return 0;
}
+
+ /* Check that the recursion depth counting balanced correctly */
+ if (res && state.recursion_depth != starting_recursion_depth) {
+ PyErr_Format(PyExc_SystemError,
+ "AST validator recursion depth mismatch (before=%d, after=%d)",
+ starting_recursion_depth, state.recursion_depth);
+ return 0;
+ }
return res;
}
typedef struct {
int optimize;
int ff_features;
+
+ int recursion_depth; /* current recursion depth */
+ int recursion_limit; /* recursion limit */
} _PyASTOptimizeState;
-#define ENTER_RECURSIVE() \
-if (Py_EnterRecursiveCall(" during compilation")) { \
- return 0; \
-}
+#define ENTER_RECURSIVE(ST) \
+ do { \
+ if (++(ST)->recursion_depth > (ST)->recursion_limit) { \
+ PyErr_SetString(PyExc_RecursionError, \
+ "maximum recursion depth exceeded during compilation"); \
+ return 0; \
+ } \
+ } while(0)
-#define LEAVE_RECURSIVE() Py_LeaveRecursiveCall();
+#define LEAVE_RECURSIVE(ST) \
+ do { \
+ --(ST)->recursion_depth; \
+ } while(0)
static int
make_const(expr_ty node, PyObject *val, PyArena *arena)
static int
astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
- ENTER_RECURSIVE();
+ ENTER_RECURSIVE(state);
switch (node_->kind) {
case BoolOp_kind:
CALL_SEQ(astfold_expr, expr, node_->v.BoolOp.values);
case Name_kind:
if (node_->v.Name.ctx == Load &&
_PyUnicode_EqualToASCIIString(node_->v.Name.id, "__debug__")) {
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(state);
return make_const(node_, PyBool_FromLong(!state->optimize), ctx_);
}
break;
// No default case, so the compiler will emit a warning if new expression
// kinds are added without being handled here
}
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(state);;
return 1;
}
static int
astfold_stmt(stmt_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{
- ENTER_RECURSIVE();
+ ENTER_RECURSIVE(state);
switch (node_->kind) {
case FunctionDef_kind:
CALL_SEQ(astfold_type_param, type_param, node_->v.FunctionDef.type_params);
// No default case, so the compiler will emit a warning if new statement
// kinds are added without being handled here
}
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(state);
return 1;
}
// Currently, this is really only used to form complex/negative numeric
// constants in MatchValue and MatchMapping nodes
// We still recurse into all subexpressions and subpatterns anyway
- ENTER_RECURSIVE();
+ ENTER_RECURSIVE(state);
switch (node_->kind) {
case MatchValue_kind:
CALL(fold_const_match_patterns, expr_ty, node_->v.MatchValue.value);
// No default case, so the compiler will emit a warning if new pattern
// kinds are added without being handled here
}
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(state);
return 1;
}
int
_PyAST_Optimize(mod_ty mod, PyArena *arena, int optimize, int ff_features)
{
+ PyThreadState *tstate;
+ int starting_recursion_depth;
+
_PyASTOptimizeState state;
state.optimize = optimize;
state.ff_features = ff_features;
+ /* Setup recursion depth check counters */
+ tstate = _PyThreadState_GET();
+ if (!tstate) {
+ return 0;
+ }
+ /* Be careful here to prevent overflow. */
+ int recursion_depth = Py_C_RECURSION_LIMIT - tstate->c_recursion_remaining;
+ starting_recursion_depth = recursion_depth;
+ state.recursion_depth = starting_recursion_depth;
+ state.recursion_limit = Py_C_RECURSION_LIMIT;
+
int ret = astfold_mod(mod, arena, &state);
assert(ret || PyErr_Occurred());
+ /* Check that the recursion depth counting balanced correctly */
+ if (ret && state.recursion_depth != starting_recursion_depth) {
+ PyErr_Format(PyExc_SystemError,
+ "AST optimizer recursion depth mismatch (before=%d, after=%d)",
+ starting_recursion_depth, state.recursion_depth);
+ return 0;
+ }
+
return ret;
}
/* Restore previous frame and return. */
tstate->current_frame = frame->previous;
assert(!_PyErr_Occurred(tstate));
+ tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS;
PyObject *result = PyStackRef_AsPyObjectSteal(retval);
SYNC_SP(); /* Not strictly necessary, but prevents warnings */
return result;
EXIT_IF(!PyCFunction_CheckExact(callable_o));
EXIT_IF(PyCFunction_GET_FLAGS(callable_o) != METH_O);
// CPython promises to check all non-vectorcall function calls.
- EXIT_IF(_Py_ReachedRecursionLimit(tstate));
+ EXIT_IF(tstate->c_recursion_remaining <= 0);
STAT_INC(CALL, hit);
PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);
_PyStackRef arg = args[0];
+ _Py_EnterRecursiveCallTstateUnchecked(tstate);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg));
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyMethodDef *meth = method->d_method;
EXIT_IF(meth->ml_flags != METH_O);
// CPython promises to check all non-vectorcall function calls.
- EXIT_IF(_Py_ReachedRecursionLimit(tstate));
+ EXIT_IF(tstate->c_recursion_remaining <= 0);
_PyStackRef arg_stackref = arguments[1];
_PyStackRef self_stackref = arguments[0];
EXIT_IF(!Py_IS_TYPE(PyStackRef_AsPyObjectBorrow(self_stackref),
method->d_common.d_type));
STAT_INC(CALL, hit);
PyCFunction cfunc = meth->ml_meth;
+ _Py_EnterRecursiveCallTstateUnchecked(tstate);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc,
PyStackRef_AsPyObjectBorrow(self_stackref),
PyStackRef_AsPyObjectBorrow(arg_stackref));
EXIT_IF(!Py_IS_TYPE(self, method->d_common.d_type));
EXIT_IF(meth->ml_flags != METH_NOARGS);
// CPython promises to check all non-vectorcall function calls.
- EXIT_IF(_Py_ReachedRecursionLimit(tstate));
+ EXIT_IF(tstate->c_recursion_remaining <= 0);
STAT_INC(CALL, hit);
PyCFunction cfunc = meth->ml_meth;
+ _Py_EnterRecursiveCallTstateUnchecked(tstate);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (frame->owner == FRAME_OWNED_BY_INTERPRETER) {
/* Restore previous frame and exit */
tstate->current_frame = frame->previous;
+ tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS;
return NULL;
}
next_instr = frame->instr_ptr;
_PyEval_StartTheWorld(interp);
}
-int
-_Py_ReachedRecursionLimitWithMargin(PyThreadState *tstate, int margin_count)
-{
- char here;
- uintptr_t here_addr = (uintptr_t)&here;
- _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
- if (here_addr > _tstate->c_stack_soft_limit + margin_count * PYOS_STACK_MARGIN_BYTES) {
- return 0;
- }
- if (_tstate->c_stack_hard_limit == 0) {
- _Py_InitializeRecursionLimits(tstate);
- }
- return here_addr <= _tstate->c_stack_soft_limit + margin_count * PYOS_STACK_MARGIN_BYTES;
-}
-
-void
-_Py_EnterRecursiveCallUnchecked(PyThreadState *tstate)
-{
- char here;
- uintptr_t here_addr = (uintptr_t)&here;
- _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
- if (here_addr < _tstate->c_stack_hard_limit) {
- Py_FatalError("Unchecked stack overflow.");
- }
-}
-
-#if defined(__s390x__)
-# define Py_C_STACK_SIZE 320000
-#elif defined(_WIN32)
- // Don't define Py_C_STACK_SIZE, ask the O/S
-#elif defined(__ANDROID__)
-# define Py_C_STACK_SIZE 1200000
-#elif defined(__sparc__)
-# define Py_C_STACK_SIZE 1600000
-#elif defined(__wasi__)
- /* Web assembly has two stacks, so this isn't really the stack depth */
-# define Py_C_STACK_SIZE 100000
-#elif defined(__hppa__) || defined(__powerpc64__)
-# define Py_C_STACK_SIZE 2000000
-#else
-# define Py_C_STACK_SIZE 5000000
-#endif
-
-void
-_Py_InitializeRecursionLimits(PyThreadState *tstate)
-{
- _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
-#ifdef WIN32
- ULONG_PTR low, high;
- GetCurrentThreadStackLimits(&low, &high);
- _tstate->c_stack_top = (uintptr_t)high;
- ULONG guarantee = 0;
- SetThreadStackGuarantee(&guarantee);
- _tstate->c_stack_hard_limit = ((uintptr_t)low) + guarantee + PYOS_STACK_MARGIN_BYTES;
- _tstate->c_stack_soft_limit = _tstate->c_stack_hard_limit + PYOS_STACK_MARGIN_BYTES;
-#else
- char here;
- uintptr_t here_addr = (uintptr_t)&here;
- _tstate->c_stack_top = _Py_SIZE_ROUND_UP(here_addr, 4096);
- _tstate->c_stack_soft_limit = _tstate->c_stack_top - Py_C_STACK_SIZE;
- _tstate->c_stack_hard_limit = _tstate->c_stack_top - (Py_C_STACK_SIZE + PYOS_STACK_MARGIN_BYTES);
-#endif
-}
-
/* The function _Py_EnterRecursiveCallTstate() only calls _Py_CheckRecursiveCall()
if the recursion_depth reaches recursion_limit. */
int
_Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)
{
- _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate;
- char here;
- uintptr_t here_addr = (uintptr_t)&here;
- assert(_tstate->c_stack_soft_limit != 0);
- if (_tstate->c_stack_hard_limit == 0) {
- _Py_InitializeRecursionLimits(tstate);
- }
- if (here_addr >= _tstate->c_stack_soft_limit) {
- return 0;
- }
- assert(_tstate->c_stack_hard_limit != 0);
- if (here_addr < _tstate->c_stack_hard_limit) {
- /* Overflowing while handling an overflow. Give up. */
- int kbytes_used = (int)(_tstate->c_stack_top - here_addr)/1024;
- char buffer[80];
- snprintf(buffer, 80, "Unrecoverable stack overflow (used %d kB)%s", kbytes_used, where);
- Py_FatalError(buffer);
+#ifdef USE_STACKCHECK
+ if (PyOS_CheckStack()) {
+ ++tstate->c_recursion_remaining;
+ _PyErr_SetString(tstate, PyExc_MemoryError, "Stack overflow");
+ return -1;
}
+#endif
if (tstate->recursion_headroom) {
- return 0;
+ if (tstate->c_recursion_remaining < -50) {
+ /* Overflowing while handling an overflow. Give up. */
+ Py_FatalError("Cannot recover from stack overflow.");
+ }
}
else {
- int kbytes_used = (int)(_tstate->c_stack_top - here_addr)/1024;
- tstate->recursion_headroom++;
- _PyErr_Format(tstate, PyExc_RecursionError,
- "Stack overflow (used %d kB)%s",
- kbytes_used,
- where);
- tstate->recursion_headroom--;
- return -1;
+ if (tstate->c_recursion_remaining <= 0) {
+ tstate->recursion_headroom++;
+ _PyErr_Format(tstate, PyExc_RecursionError,
+ "maximum recursion depth exceeded%s",
+ where);
+ tstate->recursion_headroom--;
+ ++tstate->c_recursion_remaining;
+ return -1;
+ }
}
+ return 0;
}
}
+/* _PyEval_EvalFrameDefault() is a *big* function,
+ * so consume 3 units of C stack */
+#define PY_EVAL_C_STACK_UNITS 2
+
+
/* _PyEval_EvalFrameDefault is too large to optimize for speed with PGO on MSVC.
*/
#if (defined(_MSC_VER) && \
frame->previous = &entry_frame;
tstate->current_frame = frame;
+ tstate->c_recursion_remaining -= (PY_EVAL_C_STACK_UNITS - 1);
+
/* support for generator.throw() */
if (throwflag) {
if (_Py_EnterRecursivePy(tstate)) {
assert(frame->owner == FRAME_OWNED_BY_INTERPRETER);
/* Restore previous frame and exit */
tstate->current_frame = frame->previous;
+ tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS;
return NULL;
}
// _PyThreadState_PopFrame, since f_code is already cleared at that point:
assert((PyObject **)frame + _PyFrame_GetCode(frame)->co_framesize ==
tstate->datastack_top);
+ tstate->c_recursion_remaining--;
assert(frame->frame_obj == NULL || frame->frame_obj->f_frame == frame);
_PyFrame_ClearExceptCode(frame);
PyStackRef_CLEAR(frame->f_executable);
+ tstate->c_recursion_remaining++;
_PyThreadState_PopFrame(tstate, frame);
}
assert(tstate->exc_info == &gen->gi_exc_state);
tstate->exc_info = gen->gi_exc_state.previous_item;
gen->gi_exc_state.previous_item = NULL;
+ tstate->c_recursion_remaining--;
assert(frame->frame_obj == NULL || frame->frame_obj->f_frame == frame);
_PyFrame_ClearExceptCode(frame);
_PyErr_ClearExcState(&gen->gi_exc_state);
+ tstate->c_recursion_remaining++;
frame->previous = NULL;
}
JUMP_TO_JUMP_TARGET();
}
// CPython promises to check all non-vectorcall function calls.
- if (_Py_ReachedRecursionLimit(tstate)) {
+ if (tstate->c_recursion_remaining <= 0) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(CALL, hit);
PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);
_PyStackRef arg = args[0];
+ _Py_EnterRecursiveCallTstateUnchecked(tstate);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg));
stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_JUMP_TARGET();
}
// CPython promises to check all non-vectorcall function calls.
- if (_Py_ReachedRecursionLimit(tstate)) {
+ if (tstate->c_recursion_remaining <= 0) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
}
STAT_INC(CALL, hit);
PyCFunction cfunc = meth->ml_meth;
+ _Py_EnterRecursiveCallTstateUnchecked(tstate);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc,
PyStackRef_AsPyObjectBorrow(self_stackref),
JUMP_TO_JUMP_TARGET();
}
// CPython promises to check all non-vectorcall function calls.
- if (_Py_ReachedRecursionLimit(tstate)) {
+ if (tstate->c_recursion_remaining <= 0) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(CALL, hit);
PyCFunction cfunc = meth->ml_meth;
+ _Py_EnterRecursiveCallTstateUnchecked(tstate);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_PREDICTED(CALL);
}
// CPython promises to check all non-vectorcall function calls.
- if (_Py_ReachedRecursionLimit(tstate)) {
+ if (tstate->c_recursion_remaining <= 0) {
UPDATE_MISS_STATS(CALL);
assert(_PyOpcode_Deopt[opcode] == (CALL));
JUMP_TO_PREDICTED(CALL);
STAT_INC(CALL, hit);
PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);
_PyStackRef arg = args[0];
+ _Py_EnterRecursiveCallTstateUnchecked(tstate);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg));
stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_PREDICTED(CALL);
}
// CPython promises to check all non-vectorcall function calls.
- if (_Py_ReachedRecursionLimit(tstate)) {
+ if (tstate->c_recursion_remaining <= 0) {
UPDATE_MISS_STATS(CALL);
assert(_PyOpcode_Deopt[opcode] == (CALL));
JUMP_TO_PREDICTED(CALL);
}
STAT_INC(CALL, hit);
PyCFunction cfunc = meth->ml_meth;
+ _Py_EnterRecursiveCallTstateUnchecked(tstate);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_PREDICTED(CALL);
}
// CPython promises to check all non-vectorcall function calls.
- if (_Py_ReachedRecursionLimit(tstate)) {
+ if (tstate->c_recursion_remaining <= 0) {
UPDATE_MISS_STATS(CALL);
assert(_PyOpcode_Deopt[opcode] == (CALL));
JUMP_TO_PREDICTED(CALL);
}
STAT_INC(CALL, hit);
PyCFunction cfunc = meth->ml_meth;
+ _Py_EnterRecursiveCallTstateUnchecked(tstate);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc,
PyStackRef_AsPyObjectBorrow(self_stackref),
/* Restore previous frame and return. */
tstate->current_frame = frame->previous;
assert(!_PyErr_Occurred(tstate));
+ tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS;
PyObject *result = PyStackRef_AsPyObjectSteal(retval);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
if (frame->owner == FRAME_OWNED_BY_INTERPRETER) {
/* Restore previous frame and exit */
tstate->current_frame = frame->previous;
+ tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS;
return NULL;
}
next_instr = frame->instr_ptr;
// thread_id and native_thread_id are set in bind_tstate().
- tstate->py_recursion_limit = interp->ceval.recursion_limit;
- tstate->py_recursion_remaining = interp->ceval.recursion_limit;
- tstate->c_recursion_remaining = 2;
+ tstate->py_recursion_limit = interp->ceval.recursion_limit,
+ tstate->py_recursion_remaining = interp->ceval.recursion_limit,
+ tstate->c_recursion_remaining = Py_C_RECURSION_LIMIT;
+
tstate->exc_info = &tstate->exc_state;
// PyGILState_Release must not try to delete this thread state.
tstate->previous_executor = NULL;
tstate->dict_global_version = 0;
- _tstate->c_stack_soft_limit = UINTPTR_MAX;
- _tstate->c_stack_top = 0;
- _tstate->c_stack_hard_limit = 0;
-
_tstate->asyncio_running_loop = NULL;
_tstate->asyncio_running_task = NULL;
}
#if defined(USE_STACKCHECK)
+#if defined(WIN32) && defined(_MSC_VER)
-/* Stack checking */
+/* Stack checking for Microsoft C */
+
+#include <malloc.h>
+#include <excpt.h>
/*
* Return non-zero when we run out of memory on the stack; zero otherwise.
int
PyOS_CheckStack(void)
{
- PyThreadState *tstate = _PyThreadState_GET();
- return _Py_ReachedRecursionLimit(tstate);
+ __try {
+ /* alloca throws a stack overflow exception if there's
+ not enough space left on the stack */
+ alloca(PYOS_STACK_MARGIN * sizeof(void*));
+ return 0;
+ } __except (GetExceptionCode() == STATUS_STACK_OVERFLOW ?
+ EXCEPTION_EXECUTE_HANDLER :
+ EXCEPTION_CONTINUE_SEARCH) {
+ int errcode = _resetstkoflw();
+ if (errcode == 0)
+ {
+ Py_FatalError("Could not reset the stack!");
+ }
+ }
+ return 1;
}
+#endif /* WIN32 && _MSC_VER */
+
+/* Alternate implementations can be added here... */
+
#endif /* USE_STACKCHECK */
/* Deprecated C API functions still provided for binary compatibility */
asdl_stmt_seq *seq;
Py_ssize_t i;
PyThreadState *tstate;
+ int starting_recursion_depth;
if (st == NULL)
return NULL;
_PySymtable_Free(st);
return NULL;
}
+ /* Be careful here to prevent overflow. */
+ int recursion_depth = Py_C_RECURSION_LIMIT - tstate->c_recursion_remaining;
+ starting_recursion_depth = recursion_depth;
+ st->recursion_depth = starting_recursion_depth;
+ st->recursion_limit = Py_C_RECURSION_LIMIT;
/* Make the initial symbol information gathering pass */
_PySymtable_Free(st);
return NULL;
}
+ /* Check that the recursion depth counting balanced correctly */
+ if (st->recursion_depth != starting_recursion_depth) {
+ PyErr_Format(PyExc_SystemError,
+ "symtable analysis recursion depth mismatch (before=%d, after=%d)",
+ starting_recursion_depth, st->recursion_depth);
+ _PySymtable_Free(st);
+ return NULL;
+ }
/* Make the second symbol analysis pass */
if (symtable_analyze(st)) {
#if _PY_DUMP_SYMTABLE
} \
} while(0)
-#define ENTER_RECURSIVE() \
-if (Py_EnterRecursiveCall(" during compilation")) { \
- return 0; \
-}
+#define ENTER_RECURSIVE(ST) \
+ do { \
+ if (++(ST)->recursion_depth > (ST)->recursion_limit) { \
+ PyErr_SetString(PyExc_RecursionError, \
+ "maximum recursion depth exceeded during compilation"); \
+ return 0; \
+ } \
+ } while(0)
-#define LEAVE_RECURSIVE() Py_LeaveRecursiveCall();
+#define LEAVE_RECURSIVE(ST) \
+ do { \
+ --(ST)->recursion_depth; \
+ } while(0)
static int
static int
symtable_visit_stmt(struct symtable *st, stmt_ty s)
{
- ENTER_RECURSIVE();
+ ENTER_RECURSIVE(st);
switch (s->kind) {
case FunctionDef_kind: {
if (!symtable_add_def(st, s->v.FunctionDef.name, DEF_LOCAL, LOCATION(s)))
VISIT_SEQ(st, stmt, s->v.AsyncFor.orelse);
break;
}
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(st);
return 1;
}
static int
symtable_visit_expr(struct symtable *st, expr_ty e)
{
- ENTER_RECURSIVE();
+ ENTER_RECURSIVE(st);
switch (e->kind) {
case NamedExpr_kind:
if (!symtable_raise_if_annotation_block(st, "named expression", e)) {
VISIT_SEQ(st, expr, e->v.Tuple.elts);
break;
}
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(st);
return 1;
}
static int
symtable_visit_type_param(struct symtable *st, type_param_ty tp)
{
- ENTER_RECURSIVE();
+ ENTER_RECURSIVE(st);
switch(tp->kind) {
case TypeVar_kind:
if (!symtable_add_def(st, tp->v.TypeVar.name, DEF_TYPE_PARAM | DEF_LOCAL, LOCATION(tp)))
}
break;
}
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(st);
return 1;
}
static int
symtable_visit_pattern(struct symtable *st, pattern_ty p)
{
- ENTER_RECURSIVE();
+ ENTER_RECURSIVE(st);
switch (p->kind) {
case MatchValue_kind:
VISIT(st, expr, p->v.MatchValue.value);
VISIT_SEQ(st, pattern, p->v.MatchOr.patterns);
break;
}
- LEAVE_RECURSIVE();
+ LEAVE_RECURSIVE(st);
return 1;
}
"_PyUnicode_JoinArray",
"_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY",
"_Py_DECREF_NO_DEALLOC",
+ "_Py_EnterRecursiveCallTstateUnchecked",
"_Py_ID",
"_Py_IsImmortal",
"_Py_LeaveRecursiveCallPy",
"initial_temperature_backoff_counter",
"JUMP_TO_LABEL",
"restart_backoff_counter",
- "_Py_ReachedRecursionLimit",
)
def find_stmt_start(node: parser.CodeDef, idx: int) -> lexer.Token:
# define MAXSTACK 4000
# endif
#else
-# define MAXSTACK 4000
+# define MAXSTACK 6000
#endif
"""
self.cleanup_statements: List[str] = []
def add_level(self) -> None:
- self.print("if (p->level++ == MAXSTACK || _Py_ReachedRecursionLimitWithMargin(PyThreadState_Get(), 1)) {")
+ self.print("if (p->level++ == MAXSTACK) {")
with self.indent():
self.print("_Pypegen_stack_overflow(p);")
self.print("}")
projects / thirdparty / Python / cpython.git / commitdiff
