#include <Python.h>

#include "pycore_ast.h" // _PyAST_Validate(),

#include <errcode.h>

#include "tokenizer.h"

#include "pegen.h"

#include "string_parser.h"

PyObject *

_PyPegen_new_type_comment(Parser *p, const char *s)

{

PyObject *res = PyUnicode_DecodeUTF8(s, strlen(s), NULL);

if (res == NULL) {

return NULL;

}

if (_PyArena_AddPyObject(p->arena, res) < 0) {

Py_DECREF(res);

return NULL;

}

return res;

}

arg_ty

_PyPegen_add_type_comment_to_arg(Parser *p, arg_ty a, Token *tc)

{

if (tc == NULL) {

return a;

}

const char *bytes = PyBytes_AsString(tc->bytes);

if (bytes == NULL) {

return NULL;

}

PyObject *tco = _PyPegen_new_type_comment(p, bytes);

if (tco == NULL) {

return NULL;

}

return _PyAST_arg(a->arg, a->annotation, tco,

a->lineno, a->col_offset, a->end_lineno, a->end_col_offset,

p->arena);

}

static int

init_normalization(Parser *p)

{

if (p->normalize) {

return 1;

}

PyObject *m = PyImport_ImportModuleNoBlock("unicodedata");

if (!m)

{

return 0;

}

p->normalize = PyObject_GetAttrString(m, "normalize");

Py_DECREF(m);

if (!p->normalize)

{

return 0;

}

return 1;

}

/* Checks if the NOTEQUAL token is valid given the current parser flags

0 indicates success and nonzero indicates failure (an exception may be set) */

int

_PyPegen_check_barry_as_flufl(Parser *p, Token* t) {

assert(t->bytes != NULL);

assert(t->type == NOTEQUAL);

const char* tok_str = PyBytes_AS_STRING(t->bytes);

if (p->flags & PyPARSE_BARRY_AS_BDFL && strcmp(tok_str, "<>") != 0) {

RAISE_SYNTAX_ERROR("with Barry as BDFL, use '<>' instead of '!='");

return -1;

}

if (!(p->flags & PyPARSE_BARRY_AS_BDFL)) {

return strcmp(tok_str, "!=");

}

return 0;

}

int

_PyPegen_check_legacy_stmt(Parser *p, expr_ty name) {

assert(name->kind == Name_kind);

const char* candidates[2] = {"print", "exec"};

for (int i=0; i<2; i++) {

if (PyUnicode_CompareWithASCIIString(name->v.Name.id, candidates[i]) == 0) {

return 1;

}

}

return 0;

}

PyObject *

_PyPegen_new_identifier(Parser *p, const char *n)

{

PyObject *id = PyUnicode_DecodeUTF8(n, strlen(n), NULL);

if (!id) {

goto error;

}

/* PyUnicode_DecodeUTF8 should always return a ready string. */

assert(PyUnicode_IS_READY(id));

/* Check whether there are non-ASCII characters in the

identifier; if so, normalize to NFKC. */

if (!PyUnicode_IS_ASCII(id))

{

PyObject *id2;

if (!init_normalization(p))

{

Py_DECREF(id);

goto error;

}

PyObject *form = PyUnicode_InternFromString("NFKC");

if (form == NULL)

{

Py_DECREF(id);

goto error;

}

PyObject *args[2] = {form, id};

id2 = _PyObject_FastCall(p->normalize, args, 2);

Py_DECREF(id);

Py_DECREF(form);

if (!id2) {

goto error;

}

if (!PyUnicode_Check(id2))

{

PyErr_Format(PyExc_TypeError,

"unicodedata.normalize() must return a string, not "

"%.200s",

_PyType_Name(Py_TYPE(id2)));

Py_DECREF(id2);

goto error;

}

id = id2;

}

PyUnicode_InternInPlace(&id);

if (_PyArena_AddPyObject(p->arena, id) < 0)

{

Py_DECREF(id);

goto error;

}

return id;

error:

p->error_indicator = 1;

return NULL;

}

static PyObject *

_create_dummy_identifier(Parser *p)

{

return _PyPegen_new_identifier(p, "");

}

const char *

_PyPegen_get_expr_name(expr_ty e)

{

assert(e != NULL);

switch (e->kind) {

case Attribute_kind:

return "attribute";

case Subscript_kind:

return "subscript";

case Starred_kind:

return "starred";

case Name_kind:

return "name";

case List_kind:

return "list";

case Tuple_kind:

return "tuple";

case Lambda_kind:

return "lambda";

case Call_kind:

return "function call";

case BoolOp_kind:

case BinOp_kind:

case UnaryOp_kind:

return "expression";

case GeneratorExp_kind:

return "generator expression";

case Yield_kind:

case YieldFrom_kind:

return "yield expression";

case Await_kind:

return "await expression";

case ListComp_kind:

return "list comprehension";

case SetComp_kind:

return "set comprehension";

case DictComp_kind:

return "dict comprehension";

case Dict_kind:

return "dict literal";

case Set_kind:

return "set display";

case JoinedStr_kind:

case FormattedValue_kind:

return "f-string expression";

case Constant_kind: {

PyObject *value = e->v.Constant.value;

if (value == Py_None) {

return "None";

}

if (value == Py_False) {

return "False";

}

if (value == Py_True) {

return "True";

}

if (value == Py_Ellipsis) {

return "ellipsis";

}

return "literal";

}

case Compare_kind:

return "comparison";

case IfExp_kind:

return "conditional expression";

case NamedExpr_kind:

return "named expression";

default:

PyErr_Format(PyExc_SystemError,

"unexpected expression in assignment %d (line %d)",

e->kind, e->lineno);

return NULL;

}

}

static int

raise_decode_error(Parser *p)

{

assert(PyErr_Occurred());

const char *errtype = NULL;

if (PyErr_ExceptionMatches(PyExc_UnicodeError)) {

errtype = "unicode error";

}

else if (PyErr_ExceptionMatches(PyExc_ValueError)) {

errtype = "value error";

}

if (errtype) {

PyObject *type;

PyObject *value;

PyObject *tback;

PyObject *errstr;

PyErr_Fetch(&type, &value, &tback);

errstr = PyObject_Str(value);

if (errstr) {

RAISE_SYNTAX_ERROR("(%s) %U", errtype, errstr);

Py_DECREF(errstr);

}

else {

PyErr_Clear();

RAISE_SYNTAX_ERROR("(%s) unknown error", errtype);

}

Py_XDECREF(type);

Py_XDECREF(value);

Py_XDECREF(tback);

}

return -1;

}

static inline void

raise_unclosed_parentheses_error(Parser *p) {

int error_lineno = p->tok->parenlinenostack[p->tok->level-1];

int error_col = p->tok->parencolstack[p->tok->level-1];

RAISE_ERROR_KNOWN_LOCATION(p, PyExc_SyntaxError,

error_lineno, error_col, error_lineno, -1,

"'%c' was never closed",

p->tok->parenstack[p->tok->level-1]);

}

static void

raise_tokenizer_init_error(PyObject *filename)

{

if (!(PyErr_ExceptionMatches(PyExc_LookupError)

|| PyErr_ExceptionMatches(PyExc_SyntaxError)

|| PyErr_ExceptionMatches(PyExc_ValueError)

|| PyErr_ExceptionMatches(PyExc_UnicodeDecodeError))) {

return;

}

PyObject *errstr = NULL;

PyObject *tuple = NULL;

PyObject *type;

PyObject *value;

PyObject *tback;

PyErr_Fetch(&type, &value, &tback);

errstr = PyObject_Str(value);

if (!errstr) {

goto error;

}

PyObject *tmp = Py_BuildValue("(OiiO)", filename, 0, -1, Py_None);

if (!tmp) {

goto error;

}

tuple = PyTuple_Pack(2, errstr, tmp);

Py_DECREF(tmp);

if (!value) {

goto error;

}

PyErr_SetObject(PyExc_SyntaxError, tuple);

error:

Py_XDECREF(type);

Py_XDECREF(value);

Py_XDECREF(tback);

Py_XDECREF(errstr);

Py_XDECREF(tuple);

}

static int

tokenizer_error(Parser *p)

{

if (PyErr_Occurred()) {

return -1;

}

const char *msg = NULL;

PyObject* errtype = PyExc_SyntaxError;

Py_ssize_t col_offset = -1;

switch (p->tok->done) {

case E_TOKEN:

msg = "invalid token";

break;

case E_EOF:

if (p->tok->level) {

raise_unclosed_parentheses_error(p);

} else {

RAISE_SYNTAX_ERROR("unexpected EOF while parsing");

}

return -1;

case E_DEDENT:

RAISE_INDENTATION_ERROR("unindent does not match any outer indentation level");

return -1;

case E_INTR:

if (!PyErr_Occurred()) {

PyErr_SetNone(PyExc_KeyboardInterrupt);

}

return -1;

case E_NOMEM:

PyErr_NoMemory();

return -1;

case E_TABSPACE:

errtype = PyExc_TabError;

msg = "inconsistent use of tabs and spaces in indentation";

break;

case E_TOODEEP:

errtype = PyExc_IndentationError;

msg = "too many levels of indentation";

break;

case E_LINECONT: {

char* loc = strrchr(p->tok->buf, '\n');

const char* last_char = p->tok->cur - 1;

if (loc != NULL && loc != last_char) {

col_offset = p->tok->cur - loc - 1;

p->tok->buf = loc;

} else {

col_offset = last_char - p->tok->buf - 1;

}

msg = "unexpected character after line continuation character";

break;

}

default:

msg = "unknown parsing error";

}

RAISE_ERROR_KNOWN_LOCATION(p, errtype, p->tok->lineno, col_offset, p->tok->lineno, -1, msg);

return -1;

}

void *

_PyPegen_raise_error(Parser *p, PyObject *errtype, const char *errmsg, ...)

{

Token *t = p->known_err_token != NULL ? p->known_err_token : p->tokens[p->fill - 1];

Py_ssize_t col_offset;

Py_ssize_t end_col_offset = -1;

if (t->col_offset == -1) {

col_offset = Py_SAFE_DOWNCAST(p->tok->cur - p->tok->buf,

intptr_t, int);

} else {

col_offset = t->col_offset + 1;

}

if (t->end_col_offset != -1) {

end_col_offset = t->end_col_offset + 1;

}

va_list va;

va_start(va, errmsg);

_PyPegen_raise_error_known_location(p, errtype, t->lineno, col_offset, t->end_lineno, end_col_offset, errmsg, va);

va_end(va);

return NULL;

}

static PyObject *

get_error_line(Parser *p, Py_ssize_t lineno)

{

/* If the file descriptor is interactive, the source lines of the current

* (multi-line) statement are stored in p->tok->interactive_src_start.

* If not, we're parsing from a string, which means that the whole source

* is stored in p->tok->str. */

assert(p->tok->fp == NULL || p->tok->fp == stdin);

char *cur_line = p->tok->fp_interactive ? p->tok->interactive_src_start : p->tok->str;

for (int i = 0; i < lineno - 1; i++) {

cur_line = strchr(cur_line, '\n') + 1;

}

char *next_newline;

if ((next_newline = strchr(cur_line, '\n')) == NULL) { // This is the last line

next_newline = cur_line + strlen(cur_line);

}

return PyUnicode_DecodeUTF8(cur_line, next_newline - cur_line, "replace");

}

Py_ssize_t

_PyPegen_byte_offset_to_character_offset(PyObject *line, Py_ssize_t col_offset)

{

const char *str = PyUnicode_AsUTF8(line);

if (!str) {

return -1;

}

Py_ssize_t len = strlen(str);

if (col_offset > len + 1) {

col_offset = len + 1;

}

assert(col_offset >= 0);

PyObject *text = PyUnicode_DecodeUTF8(str, col_offset, "replace");

if (!text) {

return -1;

}

Py_ssize_t size = PyUnicode_GET_LENGTH(text);

Py_DECREF(text);

return size;

}

void *

_PyPegen_raise_error_known_location(Parser *p, PyObject *errtype,

Py_ssize_t lineno, Py_ssize_t col_offset,

Py_ssize_t end_lineno, Py_ssize_t end_col_offset,

const char *errmsg, va_list va)

{

PyObject *value = NULL;

PyObject *errstr = NULL;

PyObject *error_line = NULL;

PyObject *tmp = NULL;

p->error_indicator = 1;

if (end_lineno == CURRENT_POS) {

end_lineno = p->tok->lineno;

}

if (end_col_offset == CURRENT_POS) {

end_col_offset = p->tok->cur - p->tok->line_start;

}

if (p->start_rule == Py_fstring_input) {

const char *fstring_msg = "f-string: ";

Py_ssize_t len = strlen(fstring_msg) + strlen(errmsg);

char *new_errmsg = PyMem_Malloc(len + 1); // Lengths of both strings plus NULL character

if (!new_errmsg) {

return (void *) PyErr_NoMemory();

}

// Copy both strings into new buffer

memcpy(new_errmsg, fstring_msg, strlen(fstring_msg));

memcpy(new_errmsg + strlen(fstring_msg), errmsg, strlen(errmsg));

new_errmsg[len] = 0;

errmsg = new_errmsg;

}

errstr = PyUnicode_FromFormatV(errmsg, va);

if (!errstr) {

goto error;

}

// PyErr_ProgramTextObject assumes that the text is utf-8 so we cannot call it with a file

// with an arbitrary encoding or otherwise we could get some badly decoded text.

int uses_utf8_codec = (!p->tok->encoding || strcmp(p->tok->encoding, "utf-8") == 0);

if (p->tok->fp_interactive) {

error_line = get_error_line(p, lineno);

}

else if (uses_utf8_codec && p->start_rule == Py_file_input) {

error_line = PyErr_ProgramTextObject(p->tok->filename, (int) lineno);

}

if (!error_line) {

/* PyErr_ProgramTextObject was not called or returned NULL. If it was not called,

then we need to find the error line from some other source, because

p->start_rule != Py_file_input. If it returned NULL, then it either unexpectedly

failed or we're parsing from a string or the REPL. There's a third edge case where

we're actually parsing from a file, which has an E_EOF SyntaxError and in that case

`PyErr_ProgramTextObject` fails because lineno points to last_file_line + 1, which

does not physically exist */

assert(p->tok->fp == NULL || p->tok->fp == stdin || p->tok->done == E_EOF || !uses_utf8_codec);

if (p->tok->lineno <= lineno) {

Py_ssize_t size = p->tok->inp - p->tok->buf;

error_line = PyUnicode_DecodeUTF8(p->tok->buf, size, "replace");

}

else {

error_line = get_error_line(p, lineno);

}

if (!error_line) {

goto error;

}

}

if (p->start_rule == Py_fstring_input) {

col_offset -= p->starting_col_offset;

end_col_offset -= p->starting_col_offset;

}

Py_ssize_t col_number = col_offset;

Py_ssize_t end_col_number = end_col_offset;

if (p->tok->encoding != NULL) {

col_number = _PyPegen_byte_offset_to_character_offset(error_line, col_offset);

if (col_number < 0) {

goto error;

}

if (end_col_number > 0) {

Py_ssize_t end_col_offset = _PyPegen_byte_offset_to_character_offset(error_line, end_col_number);

if (end_col_offset < 0) {

goto error;

} else {

end_col_number = end_col_offset;

}

}

}

tmp = Py_BuildValue("(OiiNii)", p->tok->filename, lineno, col_number, error_line, end_lineno, end_col_number);

if (!tmp) {

goto error;

}

value = PyTuple_Pack(2, errstr, tmp);

Py_DECREF(tmp);

if (!value) {

goto error;

}

PyErr_SetObject(errtype, value);

Py_DECREF(errstr);

Py_DECREF(value);

if (p->start_rule == Py_fstring_input) {

PyMem_Free((void *)errmsg);

}

return NULL;

error:

Py_XDECREF(errstr);

Py_XDECREF(error_line);

if (p->start_rule == Py_fstring_input) {

PyMem_Free((void *)errmsg);

}

return NULL;

}

#if 0

static const char *

token_name(int type)

{

if (0 <= type && type <= N_TOKENS) {

return _PyParser_TokenNames[type];

}

return "<Huh?>";

}

#endif

// Here, mark is the start of the node, while p->mark is the end.

// If node==NULL, they should be the same.

int

_PyPegen_insert_memo(Parser *p, int mark, int type, void *node)

{

// Insert in front

Memo *m = _PyArena_Malloc(p->arena, sizeof(Memo));

if (m == NULL) {

return -1;

}

m->type = type;

m->node = node;

m->mark = p->mark;

m->next = p->tokens[mark]->memo;

p->tokens[mark]->memo = m;

return 0;

}

// Like _PyPegen_insert_memo(), but updates an existing node if found.

int

_PyPegen_update_memo(Parser *p, int mark, int type, void *node)

{

for (Memo *m = p->tokens[mark]->memo; m != NULL; m = m->next) {

if (m->type == type) {

// Update existing node.

m->node = node;

m->mark = p->mark;

return 0;

}

}

// Insert new node.

return _PyPegen_insert_memo(p, mark, type, node);

}

// Return dummy NAME.

void *

_PyPegen_dummy_name(Parser *p, ...)

{

static void *cache = NULL;

if (cache != NULL) {

return cache;

}

PyObject *id = _create_dummy_identifier(p);

if (!id) {

return NULL;

}

cache = _PyAST_Name(id, Load, 1, 0, 1, 0, p->arena);

return cache;

}

static int

_get_keyword_or_name_type(Parser *p, const char *name, int name_len)

{

assert(name_len > 0);

if (name_len >= p->n_keyword_lists ||

p->keywords[name_len] == NULL ||

p->keywords[name_len]->type == -1) {

return NAME;

}

for (KeywordToken *k = p->keywords[name_len]; k != NULL && k->type != -1; k++) {

if (strncmp(k->str, name, name_len) == 0) {

return k->type;

}

}

return NAME;

}

static int

growable_comment_array_init(growable_comment_array *arr, size_t initial_size) {

assert(initial_size > 0);

arr->items = PyMem_Malloc(initial_size * sizeof(*arr->items));

arr->size = initial_size;

arr->num_items = 0;

return arr->items != NULL;

}

static int

growable_comment_array_add(growable_comment_array *arr, int lineno, char *comment) {

if (arr->num_items >= arr->size) {

size_t new_size = arr->size * 2;

void *new_items_array = PyMem_Realloc(arr->items, new_size * sizeof(*arr->items));

if (!new_items_array) {

return 0;

}

arr->items = new_items_array;

arr->size = new_size;

}

arr->items[arr->num_items].lineno = lineno;

arr->items[arr->num_items].comment = comment; // Take ownership

arr->num_items++;

return 1;

}

static void

growable_comment_array_deallocate(growable_comment_array *arr) {

for (unsigned i = 0; i < arr->num_items; i++) {

PyMem_Free(arr->items[i].comment);

}

PyMem_Free(arr->items);

}

static int

initialize_token(Parser *p, Token *token, const char *start, const char *end, int token_type) {

assert(token != NULL);

token->type = (token_type == NAME) ? _get_keyword_or_name_type(p, start, (int)(end - start)) : token_type;

token->bytes = PyBytes_FromStringAndSize(start, end - start);

if (token->bytes == NULL) {

return -1;

}

if (_PyArena_AddPyObject(p->arena, token->bytes) < 0) {

Py_DECREF(token->bytes);

return -1;

}

const char *line_start = token_type == STRING ? p->tok->multi_line_start : p->tok->line_start;

int lineno = token_type == STRING ? p->tok->first_lineno : p->tok->lineno;

int end_lineno = p->tok->lineno;

int col_offset = (start != NULL && start >= line_start) ? (int)(start - line_start) : -1;

int end_col_offset = (end != NULL && end >= p->tok->line_start) ? (int)(end - p->tok->line_start) : -1;

token->lineno = p->starting_lineno + lineno;

token->col_offset = p->tok->lineno == 1 ? p->starting_col_offset + col_offset : col_offset;

token->end_lineno = p->starting_lineno + end_lineno;

token->end_col_offset = p->tok->lineno == 1 ? p->starting_col_offset + end_col_offset : end_col_offset;

p->fill += 1;

if (token_type == ERRORTOKEN && p->tok->done == E_DECODE) {

return raise_decode_error(p);

}

return (token_type == ERRORTOKEN ? tokenizer_error(p) : 0);

}

static int

_resize_tokens_array(Parser *p) {

int newsize = p->size * 2;

Token **new_tokens = PyMem_Realloc(p->tokens, newsize * sizeof(Token *));

if (new_tokens == NULL) {

PyErr_NoMemory();

return -1;

}

p->tokens = new_tokens;

for (int i = p->size; i < newsize; i++) {

p->tokens[i] = PyMem_Calloc(1, sizeof(Token));

if (p->tokens[i] == NULL) {

p->size = i; // Needed, in order to cleanup correctly after parser fails

PyErr_NoMemory();

return -1;

}

}

p->size = newsize;

return 0;

}

int

_PyPegen_fill_token(Parser *p)

{

const char *start;

const char *end;

int type = _PyTokenizer_Get(p->tok, &start, &end);

// Record and skip '# type: ignore' comments

while (type == TYPE_IGNORE) {

Py_ssize_t len = end - start;

char *tag = PyMem_Malloc(len + 1);

if (tag == NULL) {

PyErr_NoMemory();

return -1;

}

strncpy(tag, start, len);

tag[len] = '\0';

// Ownership of tag passes to the growable array

if (!growable_comment_array_add(&p->type_ignore_comments, p->tok->lineno, tag)) {

PyErr_NoMemory();

return -1;

}

type = _PyTokenizer_Get(p->tok, &start, &end);

}

// If we have reached the end and we are in single input mode we need to insert a newline and reset the parsing

if (p->start_rule == Py_single_input && type == ENDMARKER && p->parsing_started) {

type = NEWLINE; /* Add an extra newline */

p->parsing_started = 0;

if (p->tok->indent && !(p->flags & PyPARSE_DONT_IMPLY_DEDENT)) {

p->tok->pendin = -p->tok->indent;

p->tok->indent = 0;

}

}

else {

p->parsing_started = 1;

}

// Check if we are at the limit of the token array capacity and resize if needed

if ((p->fill == p->size) && (_resize_tokens_array(p) != 0)) {

return -1;

}

Token *t = p->tokens[p->fill];

return initialize_token(p, t, start, end, type);

}

#if defined(Py_DEBUG)

// Instrumentation to count the effectiveness of memoization.

// The array counts the number of tokens skipped by memoization,

// indexed by type.

#define NSTATISTICS 2000

static long memo_statistics[NSTATISTICS];

void

_PyPegen_clear_memo_statistics()

{

for (int i = 0; i < NSTATISTICS; i++) {

memo_statistics[i] = 0;

}

}

PyObject *

_PyPegen_get_memo_statistics()

{

PyObject *ret = PyList_New(NSTATISTICS);

if (ret == NULL) {

return NULL;

}

for (int i = 0; i < NSTATISTICS; i++) {

PyObject *value = PyLong_FromLong(memo_statistics[i]);

if (value == NULL) {

Py_DECREF(ret);

return NULL;

}

// PyList_SetItem borrows a reference to value.

if (PyList_SetItem(ret, i, value) < 0) {

Py_DECREF(ret);

return NULL;

}

}

return ret;

}

#endif

int // bool

_PyPegen_is_memoized(Parser *p, int type, void *pres)

{

if (p->mark == p->fill) {

if (_PyPegen_fill_token(p) < 0) {

p->error_indicator = 1;

return -1;

}

}

Token *t = p->tokens[p->mark];

for (Memo *m = t->memo; m != NULL; m = m->next) {

if (m->type == type) {

#if defined(PY_DEBUG)

if (0 <= type && type < NSTATISTICS) {

long count = m->mark - p->mark;

// A memoized negative result counts for one.

if (count <= 0) {

count = 1;

}

memo_statistics[type] += count;

}

#endif

p->mark = m->mark;

*(void **)(pres) = m->node;

return 1;

}

}

return 0;

}

int

_PyPegen_lookahead_with_name(int positive, expr_ty (func)(Parser *), Parser *p)

{

int mark = p->mark;

void *res = func(p);

p->mark = mark;

return (res != NULL) == positive;

}

int

_PyPegen_lookahead_with_string(int positive, expr_ty (func)(Parser *, const char*), Parser *p, const char* arg)

{

int mark = p->mark;

void *res = func(p, arg);

p->mark = mark;

return (res != NULL) == positive;

}

int

_PyPegen_lookahead_with_int(int positive, Token *(func)(Parser *, int), Parser *p, int arg)

{

int mark = p->mark;

void *res = func(p, arg);

p->mark = mark;

return (res != NULL) == positive;

}

int

_PyPegen_lookahead(int positive, void *(func)(Parser *), Parser *p)

{

int mark = p->mark;

void *res = (void*)func(p);

p->mark = mark;

return (res != NULL) == positive;

}

Token *

_PyPegen_expect_token(Parser *p, int type)

{

if (p->mark == p->fill) {

if (_PyPegen_fill_token(p) < 0) {

p->error_indicator = 1;

return NULL;

}

}

Token *t = p->tokens[p->mark];

if (t->type != type) {

return NULL;

}

p->mark += 1;

return t;

}

void*

_PyPegen_expect_forced_result(Parser *p, void* result, const char* expected) {

if (p->error_indicator == 1) {

return NULL;

}

if (result == NULL) {

RAISE_SYNTAX_ERROR("expected (%s)", expected);

return NULL;

}

return result;

}

Token *

_PyPegen_expect_forced_token(Parser *p, int type, const char* expected) {

if (p->error_indicator == 1) {

return NULL;

}

if (p->mark == p->fill) {

if (_PyPegen_fill_token(p) < 0) {

p->error_indicator = 1;

return NULL;

}

}

Token *t = p->tokens[p->mark];

if (t->type != type) {

RAISE_SYNTAX_ERROR_KNOWN_LOCATION(t, "expected '%s'", expected);

return NULL;

}

p->mark += 1;

return t;

}

expr_ty

_PyPegen_expect_soft_keyword(Parser *p, const char *keyword)

{

if (p->mark == p->fill) {

if (_PyPegen_fill_token(p) < 0) {

p->error_indicator = 1;

return NULL;

}

}

Token *t = p->tokens[p->mark];

if (t->type != NAME) {

return NULL;

}

const char *s = PyBytes_AsString(t->bytes);

if (!s) {

p->error_indicator = 1;

return NULL;

}

if (strcmp(s, keyword) != 0) {

return NULL;

}

return _PyPegen_name_token(p);

}

Token *

_PyPegen_get_last_nonnwhitespace_token(Parser *p)

{

assert(p->mark >= 0);

Token *token = NULL;

for (int m = p->mark - 1; m >= 0; m--) {

token = p->tokens[m];

if (token->type != ENDMARKER && (token->type < NEWLINE || token->type > DEDENT)) {

break;

}

}

return token;

}

static expr_ty

_PyPegen_name_from_token(Parser *p, Token* t)

{

if (t == NULL) {

return NULL;

}

const char *s = PyBytes_AsString(t->bytes);

if (!s) {

p->error_indicator = 1;

return NULL;

}

PyObject *id = _PyPegen_new_identifier(p, s);

if (id == NULL) {

p->error_indicator = 1;

return NULL;

}

return _PyAST_Name(id, Load, t->lineno, t->col_offset, t->end_lineno,

t->end_col_offset, p->arena);

}