#else
#define D(x)
#endif
+
+# define MAXSTACK 6000
static const int n_keyword_lists = 15;
static KeywordToken *reserved_keywords[] = {
(KeywordToken[]) {{NULL, -1}},
static mod_ty
file_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
mod_ty _res = NULL;
int _mark = p->mark;
{ // statements? $
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> file[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statements? $"));
_res = _PyPegen_make_module ( p , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static mod_ty
interactive_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
mod_ty _res = NULL;
int _mark = p->mark;
{ // statement_newline
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> interactive[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement_newline"));
_res = Interactive ( a , p -> arena );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static mod_ty
eval_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
mod_ty _res = NULL;
int _mark = p->mark;
{ // expressions NEWLINE* $
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> eval[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expressions NEWLINE* $"));
_res = Expression ( a , p -> arena );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static mod_ty
func_type_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
mod_ty _res = NULL;
int _mark = p->mark;
{ // '(' type_expressions? ')' '->' expression NEWLINE* $
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> func_type[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' type_expressions? ')' '->' expression NEWLINE* $"));
_res = FunctionType ( a , b , p -> arena );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
fstring_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
{ // star_expressions
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> fstring[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
type_expressions_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // ','.expression+ ',' '*' expression ',' '**' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression ',' '**' expression"));
_res = _PyPegen_seq_append_to_end ( p , CHECK ( _PyPegen_seq_append_to_end ( p , a , b ) ) , c );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ','.expression+ ',' '*' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '*' expression"));
_res = _PyPegen_seq_append_to_end ( p , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ','.expression+ ',' '**' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+ ',' '**' expression"));
_res = _PyPegen_seq_append_to_end ( p , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '*' expression ',' '**' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression ',' '**' expression"));
_res = _PyPegen_seq_append_to_end ( p , CHECK ( _PyPegen_singleton_seq ( p , a ) ) , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '*' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression"));
_res = _PyPegen_singleton_seq ( p , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '**' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expression"));
_res = _PyPegen_singleton_seq ( p , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ','.expression+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> type_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.expression+"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
statements_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // statement+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> statements[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement+"));
_res = _PyPegen_seq_flatten ( p , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
statement_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // compound_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt"));
_res = _PyPegen_singleton_seq ( p , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // simple_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> statement[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
statement_newline_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // compound_stmt NEWLINE
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compound_stmt NEWLINE"));
_res = _PyPegen_singleton_seq ( p , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // simple_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt"));
}
{ // NEWLINE
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
D(fprintf(stderr, "%*c+ statement_newline[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _PyPegen_singleton_seq ( p , CHECK ( _Py_Pass ( EXTRA ) ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // $
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> statement_newline[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "$"));
_res = _PyPegen_interactive_exit ( p );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
simple_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // small_stmt !';' NEWLINE
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "small_stmt !';' NEWLINE"));
_res = _PyPegen_singleton_seq ( p , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ';'.small_stmt+ ';'? NEWLINE
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> simple_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'.small_stmt+ ';'? NEWLINE"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
small_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
if (_PyPegen_is_memoized(p, small_stmt_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // assignment
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "assignment"));
}
{ // star_expressions
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expressions"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Expr ( e , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // &'return' return_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'return' return_stmt"));
}
{ // &('import' | 'from') import_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('import' | 'from') import_stmt"));
}
{ // &'raise' raise_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'raise' raise_stmt"));
}
{ // 'pass'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'pass'"));
D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'pass'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Pass ( EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // &'del' del_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'del' del_stmt"));
}
{ // &'yield' yield_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'yield' yield_stmt"));
}
{ // &'assert' assert_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'assert' assert_stmt"));
}
{ // 'break'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'break'"));
D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'break'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Break ( EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // 'continue'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'continue'"));
D(fprintf(stderr, "%*c+ small_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'continue'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Continue ( EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // &'global' global_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'global' global_stmt"));
}
{ // &'nonlocal' nonlocal_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> small_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'nonlocal' nonlocal_stmt"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, small_stmt_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
compound_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
{ // &('def' | '@' | ASYNC) function_def
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('def' | '@' | ASYNC) function_def"));
}
{ // &'if' if_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'if' if_stmt"));
}
{ // &('class' | '@') class_def
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('class' | '@') class_def"));
}
{ // &('with' | ASYNC) with_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('with' | ASYNC) with_stmt"));
}
{ // &('for' | ASYNC) for_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&('for' | ASYNC) for_stmt"));
}
{ // &'try' try_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'try' try_stmt"));
}
{ // &'while' while_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compound_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'while' while_stmt"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
assignment_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // NAME ':' expression ['=' annotated_rhs]
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]"));
D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':' expression ['=' annotated_rhs]"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = CHECK_VERSION ( 6 , "Variable annotation syntax is" , _Py_AnnAssign ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , b , c , 1 , EXTRA ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]"));
D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs]"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = CHECK_VERSION ( 6 , "Variable annotations syntax is" , _Py_AnnAssign ( a , b , c , 0 , EXTRA ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?"));
D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Assign ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // single_target augassign ~ (yield_expr | star_expressions)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)"));
D(fprintf(stderr, "%*c+ assignment[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_AugAssign ( a , b -> kind , c , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
D(fprintf(stderr, "%*c%s assignment[%d-%d]: %s failed!\n", p->level, ' ',
p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "single_target augassign ~ (yield_expr | star_expressions)"));
if (_cut_var) {
- D(p->level--);
+ p->level--;
return NULL;
}
}
if (p->call_invalid_rules) { // invalid_assignment
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_assignment"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static AugOperator*
augassign_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
AugOperator* _res = NULL;
int _mark = p->mark;
{ // '+='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+='"));
_res = _PyPegen_augoperator ( p , Add );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '-='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-='"));
_res = _PyPegen_augoperator ( p , Sub );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '*='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*='"));
_res = _PyPegen_augoperator ( p , Mult );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '@='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@='"));
_res = CHECK_VERSION ( 5 , "The '@' operator is" , _PyPegen_augoperator ( p , MatMult ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '/='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'/='"));
_res = _PyPegen_augoperator ( p , Div );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '%='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'%='"));
_res = _PyPegen_augoperator ( p , Mod );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '&='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'&='"));
_res = _PyPegen_augoperator ( p , BitAnd );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '|='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'|='"));
_res = _PyPegen_augoperator ( p , BitOr );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '^='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'^='"));
_res = _PyPegen_augoperator ( p , BitXor );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '<<='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<<='"));
_res = _PyPegen_augoperator ( p , LShift );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '>>='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>>='"));
_res = _PyPegen_augoperator ( p , RShift );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '**='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**='"));
_res = _PyPegen_augoperator ( p , Pow );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '//='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> augassign[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'//='"));
_res = _PyPegen_augoperator ( p , FloorDiv );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
global_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'global' ','.NAME+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> global_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+"));
D(fprintf(stderr, "%*c+ global_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'global' ','.NAME+"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Global ( CHECK ( _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
nonlocal_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'nonlocal' ','.NAME+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> nonlocal_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+"));
D(fprintf(stderr, "%*c+ nonlocal_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'nonlocal' ','.NAME+"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Nonlocal ( CHECK ( _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
yield_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // yield_expr
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> yield_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
D(fprintf(stderr, "%*c+ yield_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "yield_expr"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Expr ( y , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
assert_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'assert' expression [',' expression]
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> assert_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]"));
D(fprintf(stderr, "%*c+ assert_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'assert' expression [',' expression]"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Assert ( a , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
del_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'del' del_targets &(';' | NEWLINE)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)"));
D(fprintf(stderr, "%*c+ del_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'del' del_targets &(';' | NEWLINE)"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Delete ( a , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
if (p->call_invalid_rules) { // invalid_del_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_del_stmt"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
import_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
{ // import_name
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_name"));
}
{ // import_from
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> import_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
import_name_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'import' dotted_as_names
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> import_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names"));
D(fprintf(stderr, "%*c+ import_name[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'import' dotted_as_names"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Import ( a , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
import_from_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'from' (('.' | '...'))* dotted_name 'import' import_from_targets
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets"));
D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))* dotted_name 'import' import_from_targets"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_ImportFrom ( b -> v . Name . id , c , _PyPegen_seq_count_dots ( a ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // 'from' (('.' | '...'))+ 'import' import_from_targets
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> import_from[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets"));
D(fprintf(stderr, "%*c+ import_from[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'from' (('.' | '...'))+ 'import' import_from_targets"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_ImportFrom ( NULL , b , _PyPegen_seq_count_dots ( a ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
import_from_targets_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // '(' import_from_as_names ','? ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' import_from_as_names ','? ')'"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // import_from_as_names !','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_names !','"));
}
{ // '*'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*'"));
_res = _PyPegen_singleton_seq ( p , CHECK ( _PyPegen_alias_for_star ( p ) ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
if (p->call_invalid_rules) { // invalid_import_from_targets
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_import_from_targets"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
import_from_as_names_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // ','.import_from_as_name+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> import_from_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.import_from_as_name+"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static alias_ty
import_from_as_name_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
alias_ty _res = NULL;
int _mark = p->mark;
{ // NAME ['as' NAME]
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> import_from_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ['as' NAME]"));
_res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
dotted_as_names_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // ','.dotted_as_name+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> dotted_as_names[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.dotted_as_name+"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static alias_ty
dotted_as_name_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
alias_ty _res = NULL;
int _mark = p->mark;
{ // dotted_name ['as' NAME]
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> dotted_as_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name ['as' NAME]"));
_res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
dotted_name_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, dotted_name_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
while (1) {
int tmpvar_0 = _PyPegen_update_memo(p, _mark, dotted_name_type, _res);
if (tmpvar_0) {
- D(p->level--);
+ p->level--;
return _res;
}
p->mark = _mark;
void *_raw = dotted_name_raw(p);
- if (p->error_indicator)
+ if (p->error_indicator) {
+ p->level--;
return NULL;
+ }
if (_raw == NULL || p->mark <= _resmark)
break;
_resmark = p->mark;
_res = _raw;
}
p->mark = _resmark;
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
dotted_name_raw(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
{ // dotted_name '.' NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_name '.' NAME"));
_res = _PyPegen_join_names_with_dot ( p , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> dotted_name[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
if_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'if' named_expression ':' block elif_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block elif_stmt"));
D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block elif_stmt"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_If ( a , b , CHECK ( _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // 'if' named_expression ':' block else_block?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> if_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block else_block?"));
D(fprintf(stderr, "%*c+ if_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'if' named_expression ':' block else_block?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_If ( a , b , c , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
elif_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'elif' named_expression ':' block elif_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block elif_stmt"));
D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block elif_stmt"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_If ( a , b , CHECK ( _PyPegen_singleton_seq ( p , c ) ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // 'elif' named_expression ':' block else_block?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> elif_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block else_block?"));
D(fprintf(stderr, "%*c+ elif_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'elif' named_expression ':' block else_block?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_If ( a , b , c , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
else_block_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // 'else' ':' block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> else_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'else' ':' block"));
_res = b;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
while_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'while' named_expression ':' block else_block?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> while_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' block else_block?"));
D(fprintf(stderr, "%*c+ while_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'while' named_expression ':' block else_block?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_While ( a , b , c , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
for_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_For ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
if (_cut_var) {
- D(p->level--);
+ p->level--;
return NULL;
}
}
{ // ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
D(fprintf(stderr, "%*c+ for_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = CHECK_VERSION ( 5 , "Async for loops are" , _Py_AsyncFor ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
D(fprintf(stderr, "%*c%s for_stmt[%d-%d]: %s failed!\n", p->level, ' ',
p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block?"));
if (_cut_var) {
- D(p->level--);
+ p->level--;
return NULL;
}
}
if (p->call_invalid_rules) { // invalid_for_target
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> for_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
with_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'with' '(' ','.with_item+ ','? ')' ':' block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block"));
D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' '(' ','.with_item+ ','? ')' ':' block"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_With ( a , b , NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // 'with' ','.with_item+ ':' TYPE_COMMENT? block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block"));
D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'with' ','.with_item+ ':' TYPE_COMMENT? block"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block"));
D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = CHECK_VERSION ( 5 , "Async with statements are" , _Py_AsyncWith ( a , b , NULL , EXTRA ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> with_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block"));
D(fprintf(stderr, "%*c+ with_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = CHECK_VERSION ( 5 , "Async with statements are" , _Py_AsyncWith ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static withitem_ty
with_item_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
withitem_ty _res = NULL;
int _mark = p->mark;
{ // expression 'as' star_target &(',' | ')' | ':')
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' star_target &(',' | ')' | ':')"));
_res = _Py_withitem ( e , t , p -> arena );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
if (p->call_invalid_rules) { // invalid_with_item
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_with_item"));
}
{ // expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
_res = _Py_withitem ( e , NULL , p -> arena );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
try_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'try' ':' block finally_block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' block finally_block"));
D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block finally_block"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Try ( b , NULL , NULL , f , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // 'try' ':' block except_block+ else_block? finally_block?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> try_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'try' ':' block except_block+ else_block? finally_block?"));
D(fprintf(stderr, "%*c+ try_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'try' ':' block except_block+ else_block? finally_block?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Try ( b , ex , el , f , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static excepthandler_ty
except_block_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
excepthandler_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'except' expression ['as' NAME] ':' block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' block"));
D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' expression ['as' NAME] ':' block"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // 'except' ':' block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> except_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'except' ':' block"));
D(fprintf(stderr, "%*c+ except_block[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'except' ':' block"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_ExceptHandler ( NULL , NULL , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
finally_block_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // 'finally' ':' block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> finally_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'finally' ':' block"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
return_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'return' star_expressions?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> return_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?"));
D(fprintf(stderr, "%*c+ return_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'return' star_expressions?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Return ( a , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
raise_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'raise' expression ['from' expression]
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]"));
D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise' expression ['from' expression]"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Raise ( a , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // 'raise'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> raise_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'raise'"));
D(fprintf(stderr, "%*c+ raise_stmt[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'raise'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Raise ( NULL , NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
function_def_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
{ // decorators function_def_raw
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators function_def_raw"));
_res = _PyPegen_function_def_decorators ( p , d , f );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // function_def_raw
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> function_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "function_def_raw"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
function_def_raw_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block"));
D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_FunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ASYNC 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> function_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block"));
D(fprintf(stderr, "%*c+ function_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "ASYNC 'def' NAME '(' params? ')' ['->' expression] ':' func_type_comment? block"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = CHECK_VERSION ( 5 , "Async functions are" , _Py_AsyncFunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static Token*
func_type_comment_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
Token* _res = NULL;
int _mark = p->mark;
{ // NEWLINE TYPE_COMMENT &(NEWLINE INDENT)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE TYPE_COMMENT &(NEWLINE INDENT)"));
_res = t;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
if (p->call_invalid_rules) { // invalid_double_type_comments
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_double_type_comments"));
}
{ // TYPE_COMMENT
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> func_type_comment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static arguments_ty
params_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
arguments_ty _res = NULL;
int _mark = p->mark;
if (p->call_invalid_rules) { // invalid_parameters
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_parameters"));
}
{ // parameters
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "parameters"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static arguments_ty
parameters_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
arguments_ty _res = NULL;
int _mark = p->mark;
{ // slash_no_default param_no_default* param_with_default* star_etc?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_no_default param_no_default* param_with_default* star_etc?"));
_res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // slash_with_default param_with_default* star_etc?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default param_with_default* star_etc?"));
_res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // param_no_default+ param_with_default* star_etc?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ param_with_default* star_etc?"));
_res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // param_with_default+ star_etc?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default+ star_etc?"));
_res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // star_etc
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_etc"));
_res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
slash_no_default_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // param_no_default+ '/' ','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' ','"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // param_no_default+ '/' &')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default+ '/' &')'"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static SlashWithDefault*
slash_with_default_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
SlashWithDefault* _res = NULL;
int _mark = p->mark;
{ // param_no_default* param_with_default+ '/' ','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' ','"));
_res = _PyPegen_slash_with_default ( p , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // param_no_default* param_with_default+ '/' &')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* param_with_default+ '/' &')'"));
_res = _PyPegen_slash_with_default ( p , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static StarEtc*
star_etc_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
StarEtc* _res = NULL;
int _mark = p->mark;
{ // '*' param_no_default param_maybe_default* kwds?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' param_no_default param_maybe_default* kwds?"));
_res = _PyPegen_star_etc ( p , a , b , c );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '*' ',' param_maybe_default+ kwds?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' param_maybe_default+ kwds?"));
_res = _PyPegen_star_etc ( p , NULL , b , c );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // kwds
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwds"));
_res = _PyPegen_star_etc ( p , NULL , NULL , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
if (p->call_invalid_rules) { // invalid_star_etc
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_star_etc"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static arg_ty
kwds_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
arg_ty _res = NULL;
int _mark = p->mark;
{ // '**' param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' param_no_default"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static arg_ty
param_no_default_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
arg_ty _res = NULL;
int _mark = p->mark;
{ // param ',' TYPE_COMMENT?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param ',' TYPE_COMMENT?"));
_res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // param TYPE_COMMENT? &')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param TYPE_COMMENT? &')'"));
_res = _PyPegen_add_type_comment_to_arg ( p , a , tc );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static NameDefaultPair*
param_with_default_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
NameDefaultPair* _res = NULL;
int _mark = p->mark;
{ // param default ',' TYPE_COMMENT?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default ',' TYPE_COMMENT?"));
_res = _PyPegen_name_default_pair ( p , a , c , tc );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // param default TYPE_COMMENT? &')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default TYPE_COMMENT? &')'"));
_res = _PyPegen_name_default_pair ( p , a , c , tc );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static NameDefaultPair*
param_maybe_default_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
NameDefaultPair* _res = NULL;
int _mark = p->mark;
{ // param default? ',' TYPE_COMMENT?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default? ',' TYPE_COMMENT?"));
_res = _PyPegen_name_default_pair ( p , a , c , tc );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // param default? TYPE_COMMENT? &')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param default? TYPE_COMMENT? &')'"));
_res = _PyPegen_name_default_pair ( p , a , c , tc );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static arg_ty
param_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
arg_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // NAME annotation?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME annotation?"));
D(fprintf(stderr, "%*c+ param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME annotation?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_arg ( a -> v . Name . id , b , NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
annotation_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
{ // ':' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> annotation[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
default_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
{ // '=' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' expression"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
decorators_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // (('@' named_expression NEWLINE))+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> decorators[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(('@' named_expression NEWLINE))+"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
class_def_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
{ // decorators class_def_raw
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "decorators class_def_raw"));
_res = _PyPegen_class_def_decorators ( p , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // class_def_raw
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> class_def[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "class_def_raw"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static stmt_ty
class_def_raw_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
stmt_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'class' NAME ['(' arguments? ')'] ':' block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> class_def_raw[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block"));
D(fprintf(stderr, "%*c+ class_def_raw[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'class' NAME ['(' arguments? ')'] ':' block"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_ClassDef ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , c , NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
block_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
if (_PyPegen_is_memoized(p, block_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
{ // NEWLINE INDENT statements DEDENT
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT statements DEDENT"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // simple_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "simple_stmt"));
}
if (p->call_invalid_rules) { // invalid_block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_block"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, block_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
star_expressions_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // star_expression ((',' star_expression))+ ','?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?"));
D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ((',' star_expression))+ ','?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // star_expression ','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression ','"));
D(fprintf(stderr, "%*c+ star_expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_expression ','"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Tuple ( CHECK ( _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // star_expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expression"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
star_expression_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, star_expression_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '*' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
D(fprintf(stderr, "%*c+ star_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Starred ( a , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, star_expression_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
star_named_expressions_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // ','.star_named_expression+ ','?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_named_expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.star_named_expression+ ','?"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
star_named_expression_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '*' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
D(fprintf(stderr, "%*c+ star_named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' bitwise_or"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Starred ( a , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // named_expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
named_expression_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // NAME ':=' ~ expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression"));
D(fprintf(stderr, "%*c+ named_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME ':=' ~ expression"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_NamedExpr ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
D(fprintf(stderr, "%*c%s named_expression[%d-%d]: %s failed!\n", p->level, ' ',
p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "NAME ':=' ~ expression"));
if (_cut_var) {
- D(p->level--);
+ p->level--;
return NULL;
}
}
{ // expression !':='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression !':='"));
}
if (p->call_invalid_rules) { // invalid_named_expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_named_expression"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
annotated_rhs_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
{ // yield_expr
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
}
{ // star_expressions
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> annotated_rhs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
expressions_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // expression ((',' expression))+ ','?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?"));
D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ((',' expression))+ ','?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // expression ','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ','"));
D(fprintf(stderr, "%*c+ expressions[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression ','"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Tuple ( CHECK ( _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> expressions[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
expression_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, expression_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // disjunction 'if' disjunction 'else' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
D(fprintf(stderr, "%*c+ expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "disjunction 'if' disjunction 'else' expression"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_IfExp ( b , a , c , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // disjunction
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "disjunction"));
}
{ // lambdef
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambdef"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, expression_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
lambdef_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'lambda' lambda_params? ':' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambdef[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression"));
D(fprintf(stderr, "%*c+ lambdef[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'lambda' lambda_params? ':' expression"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Lambda ( ( a ) ? a : CHECK ( _PyPegen_empty_arguments ( p ) ) , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static arguments_ty
lambda_params_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
arguments_ty _res = NULL;
int _mark = p->mark;
if (p->call_invalid_rules) { // invalid_lambda_parameters
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_parameters"));
}
{ // lambda_parameters
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_parameters"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static arguments_ty
lambda_parameters_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
arguments_ty _res = NULL;
int _mark = p->mark;
{ // lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc?"));
_res = _PyPegen_make_arguments ( p , a , NULL , b , c , d );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // lambda_slash_with_default lambda_param_with_default* lambda_star_etc?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default lambda_param_with_default* lambda_star_etc?"));
_res = _PyPegen_make_arguments ( p , NULL , a , NULL , b , c );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ lambda_param_with_default* lambda_star_etc?"));
_res = _PyPegen_make_arguments ( p , NULL , NULL , a , b , c );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // lambda_param_with_default+ lambda_star_etc?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+ lambda_star_etc?"));
_res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // lambda_star_etc
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_star_etc"));
_res = _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
lambda_slash_no_default_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // lambda_param_no_default+ '/' ','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' ','"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // lambda_param_no_default+ '/' &':'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_slash_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default+ '/' &':'"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static SlashWithDefault*
lambda_slash_with_default_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
SlashWithDefault* _res = NULL;
int _mark = p->mark;
{ // lambda_param_no_default* lambda_param_with_default+ '/' ','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' ','"));
_res = _PyPegen_slash_with_default ( p , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // lambda_param_no_default* lambda_param_with_default+ '/' &':'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_slash_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* lambda_param_with_default+ '/' &':'"));
_res = _PyPegen_slash_with_default ( p , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static StarEtc*
lambda_star_etc_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
StarEtc* _res = NULL;
int _mark = p->mark;
{ // '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds?"));
_res = _PyPegen_star_etc ( p , a , b , c );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '*' ',' lambda_param_maybe_default+ lambda_kwds?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' lambda_param_maybe_default+ lambda_kwds?"));
_res = _PyPegen_star_etc ( p , NULL , b , c );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // lambda_kwds
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_kwds"));
_res = _PyPegen_star_etc ( p , NULL , NULL , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
if (p->call_invalid_rules) { // invalid_lambda_star_etc
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_lambda_star_etc"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static arg_ty
lambda_kwds_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
arg_ty _res = NULL;
int _mark = p->mark;
{ // '**' lambda_param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_kwds[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' lambda_param_no_default"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static arg_ty
lambda_param_no_default_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
arg_ty _res = NULL;
int _mark = p->mark;
{ // lambda_param ','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param ','"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // lambda_param &':'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_param_no_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param &':'"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static NameDefaultPair*
lambda_param_with_default_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
NameDefaultPair* _res = NULL;
int _mark = p->mark;
{ // lambda_param default ','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default ','"));
_res = _PyPegen_name_default_pair ( p , a , c , NULL );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // lambda_param default &':'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_param_with_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default &':'"));
_res = _PyPegen_name_default_pair ( p , a , c , NULL );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static NameDefaultPair*
lambda_param_maybe_default_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
NameDefaultPair* _res = NULL;
int _mark = p->mark;
{ // lambda_param default? ','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default? ','"));
_res = _PyPegen_name_default_pair ( p , a , c , NULL );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // lambda_param default? &':'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_param_maybe_default[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param default? &':'"));
_res = _PyPegen_name_default_pair ( p , a , c , NULL );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static arg_ty
lambda_param_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
arg_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lambda_param[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
D(fprintf(stderr, "%*c+ lambda_param[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_arg ( a -> v . Name . id , NULL , NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
disjunction_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, disjunction_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // conjunction (('or' conjunction))+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+"));
D(fprintf(stderr, "%*c+ disjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "conjunction (('or' conjunction))+"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BoolOp ( Or , CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // conjunction
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> disjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "conjunction"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, disjunction_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
conjunction_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, conjunction_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // inversion (('and' inversion))+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+"));
D(fprintf(stderr, "%*c+ conjunction[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "inversion (('and' inversion))+"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BoolOp ( And , CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // inversion
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> conjunction[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "inversion"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, conjunction_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
inversion_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, inversion_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'not' inversion
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' inversion"));
D(fprintf(stderr, "%*c+ inversion[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'not' inversion"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_UnaryOp ( Not , a , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // comparison
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> inversion[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "comparison"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, inversion_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
comparison_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // bitwise_or compare_op_bitwise_or_pair+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+"));
D(fprintf(stderr, "%*c+ comparison[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or compare_op_bitwise_or_pair+"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Compare ( a , CHECK ( _PyPegen_get_cmpops ( p , b ) ) , CHECK ( _PyPegen_get_exprs ( p , b ) ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> comparison[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static CmpopExprPair*
compare_op_bitwise_or_pair_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
CmpopExprPair* _res = NULL;
int _mark = p->mark;
{ // eq_bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "eq_bitwise_or"));
}
{ // noteq_bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "noteq_bitwise_or"));
}
{ // lte_bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lte_bitwise_or"));
}
{ // lt_bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lt_bitwise_or"));
}
{ // gte_bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "gte_bitwise_or"));
}
{ // gt_bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "gt_bitwise_or"));
}
{ // notin_bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "notin_bitwise_or"));
}
{ // in_bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "in_bitwise_or"));
}
{ // isnot_bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "isnot_bitwise_or"));
}
{ // is_bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> compare_op_bitwise_or_pair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "is_bitwise_or"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static CmpopExprPair*
eq_bitwise_or_rule(Parser *p)
{
- D(p->level++);
- if (p->error_indicator) {
- D(p->level--);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
+ if (p->error_indicator) {
+ p->level--;
return NULL;
}
CmpopExprPair* _res = NULL;
int _mark = p->mark;
{ // '==' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> eq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'==' bitwise_or"));
_res = _PyPegen_cmpop_expr_pair ( p , Eq , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static CmpopExprPair*
noteq_bitwise_or_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
CmpopExprPair* _res = NULL;
int _mark = p->mark;
{ // ('!=') bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> noteq_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('!=') bitwise_or"));
_res = _PyPegen_cmpop_expr_pair ( p , NotEq , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static CmpopExprPair*
lte_bitwise_or_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
CmpopExprPair* _res = NULL;
int _mark = p->mark;
{ // '<=' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<=' bitwise_or"));
_res = _PyPegen_cmpop_expr_pair ( p , LtE , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static CmpopExprPair*
lt_bitwise_or_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
CmpopExprPair* _res = NULL;
int _mark = p->mark;
{ // '<' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> lt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'<' bitwise_or"));
_res = _PyPegen_cmpop_expr_pair ( p , Lt , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static CmpopExprPair*
gte_bitwise_or_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
CmpopExprPair* _res = NULL;
int _mark = p->mark;
{ // '>=' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> gte_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>=' bitwise_or"));
_res = _PyPegen_cmpop_expr_pair ( p , GtE , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static CmpopExprPair*
gt_bitwise_or_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
CmpopExprPair* _res = NULL;
int _mark = p->mark;
{ // '>' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> gt_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'>' bitwise_or"));
_res = _PyPegen_cmpop_expr_pair ( p , Gt , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static CmpopExprPair*
notin_bitwise_or_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
CmpopExprPair* _res = NULL;
int _mark = p->mark;
{ // 'not' 'in' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> notin_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'not' 'in' bitwise_or"));
_res = _PyPegen_cmpop_expr_pair ( p , NotIn , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static CmpopExprPair*
in_bitwise_or_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
CmpopExprPair* _res = NULL;
int _mark = p->mark;
{ // 'in' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> in_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'in' bitwise_or"));
_res = _PyPegen_cmpop_expr_pair ( p , In , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static CmpopExprPair*
isnot_bitwise_or_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
CmpopExprPair* _res = NULL;
int _mark = p->mark;
{ // 'is' 'not' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> isnot_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' 'not' bitwise_or"));
_res = _PyPegen_cmpop_expr_pair ( p , IsNot , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static CmpopExprPair*
is_bitwise_or_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
CmpopExprPair* _res = NULL;
int _mark = p->mark;
{ // 'is' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> is_bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'is' bitwise_or"));
_res = _PyPegen_cmpop_expr_pair ( p , Is , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
bitwise_or_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, bitwise_or_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
while (1) {
int tmpvar_1 = _PyPegen_update_memo(p, _mark, bitwise_or_type, _res);
if (tmpvar_1) {
- D(p->level--);
+ p->level--;
return _res;
}
p->mark = _mark;
void *_raw = bitwise_or_raw(p);
- if (p->error_indicator)
+ if (p->error_indicator) {
+ p->level--;
return NULL;
+ }
if (_raw == NULL || p->mark <= _resmark)
break;
_resmark = p->mark;
_res = _raw;
}
p->mark = _resmark;
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
bitwise_or_raw(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // bitwise_or '|' bitwise_xor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor"));
D(fprintf(stderr, "%*c+ bitwise_or[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_or '|' bitwise_xor"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , BitOr , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // bitwise_xor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> bitwise_or[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
bitwise_xor_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, bitwise_xor_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
while (1) {
int tmpvar_2 = _PyPegen_update_memo(p, _mark, bitwise_xor_type, _res);
if (tmpvar_2) {
- D(p->level--);
+ p->level--;
return _res;
}
p->mark = _mark;
void *_raw = bitwise_xor_raw(p);
- if (p->error_indicator)
+ if (p->error_indicator) {
+ p->level--;
return NULL;
+ }
if (_raw == NULL || p->mark <= _resmark)
break;
_resmark = p->mark;
_res = _raw;
}
p->mark = _resmark;
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
bitwise_xor_raw(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // bitwise_xor '^' bitwise_and
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and"));
D(fprintf(stderr, "%*c+ bitwise_xor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_xor '^' bitwise_and"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , BitXor , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // bitwise_and
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> bitwise_xor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
bitwise_and_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, bitwise_and_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
while (1) {
int tmpvar_3 = _PyPegen_update_memo(p, _mark, bitwise_and_type, _res);
if (tmpvar_3) {
- D(p->level--);
+ p->level--;
return _res;
}
p->mark = _mark;
void *_raw = bitwise_and_raw(p);
- if (p->error_indicator)
+ if (p->error_indicator) {
+ p->level--;
return NULL;
+ }
if (_raw == NULL || p->mark <= _resmark)
break;
_resmark = p->mark;
_res = _raw;
}
p->mark = _resmark;
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
bitwise_and_raw(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // bitwise_and '&' shift_expr
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr"));
D(fprintf(stderr, "%*c+ bitwise_and[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "bitwise_and '&' shift_expr"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , BitAnd , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // shift_expr
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> bitwise_and[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
shift_expr_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, shift_expr_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
while (1) {
int tmpvar_4 = _PyPegen_update_memo(p, _mark, shift_expr_type, _res);
if (tmpvar_4) {
- D(p->level--);
+ p->level--;
return _res;
}
p->mark = _mark;
void *_raw = shift_expr_raw(p);
- if (p->error_indicator)
+ if (p->error_indicator) {
+ p->level--;
return NULL;
+ }
if (_raw == NULL || p->mark <= _resmark)
break;
_resmark = p->mark;
_res = _raw;
}
p->mark = _resmark;
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
shift_expr_raw(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // shift_expr '<<' sum
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum"));
D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '<<' sum"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , LShift , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // shift_expr '>>' sum
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum"));
D(fprintf(stderr, "%*c+ shift_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "shift_expr '>>' sum"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , RShift , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // sum
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> shift_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
sum_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, sum_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
while (1) {
int tmpvar_5 = _PyPegen_update_memo(p, _mark, sum_type, _res);
if (tmpvar_5) {
- D(p->level--);
+ p->level--;
return _res;
}
p->mark = _mark;
void *_raw = sum_raw(p);
- if (p->error_indicator)
+ if (p->error_indicator) {
+ p->level--;
return NULL;
+ }
if (_raw == NULL || p->mark <= _resmark)
break;
_resmark = p->mark;
_res = _raw;
}
p->mark = _resmark;
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
sum_raw(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // sum '+' term
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '+' term"));
D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '+' term"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , Add , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // sum '-' term
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "sum '-' term"));
D(fprintf(stderr, "%*c+ sum[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "sum '-' term"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , Sub , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // term
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> sum[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
term_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, term_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
while (1) {
int tmpvar_6 = _PyPegen_update_memo(p, _mark, term_type, _res);
if (tmpvar_6) {
- D(p->level--);
+ p->level--;
return _res;
}
p->mark = _mark;
void *_raw = term_raw(p);
- if (p->error_indicator)
+ if (p->error_indicator) {
+ p->level--;
return NULL;
+ }
if (_raw == NULL || p->mark <= _resmark)
break;
_resmark = p->mark;
_res = _raw;
}
p->mark = _resmark;
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
term_raw(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // term '*' factor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '*' factor"));
D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '*' factor"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , Mult , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // term '/' factor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '/' factor"));
D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '/' factor"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , Div , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // term '//' factor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '//' factor"));
D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '//' factor"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , FloorDiv , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // term '%' factor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '%' factor"));
D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '%' factor"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , Mod , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // term '@' factor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "term '@' factor"));
D(fprintf(stderr, "%*c+ term[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "term '@' factor"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = CHECK_VERSION ( 5 , "The '@' operator is" , _Py_BinOp ( a , MatMult , b , EXTRA ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // factor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> term[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "factor"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
factor_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, factor_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '+' factor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'+' factor"));
D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'+' factor"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_UnaryOp ( UAdd , a , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '-' factor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'-' factor"));
D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'-' factor"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_UnaryOp ( USub , a , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '~' factor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'~' factor"));
D(fprintf(stderr, "%*c+ factor[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'~' factor"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_UnaryOp ( Invert , a , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // power
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> factor[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "power"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, factor_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
power_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // await_primary '**' factor
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary '**' factor"));
D(fprintf(stderr, "%*c+ power[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "await_primary '**' factor"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_BinOp ( a , Pow , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // await_primary
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> power[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "await_primary"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
await_primary_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, await_primary_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // AWAIT primary
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "AWAIT primary"));
D(fprintf(stderr, "%*c+ await_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "AWAIT primary"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = CHECK_VERSION ( 5 , "Await expressions are" , _Py_Await ( a , EXTRA ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // primary
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> await_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, await_primary_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
primary_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, primary_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
while (1) {
int tmpvar_7 = _PyPegen_update_memo(p, _mark, primary_type, _res);
if (tmpvar_7) {
- D(p->level--);
+ p->level--;
return _res;
}
p->mark = _mark;
void *_raw = primary_raw(p);
- if (p->error_indicator)
+ if (p->error_indicator) {
+ p->level--;
return NULL;
+ }
if (_raw == NULL || p->mark <= _resmark)
break;
_resmark = p->mark;
_res = _raw;
}
p->mark = _resmark;
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
primary_raw(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
if (p->call_invalid_rules) { // invalid_primary
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_primary"));
}
{ // primary '.' NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '.' NAME"));
D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '.' NAME"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Attribute ( a , b -> v . Name . id , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // primary genexp
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary genexp"));
D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary genexp"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Call ( a , CHECK ( _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // primary '(' arguments? ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'"));
D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '(' arguments? ')'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // primary '[' slices ']'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'"));
D(fprintf(stderr, "%*c+ primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "primary '[' slices ']'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Subscript ( a , b , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // atom
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
slices_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // slice !','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice !','"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ','.slice+ ','?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> slices[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.slice+ ','?"));
D(fprintf(stderr, "%*c+ slices[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.slice+ ','?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Tuple ( a , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
slice_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // expression? ':' expression? [':' expression?]
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]"));
D(fprintf(stderr, "%*c+ slice[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "expression? ':' expression? [':' expression?]"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Slice ( a , b , c , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> slice[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
atom_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
}
{ // 'True'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'True'"));
D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'True'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Constant ( Py_True , NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // 'False'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'False'"));
D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'False'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Constant ( Py_False , NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // 'None'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'None'"));
D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'None'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Constant ( Py_None , NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '__peg_parser__'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'__peg_parser__'"));
_res = RAISE_SYNTAX_ERROR ( "You found it!" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // &STRING strings
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&STRING strings"));
}
{ // NUMBER
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NUMBER"));
}
{ // &'(' (tuple | group | genexp)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'(' (tuple | group | genexp)"));
}
{ // &'[' (list | listcomp)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'[' (list | listcomp)"));
}
{ // &'{' (dict | set | dictcomp | setcomp)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "&'{' (dict | set | dictcomp | setcomp)"));
}
{ // '...'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
D(fprintf(stderr, "%*c+ atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'...'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Constant ( Py_Ellipsis , NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
strings_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, strings_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
{ // STRING+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> strings[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING+"));
_res = _PyPegen_concatenate_strings ( p , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, strings_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
list_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '[' star_named_expressions? ']'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> list[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'"));
D(fprintf(stderr, "%*c+ list[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_named_expressions? ']'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_List ( a , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
listcomp_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '[' named_expression ~ for_if_clauses ']'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' named_expression ~ for_if_clauses ']'"));
D(fprintf(stderr, "%*c+ listcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' named_expression ~ for_if_clauses ']'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_ListComp ( a , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
D(fprintf(stderr, "%*c%s listcomp[%d-%d]: %s failed!\n", p->level, ' ',
p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'[' named_expression ~ for_if_clauses ']'"));
if (_cut_var) {
- D(p->level--);
+ p->level--;
return NULL;
}
}
if (p->call_invalid_rules) { // invalid_comprehension
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> listcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
tuple_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '(' [star_named_expression ',' star_named_expressions?] ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> tuple[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'"));
D(fprintf(stderr, "%*c+ tuple[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' [star_named_expression ',' star_named_expressions?] ')'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Tuple ( a , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
group_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
{ // '(' (yield_expr | named_expression) ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' (yield_expr | named_expression) ')'"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
if (p->call_invalid_rules) { // invalid_group
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_group"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
genexp_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '(' named_expression ~ for_if_clauses ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' named_expression ~ for_if_clauses ')'"));
D(fprintf(stderr, "%*c+ genexp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' named_expression ~ for_if_clauses ')'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_GeneratorExp ( a , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
D(fprintf(stderr, "%*c%s genexp[%d-%d]: %s failed!\n", p->level, ' ',
p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'(' named_expression ~ for_if_clauses ')'"));
if (_cut_var) {
- D(p->level--);
+ p->level--;
return NULL;
}
}
if (p->call_invalid_rules) { // invalid_comprehension
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> genexp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
set_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '{' star_named_expressions '}'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> set[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'"));
D(fprintf(stderr, "%*c+ set[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' star_named_expressions '}'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Set ( a , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
setcomp_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '{' named_expression ~ for_if_clauses '}'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' named_expression ~ for_if_clauses '}'"));
D(fprintf(stderr, "%*c+ setcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' named_expression ~ for_if_clauses '}'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_SetComp ( a , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
D(fprintf(stderr, "%*c%s setcomp[%d-%d]: %s failed!\n", p->level, ' ',
p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'{' named_expression ~ for_if_clauses '}'"));
if (_cut_var) {
- D(p->level--);
+ p->level--;
return NULL;
}
}
if (p->call_invalid_rules) { // invalid_comprehension
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> setcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_comprehension"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
dict_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '{' double_starred_kvpairs? '}'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> dict[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'"));
D(fprintf(stderr, "%*c+ dict[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' double_starred_kvpairs? '}'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Dict ( CHECK ( _PyPegen_get_keys ( p , a ) ) , CHECK ( _PyPegen_get_values ( p , a ) ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
dictcomp_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '{' kvpair for_if_clauses '}'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'"));
D(fprintf(stderr, "%*c+ dictcomp[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'{' kvpair for_if_clauses '}'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_DictComp ( a -> key , a -> value , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
if (p->call_invalid_rules) { // invalid_dict_comprehension
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> dictcomp[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_dict_comprehension"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
double_starred_kvpairs_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // ','.double_starred_kvpair+ ','?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> double_starred_kvpairs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.double_starred_kvpair+ ','?"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static KeyValuePair*
double_starred_kvpair_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
KeyValuePair* _res = NULL;
int _mark = p->mark;
{ // '**' bitwise_or
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' bitwise_or"));
_res = _PyPegen_key_value_pair ( p , NULL , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // kvpair
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> double_starred_kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kvpair"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static KeyValuePair*
kvpair_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
KeyValuePair* _res = NULL;
int _mark = p->mark;
{ // expression ':' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> kvpair[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
_res = _PyPegen_key_value_pair ( p , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
for_if_clauses_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // for_if_clause+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> for_if_clauses[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause+"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static comprehension_ty
for_if_clause_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
comprehension_ty _res = NULL;
int _mark = p->mark;
{ // ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
_res = CHECK_VERSION ( 6 , "Async comprehensions are" , _Py_comprehension ( a , b , c , 1 , p -> arena ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',
p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
if (_cut_var) {
- D(p->level--);
+ p->level--;
return NULL;
}
}
{ // 'for' star_targets 'in' ~ disjunction (('if' disjunction))*
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
_res = _Py_comprehension ( a , b , c , 0 , p -> arena );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
D(fprintf(stderr, "%*c%s for_if_clause[%d-%d]: %s failed!\n", p->level, ' ',
p->error_indicator ? "ERROR!" : "-", _mark, p->mark, "'for' star_targets 'in' ~ disjunction (('if' disjunction))*"));
if (_cut_var) {
- D(p->level--);
+ p->level--;
return NULL;
}
}
if (p->call_invalid_rules) { // invalid_for_target
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> for_if_clause[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_for_target"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
yield_expr_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // 'yield' 'from' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression"));
D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' 'from' expression"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_YieldFrom ( a , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // 'yield' star_expressions?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> yield_expr[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?"));
D(fprintf(stderr, "%*c+ yield_expr[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'yield' star_expressions?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Yield ( a , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
arguments_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, arguments_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
{ // args ','? &')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ','? &')'"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
if (p->call_invalid_rules) { // invalid_arguments
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_arguments"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, arguments_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
args_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // ','.(starred_expression | named_expression !'=')+ [',' kwargs]
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | named_expression !'=')+ [',' kwargs]"));
D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "','.(starred_expression | named_expression !'=')+ [',' kwargs]"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _PyPegen_collect_call_seqs ( p , a , b , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // kwargs
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> args[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwargs"));
D(fprintf(stderr, "%*c+ args[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "kwargs"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Call ( _PyPegen_dummy_name ( p ) , CHECK_NULL_ALLOWED ( _PyPegen_seq_extract_starred_exprs ( p , a ) ) , CHECK_NULL_ALLOWED ( _PyPegen_seq_delete_starred_exprs ( p , a ) ) , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
kwargs_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+"));
_res = _PyPegen_join_sequences ( p , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ','.kwarg_or_starred+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_starred+"));
}
{ // ','.kwarg_or_double_starred+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> kwargs[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.kwarg_or_double_starred+"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
starred_expression_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '*' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> starred_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' expression"));
D(fprintf(stderr, "%*c+ starred_expression[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' expression"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Starred ( a , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static KeywordOrStarred*
kwarg_or_starred_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
KeywordOrStarred* _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // NAME '=' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
D(fprintf(stderr, "%*c+ kwarg_or_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // starred_expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression"));
_res = _PyPegen_keyword_or_starred ( p , a , 0 );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
if (p->call_invalid_rules) { // invalid_kwarg
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> kwarg_or_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static KeywordOrStarred*
kwarg_or_double_starred_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
KeywordOrStarred* _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // NAME '=' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "NAME '=' expression"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '**' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**' expression"));
D(fprintf(stderr, "%*c+ kwarg_or_double_starred[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'**' expression"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _PyPegen_keyword_or_starred ( p , CHECK ( _Py_keyword ( NULL , a , EXTRA ) ) , 1 );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
if (p->call_invalid_rules) { // invalid_kwarg
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> kwarg_or_double_starred[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_kwarg"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
star_targets_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // star_target !','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target !','"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // star_target ((',' star_target))* ','?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?"));
D(fprintf(stderr, "%*c+ star_targets[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))* ','?"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Tuple ( CHECK ( _PyPegen_seq_insert_in_front ( p , a , b ) ) , Store , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
star_targets_list_seq_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // ','.star_target+ ','?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_targets_list_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.star_target+ ','?"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
star_targets_tuple_seq_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // star_target ((',' star_target))+ ','?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ((',' star_target))+ ','?"));
_res = _PyPegen_seq_insert_in_front ( p , a , b );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // star_target ','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_targets_tuple_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target ','"));
_res = _PyPegen_singleton_seq ( p , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
star_target_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, star_target_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // '*' (!'*' star_target)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)"));
D(fprintf(stderr, "%*c+ star_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'*' (!'*' star_target)"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Starred ( CHECK ( _PyPegen_set_expr_context ( p , a , Store ) ) , Store , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // target_with_star_atom
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "target_with_star_atom"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, star_target_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
target_with_star_atom_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, target_with_star_atom_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // t_primary '.' NAME !t_lookahead
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // t_primary '[' slices ']' !t_lookahead
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
D(fprintf(stderr, "%*c+ target_with_star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Subscript ( a , b , Store , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // star_atom
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> target_with_star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_atom"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, target_with_star_atom_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
star_atom_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
_res = _PyPegen_set_expr_context ( p , a , Store );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '(' target_with_star_atom ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' target_with_star_atom ')'"));
_res = _PyPegen_set_expr_context ( p , a , Store );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '(' star_targets_tuple_seq? ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'"));
D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' star_targets_tuple_seq? ')'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Tuple ( a , Store , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '[' star_targets_list_seq? ']'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> star_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'"));
D(fprintf(stderr, "%*c+ star_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' star_targets_list_seq? ']'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_List ( a , Store , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
single_target_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
{ // single_subscript_attribute_target
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
}
{ // NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
_res = _PyPegen_set_expr_context ( p , a , Store );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '(' single_target ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> single_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
single_subscript_attribute_target_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // t_primary '.' NAME !t_lookahead
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Attribute ( a , b -> v . Name . id , Store , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // t_primary '[' slices ']' !t_lookahead
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> single_subscript_attribute_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
D(fprintf(stderr, "%*c+ single_subscript_attribute_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Subscript ( a , b , Store , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq*
del_targets_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq* _res = NULL;
int _mark = p->mark;
{ // ','.del_target+ ','?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> del_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.del_target+ ','?"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
del_target_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, del_target_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // t_primary '.' NAME !t_lookahead
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME !t_lookahead"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Attribute ( a , b -> v . Name . id , Del , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // t_primary '[' slices ']' !t_lookahead
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
D(fprintf(stderr, "%*c+ del_target[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' !t_lookahead"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Subscript ( a , b , Del , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // del_t_atom
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> del_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_t_atom"));
_res = NULL;
done:
_PyPegen_insert_memo(p, _mark, del_target_type, _res);
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
del_t_atom_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME"));
_res = _PyPegen_set_expr_context ( p , a , Del );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '(' del_target ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_target ')'"));
_res = _PyPegen_set_expr_context ( p , a , Del );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '(' del_targets? ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' del_targets? ')'"));
D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'(' del_targets? ')'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Tuple ( a , Del , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '[' del_targets? ']'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> del_t_atom[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' del_targets? ']'"));
D(fprintf(stderr, "%*c+ del_t_atom[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' del_targets? ']'"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_List ( a , Del , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
t_primary_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
expr_ty _res = NULL;
if (_PyPegen_is_memoized(p, t_primary_type, &_res)) {
- D(p->level--);
+ p->level--;
return _res;
}
int _mark = p->mark;
while (1) {
int tmpvar_8 = _PyPegen_update_memo(p, _mark, t_primary_type, _res);
if (tmpvar_8) {
- D(p->level--);
+ p->level--;
return _res;
}
p->mark = _mark;
void *_raw = t_primary_raw(p);
- if (p->error_indicator)
+ if (p->error_indicator) {
+ p->level--;
return NULL;
+ }
if (_raw == NULL || p->mark <= _resmark)
break;
_resmark = p->mark;
_res = _raw;
}
p->mark = _resmark;
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
t_primary_raw(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
int _start_lineno = p->tokens[_mark]->lineno;
UNUSED(_start_col_offset); // Only used by EXTRA macro
{ // t_primary '.' NAME &t_lookahead
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME &t_lookahead"));
D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '.' NAME &t_lookahead"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Attribute ( a , b -> v . Name . id , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // t_primary '[' slices ']' &t_lookahead
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' &t_lookahead"));
D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '[' slices ']' &t_lookahead"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Subscript ( a , b , Load , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // t_primary genexp &t_lookahead
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary genexp &t_lookahead"));
D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary genexp &t_lookahead"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Call ( a , CHECK ( _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // t_primary '(' arguments? ')' &t_lookahead
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead"));
D(fprintf(stderr, "%*c+ t_primary[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "t_primary '(' arguments? ')' &t_lookahead"));
Token *_token = _PyPegen_get_last_nonnwhitespace_token(p);
if (_token == NULL) {
- D(p->level--);
+ p->level--;
return NULL;
}
int _end_lineno = _token->end_lineno;
_res = _Py_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // atom &t_lookahead
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> t_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "atom &t_lookahead"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
t_lookahead_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '('
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
}
{ // '['
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
}
{ // '.'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> t_lookahead[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_arguments_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // args ',' '*'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' '*'"));
_res = RAISE_SYNTAX_ERROR ( "iterable argument unpacking follows keyword argument unpacking" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // expression for_if_clauses ',' [args | expression for_if_clauses]
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses ',' [args | expression for_if_clauses]"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "Generator expression must be parenthesized" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // args for_if_clauses
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args for_if_clauses"));
_res = _PyPegen_nonparen_genexp_in_call ( p , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // args ',' expression for_if_clauses
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' expression for_if_clauses"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "Generator expression must be parenthesized" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // args ',' args
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_arguments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args ',' args"));
_res = _PyPegen_arguments_parsing_error ( p , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_kwarg_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // !(NAME '=') expression '='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_kwarg[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!(NAME '=') expression '='"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression cannot contain assignment, perhaps you meant \"==\"?" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_named_expression_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // expression ':=' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_named_expression[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':=' expression"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use assignment expressions with %s" , _PyPegen_get_expr_name ( a ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_assignment_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // invalid_ann_assign_target ':' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "invalid_ann_assign_target ':' expression"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not %s) can be annotated" , _PyPegen_get_expr_name ( a ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // star_named_expression ',' star_named_expressions* ':' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions* ':' expression"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not tuple) can be annotated" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // expression ':' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression ':' expression"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "illegal target for annotation" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ((star_targets '='))* star_expressions '='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* star_expressions '='"));
_res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // ((star_targets '='))* yield_expr '='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "((star_targets '='))* yield_expr '='"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "assignment to yield expression not possible" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // star_expressions augassign (yield_expr | star_expressions)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_assignment[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions augassign (yield_expr | star_expressions)"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "'%s' is an illegal expression for augmented assignment" , _PyPegen_get_expr_name ( a ) );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static expr_ty
invalid_ann_assign_target_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
expr_ty _res = NULL;
int _mark = p->mark;
{ // list
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list"));
}
{ // tuple
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple"));
}
{ // '(' invalid_ann_assign_target ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_ann_assign_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' invalid_ann_assign_target ')'"));
_res = a;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_del_stmt_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'del' star_expressions
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_del_stmt[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'del' star_expressions"));
_res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( DEL_TARGETS , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_block_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // NEWLINE !INDENT
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_block[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE !INDENT"));
_res = RAISE_INDENTATION_ERROR ( "expected an indented block" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_primary_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // primary '{'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_primary[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "primary '{'"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "invalid syntax" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_comprehension_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ('[' | '(' | '{') starred_expression for_if_clauses
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('[' | '(' | '{') starred_expression for_if_clauses"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "iterable unpacking cannot be used in comprehension" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_dict_comprehension_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '{' '**' bitwise_or for_if_clauses '}'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_dict_comprehension[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{' '**' bitwise_or for_if_clauses '}'"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "dict unpacking cannot be used in dict comprehension" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_parameters_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // param_no_default* (slash_with_default | param_with_default+) param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default* (slash_with_default | param_with_default+) param_no_default"));
_res = RAISE_SYNTAX_ERROR ( "non-default argument follows default argument" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_lambda_parameters_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // lambda_param_no_default* (lambda_slash_with_default | lambda_param_with_default+) lambda_param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_lambda_parameters[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default* (lambda_slash_with_default | lambda_param_with_default+) lambda_param_no_default"));
_res = RAISE_SYNTAX_ERROR ( "non-default argument follows default argument" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_star_etc_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '*' (')' | ',' (')' | '**'))
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (')' | ',' (')' | '**'))"));
_res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // '*' ',' TYPE_COMMENT
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' ',' TYPE_COMMENT"));
_res = RAISE_SYNTAX_ERROR ( "bare * has associated type comment" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_lambda_star_etc_rule(Parser *p)
{
- D(p->level++);
- if (p->error_indicator) {
- D(p->level--);
- return NULL;
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
+ if (p->error_indicator) {
+ p->level--;
+ return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '*' (':' | ',' (':' | '**'))
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_lambda_star_etc[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'*' (':' | ',' (':' | '**'))"));
_res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_double_type_comments_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_double_type_comments[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT"));
_res = RAISE_SYNTAX_ERROR ( "Cannot have two type comments on def" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_with_item_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // expression 'as' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_with_item[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression 'as' expression"));
_res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_for_target_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ASYNC? 'for' star_expressions
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_for_target[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC? 'for' star_expressions"));
_res = RAISE_SYNTAX_ERROR_INVALID_TARGET ( FOR_TARGETS , a );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_group_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '(' starred_expression ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_group[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' starred_expression ')'"));
_res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "can't use starred expression here" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
invalid_import_from_targets_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // import_from_as_names ',' NEWLINE
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> invalid_import_from_targets[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_names ',' NEWLINE"));
_res = RAISE_SYNTAX_ERROR ( "trailing comma not allowed without surrounding parentheses" );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_1_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // NEWLINE
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_1[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_1_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_2_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // NEWLINE
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_2[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_2_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_4_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_4[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_4_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_3_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // expression _loop0_4
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_3[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_4"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_6_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_6[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_6_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_5_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // expression _loop0_6
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_5[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_6"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_8_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_8[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_8_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_7_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // expression _loop0_8
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_7[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_8"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_10_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_10[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_10_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_9_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // expression _loop0_10
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_9[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression _loop0_10"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop1_11_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // statement
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_11[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "statement"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_11_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_13_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ';' small_stmt
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_13[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';' small_stmt"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_13_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_12_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // small_stmt _loop0_13
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_12[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "small_stmt _loop0_13"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_14_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'import'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'import'"));
}
{ // 'from'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_14[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from'"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_15_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'def'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'def'"));
}
{ // '@'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));
}
{ // ASYNC
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_15[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_16_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'class'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'class'"));
}
{ // '@'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_16[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@'"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_17_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'with'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'with'"));
}
{ // ASYNC
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_17[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_18_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'for'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'for'"));
}
{ // ASYNC
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_18[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "ASYNC"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_19_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '=' annotated_rhs
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_19[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
_res = d;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_20_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '(' single_target ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_20[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' single_target ')'"));
_res = b;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
{ // single_subscript_attribute_target
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_20[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "single_subscript_attribute_target"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_21_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '=' annotated_rhs
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_21[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'=' annotated_rhs"));
_res = d;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop1_22_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // (star_targets '=')
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_22[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_22_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static void *
_tmp_23_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // yield_expr
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
}
{ // star_expressions
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_23[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_24_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // yield_expr
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
}
{ // star_expressions
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_24[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_26_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_26[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_26_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_25_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // NAME _loop0_26
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_25[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_26"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_28_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_28[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' NAME"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_28_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_27_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // NAME _loop0_28
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_27[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME _loop0_28"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_29_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ',' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_29[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
_res = z;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_30_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ';'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "';'"));
}
{ // NEWLINE
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_30[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_31_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ('.' | '...')
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_31[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_31_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_32_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ('.' | '...')
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_32[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('.' | '...')"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_32_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_34_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' import_from_as_name
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_34[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' import_from_as_name"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_34_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_33_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // import_from_as_name _loop0_34
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_33[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "import_from_as_name _loop0_34"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_35_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'as' NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_35[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
_res = z;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_37_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' dotted_as_name
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_37[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' dotted_as_name"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_37_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_36_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // dotted_as_name _loop0_37
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_36[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dotted_as_name _loop0_37"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_38_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'as' NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_38[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
_res = z;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_40_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' with_item
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_40[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_40_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_39_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // with_item _loop0_40
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_39[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_40"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_42_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' with_item
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_42[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_42_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_41_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // with_item _loop0_42
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_41[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_42"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_44_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' with_item
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_44[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_44_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_43_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // with_item _loop0_44
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_43[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_44"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_46_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' with_item
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_46[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' with_item"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_46_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_45_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // with_item _loop0_46
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_45[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "with_item _loop0_46"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_47_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ','
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','"));
}
{ // ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
}
{ // ':'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_47[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop1_48_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // except_block
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_48[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "except_block"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_48_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static void *
_tmp_49_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'as' NAME
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_49[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'as' NAME"));
_res = z;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_50_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'from' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_50[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'from' expression"));
_res = z;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_51_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '->' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_51[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));
_res = z;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_52_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '->' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_52[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'->' expression"));
_res = z;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_53_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // NEWLINE INDENT
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_53[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NEWLINE INDENT"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_54_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_54[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_54_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_55_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_55[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_55_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_56_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_56[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_56_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_57_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_57[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_57_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_58_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_58[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_58_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_59_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_59[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_59_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_60_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_60[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_60_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_61_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_61[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_61_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_62_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_62[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_62_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_63_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_63[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_63_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_64_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_64[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_64_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_65_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_65[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_65_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_66_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_maybe_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_66[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_66_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_67_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_maybe_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_67[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_maybe_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_67_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_68_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ('@' named_expression NEWLINE)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_68[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('@' named_expression NEWLINE)"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_68_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static void *
_tmp_69_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '(' arguments? ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_69[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'(' arguments? ')'"));
_res = z;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop1_70_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // (',' star_expression)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_70[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_expression)"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_70_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_72_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' star_named_expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_72[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_named_expression"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_72_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_71_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // star_named_expression _loop0_72
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_71[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression _loop0_72"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop1_73_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // (',' expression)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_73[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' expression)"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_73_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_74_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_74[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_74_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_75_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_75[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_75_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_76_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_76[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_76_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_77_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_77[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_77_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_78_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_78[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_78_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_79_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_79[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_79_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_80_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_80[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_80_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_81_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_81_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_82_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_82_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_83_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_83[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_83_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_84_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_84[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_84_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_85_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_85[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_85_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_86_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_maybe_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_86[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_86_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_87_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_maybe_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_87[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_maybe_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_87_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_88_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ('or' conjunction)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_88[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('or' conjunction)"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_88_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_89_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ('and' inversion)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_89[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('and' inversion)"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_89_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_90_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // compare_op_bitwise_or_pair
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_90[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "compare_op_bitwise_or_pair"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_90_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static void *
_tmp_91_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '!='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_91[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'!='"));
_res = _PyPegen_check_barry_as_flufl ( p , tok ) ? NULL : tok;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_93_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' slice
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_93[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' slice"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_93_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_92_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // slice _loop0_93
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_92[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slice _loop0_93"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_94_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ':' expression?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_94[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':' expression?"));
_res = d;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_95_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // tuple
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "tuple"));
}
{ // group
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "group"));
}
{ // genexp
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_95[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "genexp"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_96_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // list
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "list"));
}
{ // listcomp
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_96[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "listcomp"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_97_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // dict
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dict"));
}
{ // set
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "set"));
}
{ // dictcomp
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "dictcomp"));
}
{ // setcomp
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_97[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "setcomp"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop1_98_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // STRING
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_98[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "STRING"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_98_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static void *
_tmp_99_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // star_named_expression ',' star_named_expressions?
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_99[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expression ',' star_named_expressions?"));
_res = _PyPegen_seq_insert_in_front ( p , y , z );
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_100_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // yield_expr
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
}
{ // named_expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_100[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_102_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' double_starred_kvpair
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_102[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' double_starred_kvpair"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_102_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_101_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // double_starred_kvpair _loop0_102
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_101[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "double_starred_kvpair _loop0_102"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop1_103_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // for_if_clause
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_103[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "for_if_clause"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_103_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_104_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ('if' disjunction)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_104[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_104_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_105_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ('if' disjunction)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_105[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "('if' disjunction)"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_105_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_107_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' (starred_expression | named_expression !'=')
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_107[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (starred_expression | named_expression !'=')"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_107_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_106_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // (starred_expression | named_expression !'=') _loop0_107
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_106[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(starred_expression | named_expression !'=') _loop0_107"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_108_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ',' kwargs
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_108[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwargs"));
_res = k;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_110_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' kwarg_or_starred
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_110[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_110_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_109_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // kwarg_or_starred _loop0_110
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_109[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_110"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_112_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' kwarg_or_double_starred
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_112[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_112_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_111_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // kwarg_or_double_starred _loop0_112
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_111[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_112"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_114_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' kwarg_or_starred
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_114[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_starred"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_114_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_113_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // kwarg_or_starred _loop0_114
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_113[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_starred _loop0_114"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_116_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' kwarg_or_double_starred
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_116[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' kwarg_or_double_starred"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_116_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_115_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // kwarg_or_double_starred _loop0_116
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_115[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "kwarg_or_double_starred _loop0_116"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_117_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // (',' star_target)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_117[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_117_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_119_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' star_target
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_119[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_119_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_118_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // star_target _loop0_119
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_118[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_target _loop0_119"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop1_120_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // (',' star_target)
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_120[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(',' star_target)"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_120_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static void *
_tmp_121_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // !'*' star_target
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_121[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "!'*' star_target"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_123_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // ',' del_target
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_123[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' del_target"));
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
if (_n == _children_capacity) {
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_123_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_gather_122_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq * _res = NULL;
int _mark = p->mark;
{ // del_target _loop0_123
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _gather_122[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "del_target _loop0_123"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_124_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // args
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "args"));
}
{ // expression for_if_clauses
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_124[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "expression for_if_clauses"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_125_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // NAME '='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_125[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "NAME '='"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_126_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // star_named_expressions
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_126[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_named_expressions"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_126_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_127_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // (star_targets '=')
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_127[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_127_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop0_128_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // (star_targets '=')
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_128[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "(star_targets '=')"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_128_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static void *
_tmp_129_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // yield_expr
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "yield_expr"));
}
{ // star_expressions
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_129[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_expressions"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_130_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '['
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'['"));
}
{ // '('
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'('"));
}
{ // '{'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_130[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'{'"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_131_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_131[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_131_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static void *
_tmp_132_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // slash_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "slash_with_default"));
}
{ // param_with_default+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_132[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default+"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop0_133_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_no_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop0_133[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_no_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop0_133_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static void *
_tmp_134_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // lambda_slash_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_slash_with_default"));
}
{ // lambda_param_with_default+
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_134[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default+"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_135_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
}
{ // ',' (')' | '**')
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_135[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (')' | '**')"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_136_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ':'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
}
{ // ',' (':' | '**')
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_136[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' (':' | '**')"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_137_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // star_targets '='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_137[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
_res = z;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_138_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '.'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
}
{ // '...'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_138[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_139_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '.'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'.'"));
}
{ // '...'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_139[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'...'"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_140_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // '@' named_expression NEWLINE
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_140[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'@' named_expression NEWLINE"));
_res = f;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_141_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ',' star_expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_141[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_expression"));
_res = c;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_142_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ',' expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_142[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' expression"));
_res = c;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_143_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'or' conjunction
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_143[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'or' conjunction"));
_res = c;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_144_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'and' inversion
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_144[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'and' inversion"));
_res = c;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_145_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'if' disjunction
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_145[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
_res = z;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_146_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // 'if' disjunction
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_146[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'if' disjunction"));
_res = z;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_147_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // starred_expression
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "starred_expression"));
}
{ // named_expression !'='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_147[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "named_expression !'='"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_148_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ',' star_target
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_148[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"));
_res = c;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_149_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ',' star_target
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_149[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' star_target"));
_res = c;
if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1;
- D(p->level--);
+ p->level--;
return NULL;
}
goto done;
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_150_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // star_targets '='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_150[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_151_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // star_targets '='
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_151[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "star_targets '='"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static asdl_seq *
_loop1_152_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_152[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_152_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static asdl_seq *
_loop1_153_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void *_res = NULL;
if (!_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
ssize_t _children_capacity = 1;
ssize_t _n = 0;
{ // lambda_param_with_default
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _loop1_153[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "lambda_param_with_default"));
if (!_new_children) {
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
_children = _new_children;
}
if (_n == 0 || p->error_indicator) {
PyMem_Free(_children);
- D(p->level--);
+ p->level--;
return NULL;
}
asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena);
PyMem_Free(_children);
p->error_indicator = 1;
PyErr_NoMemory();
- D(p->level--);
+ p->level--;
return NULL;
}
for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]);
PyMem_Free(_children);
_PyPegen_insert_memo(p, _start_mark, _loop1_153_type, _seq);
- D(p->level--);
+ p->level--;
return _seq;
}
static void *
_tmp_154_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ')'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "')'"));
}
{ // '**'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_154[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
static void *
_tmp_155_rule(Parser *p)
{
- D(p->level++);
+ if (p->level++ == MAXSTACK) {
+ p->error_indicator = 1;
+ PyErr_NoMemory();
+ }
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
void * _res = NULL;
int _mark = p->mark;
{ // ':'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "':'"));
}
{ // '**'
if (p->error_indicator) {
- D(p->level--);
+ p->level--;
return NULL;
}
D(fprintf(stderr, "%*c> _tmp_155[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'**'"));
}
_res = NULL;
done:
- D(p->level--);
+ p->level--;
return _res;
}
projects / thirdparty / Python / cpython.git / commitdiff
