motiejus/zig0
1
Fork 0
Code Releases Activity

replace TOKENIZER_TAG_ with TOKEN_

Browse Source
This commit is contained in:
Motiejus Jakštys
2024-12-30 22:38:17 +02:00
parent d551ba3d12
commit 3264d1747e
5 changed files with 511 additions and 511 deletions
Download Patch File Download Diff File Expand all files Collapse all files

244
parser.c
View File

@@ -74,12 +74,12 @@ static AstTokenIndex eatToken(Parser* p, TokenizerTag tag, bool* ok) {
static void eatDocComments(Parser* p) {
bool ok;
while (eatToken(p, TOKENIZER_TAG_DOC_COMMENT, &ok), ok) { }
while (eatToken(p, TOKEN_DOC_COMMENT, &ok), ok) { }
}
static void expectSemicolon(Parser* p) {
bool ok;
eatToken(p, TOKENIZER_TAG_SEMICOLON, &ok);
eatToken(p, TOKEN_SEMICOLON, &ok);
if (ok)
return;
@@ -126,7 +126,7 @@ static AstNodeIndex addExtra(Parser* p, const AstNodeIndex* extra, uint32_t coun
static AstNodeIndex parseByteAlign(Parser* p) {
bool ok;
eatToken(p, TOKENIZER_TAG_KEYWORD_ALIGN, &ok);
eatToken(p, TOKEN_KEYWORD_ALIGN, &ok);
if (!ok)
return null_node;
fprintf(stderr, "parseByteAlign cannot parse alginment\n");
@@ -136,7 +136,7 @@ static AstNodeIndex parseByteAlign(Parser* p) {
static AstNodeIndex parseAddrSpace(Parser* p) {
bool ok;
eatToken(p, TOKENIZER_TAG_KEYWORD_ADDRSPACE, &ok);
eatToken(p, TOKEN_KEYWORD_ADDRSPACE, &ok);
if (!ok)
return null_node;
fprintf(stderr, "parseAddrSpace cannot parse addrspace\n");
@@ -146,7 +146,7 @@ static AstNodeIndex parseAddrSpace(Parser* p) {
static AstNodeIndex parseLinkSection(Parser* p) {
bool ok;
eatToken(p, TOKENIZER_TAG_KEYWORD_LINKSECTION, &ok);
eatToken(p, TOKEN_KEYWORD_LINKSECTION, &ok);
if (!ok)
return null_node;
fprintf(stderr, "parseLinkSection cannot parse linksection\n");
@@ -156,7 +156,7 @@ static AstNodeIndex parseLinkSection(Parser* p) {
static AstNodeIndex parseCallconv(Parser* p) {
bool ok;
eatToken(p, TOKENIZER_TAG_KEYWORD_CALLCONV, &ok);
eatToken(p, TOKEN_KEYWORD_CALLCONV, &ok);
if (!ok)
return null_node;
fprintf(stderr, "parseCallconv cannot parse callconv\n");
@@ -171,15 +171,15 @@ typedef struct {
} NodeContainerField;
static AstNodeIndex expectContainerField(Parser* p) {
eatToken(p, TOKENIZER_TAG_KEYWORD_COMPTIME, NULL);
eatToken(p, TOKEN_KEYWORD_COMPTIME, NULL);
const AstTokenIndex main_token = p->tok_i;
if (p->token_tags[p->tok_i] == TOKENIZER_TAG_IDENTIFIER && p->token_tags[p->tok_i + 1] == TOKENIZER_TAG_COLON)
if (p->token_tags[p->tok_i] == TOKEN_IDENTIFIER && p->token_tags[p->tok_i + 1] == TOKEN_COLON)
p->tok_i += 2;
const AstNodeIndex type_expr = parseTypeExpr(p);
const AstNodeIndex align_expr = parseByteAlign(p);
bool ok;
eatToken(p, TOKENIZER_TAG_EQUAL, &ok);
eatToken(p, TOKEN_EQUAL, &ok);
if (ok) {
fprintf(stderr, "expectContainerField does not support expr\n");
exit(1);
@@ -225,27 +225,27 @@ static AstNodeIndex expectContainerField(Parser* p) {
static AstNodeIndex parsePrimaryTypeExpr(Parser* p) {
const TokenizerTag tok = p->token_tags[p->tok_i];
switch (tok) {
case TOKENIZER_TAG_CHAR_LITERAL:
case TOKENIZER_TAG_NUMBER_LITERAL:
case TOKENIZER_TAG_KEYWORD_UNREACHABLE:
case TOKENIZER_TAG_KEYWORD_ANYFRAME:
case TOKENIZER_TAG_STRING_LITERAL:
case TOKENIZER_TAG_BUILTIN:
case TOKENIZER_TAG_KEYWORD_FN:
case TOKENIZER_TAG_KEYWORD_IF:
case TOKENIZER_TAG_KEYWORD_SWITCH:
case TOKENIZER_TAG_KEYWORD_EXTERN:
case TOKENIZER_TAG_KEYWORD_PACKED:
case TOKENIZER_TAG_KEYWORD_STRUCT:
case TOKENIZER_TAG_KEYWORD_OPAQUE:
case TOKENIZER_TAG_KEYWORD_ENUM:
case TOKENIZER_TAG_KEYWORD_UNION:
case TOKENIZER_TAG_KEYWORD_COMPTIME:
case TOKENIZER_TAG_MULTILINE_STRING_LITERAL_LINE:
case TOKEN_CHAR_LITERAL:
case TOKEN_NUMBER_LITERAL:
case TOKEN_KEYWORD_UNREACHABLE:
case TOKEN_KEYWORD_ANYFRAME:
case TOKEN_STRING_LITERAL:
case TOKEN_BUILTIN:
case TOKEN_KEYWORD_FN:
case TOKEN_KEYWORD_IF:
case TOKEN_KEYWORD_SWITCH:
case TOKEN_KEYWORD_EXTERN:
case TOKEN_KEYWORD_PACKED:
case TOKEN_KEYWORD_STRUCT:
case TOKEN_KEYWORD_OPAQUE:
case TOKEN_KEYWORD_ENUM:
case TOKEN_KEYWORD_UNION:
case TOKEN_KEYWORD_COMPTIME:
case TOKEN_MULTILINE_STRING_LITERAL_LINE:
fprintf(stderr, "parsePrimaryTypeExpr does not support %s\n", tokenizerGetTagString(tok));
exit(1);
case TOKENIZER_TAG_IDENTIFIER:
if (p->token_tags[p->tok_i + 1] == TOKENIZER_TAG_COLON) {
case TOKEN_IDENTIFIER:
if (p->token_tags[p->tok_i + 1] == TOKEN_COLON) {
fprintf(stderr, "parsePrimaryTypeExpr does not support identifier followed by colon\n");
exit(1);
}
@@ -255,12 +255,12 @@ static AstNodeIndex parsePrimaryTypeExpr(Parser* p) {
.tag = AST_NODE_TAG_IDENTIFIER,
.main_token = nextToken(p),
.data = {} });
case TOKENIZER_TAG_KEYWORD_INLINE:
case TOKENIZER_TAG_KEYWORD_FOR:
case TOKENIZER_TAG_KEYWORD_WHILE:
case TOKENIZER_TAG_PERIOD:
case TOKENIZER_TAG_KEYWORD_ERROR:
case TOKENIZER_TAG_L_PAREN:
case TOKEN_KEYWORD_INLINE:
case TOKEN_KEYWORD_FOR:
case TOKEN_KEYWORD_WHILE:
case TOKEN_PERIOD:
case TOKEN_KEYWORD_ERROR:
case TOKEN_L_PAREN:
fprintf(stderr, "parsePrimaryTypeExpr does not support %s\n", tokenizerGetTagString(tok));
exit(1);
default:
@@ -271,10 +271,10 @@ static AstNodeIndex parsePrimaryTypeExpr(Parser* p) {
static AstNodeIndex parseSuffixOp(Parser* p) {
const TokenizerTag tok = p->token_tags[p->tok_i];
switch (tok) {
case TOKENIZER_TAG_L_BRACKET:
case TOKENIZER_TAG_PERIOD_ASTERISK:
case TOKENIZER_TAG_INVALID_PERIODASTERISKS:
case TOKENIZER_TAG_PERIOD:
case TOKEN_L_BRACKET:
case TOKEN_PERIOD_ASTERISK:
case TOKEN_INVALID_PERIODASTERISKS:
case TOKEN_PERIOD:
fprintf(stderr, "parseSuffixOp does not support %s\n", tokenizerGetTagString(tok));
exit(1);
default:
@@ -284,7 +284,7 @@ static AstNodeIndex parseSuffixOp(Parser* p) {
static AstNodeIndex parseSuffixExpr(Parser* p) {
bool ok;
eatToken(p, TOKENIZER_TAG_KEYWORD_ASYNC, &ok);
eatToken(p, TOKEN_KEYWORD_ASYNC, &ok);
if (ok) {
fprintf(stderr, "async not supported\n");
exit(1);
@@ -300,13 +300,13 @@ static AstNodeIndex parseSuffixExpr(Parser* p) {
res = suffix_op;
continue;
}
eatToken(p, TOKENIZER_TAG_L_PAREN, &ok);
eatToken(p, TOKEN_L_PAREN, &ok);
if (ok) {
fprintf(stderr, "parseSuffixExpr does not support expr with parens\n");
exit(1);
}
// TODO more work
// const bool comma = p->token_tags[p->tok_i - 2] == TOKENIZER_TAG_COMMA;
// const bool comma = p->token_tags[p->tok_i - 2] == TOKEN_COMMA;
return res;
}
@@ -329,7 +329,7 @@ static AstNodeIndex parseErrorUnionExpr(Parser* p) {
if (suffix_expr == 0)
return null_node;
bool ok;
const AstNodeIndex bang = eatToken(p, TOKENIZER_TAG_BANG, &ok);
const AstNodeIndex bang = eatToken(p, TOKEN_BANG, &ok);
if (!ok)
return suffix_expr;
return addNode(
@@ -347,11 +347,11 @@ static AstNodeIndex parseErrorUnionExpr(Parser* p) {
static AstNodeIndex parseTypeExpr(Parser* p) {
const AstNodeIndex tok = p->token_tags[p->tok_i];
switch (tok) {
case TOKENIZER_TAG_QUESTION_MARK:
case TOKENIZER_TAG_KEYWORD_ANYFRAME:
case TOKENIZER_TAG_ASTERISK:
case TOKENIZER_TAG_ASTERISK_ASTERISK:
case TOKENIZER_TAG_L_BRACKET:
case TOKEN_QUESTION_MARK:
case TOKEN_KEYWORD_ANYFRAME:
case TOKEN_ASTERISK:
case TOKEN_ASTERISK_ASTERISK:
case TOKEN_L_BRACKET:
fprintf(stderr, "parseTypeExpr not supported for %s\n", tokenizerGetTagString(tok));
exit(1);
default:
@@ -362,13 +362,13 @@ static AstNodeIndex parseTypeExpr(Parser* p) {
static SmallSpan parseParamDeclList(Parser* p) {
// can only parse functions with no declarations
bool ok;
AstTokenIndex got_token = eatToken(p, TOKENIZER_TAG_L_PAREN, &ok);
AstTokenIndex got_token = eatToken(p, TOKEN_L_PAREN, &ok);
if (!ok) {
fprintf(stderr, "expected (, got %s\n", tokenizerGetTagString(got_token));
exit(1);
}
got_token = eatToken(p, TOKENIZER_TAG_R_PAREN, &ok);
got_token = eatToken(p, TOKEN_R_PAREN, &ok);
if (!ok) {
fprintf(stderr, "expected ), got %s\n", tokenizerGetTagString(got_token));
exit(1);
@@ -387,20 +387,20 @@ static uint32_t reserveNode(Parser* p, AstNodeTag tag) {
static AstNodeIndex parseFnProto(Parser* p) {
bool ok;
AstNodeIndex fn_token = eatToken(p, TOKENIZER_TAG_KEYWORD_FN, &ok);
AstNodeIndex fn_token = eatToken(p, TOKEN_KEYWORD_FN, &ok);
if (!ok)
return null_node;
AstNodeIndex fn_proto_index = reserveNode(p, AST_NODE_TAG_FN_PROTO);
eatToken(p, TOKENIZER_TAG_IDENTIFIER, NULL);
eatToken(p, TOKEN_IDENTIFIER, NULL);
SmallSpan params = parseParamDeclList(p);
const AstNodeIndex align_expr = parseByteAlign(p);
const AstNodeIndex addrspace_expr = parseAddrSpace(p);
const AstNodeIndex section_expr = parseLinkSection(p);
const AstNodeIndex callconv_expr = parseCallconv(p);
eatToken(p, TOKENIZER_TAG_BANG, NULL);
eatToken(p, TOKEN_BANG, NULL);
const AstNodeIndex return_type_expr = parseTypeExpr(p);
@@ -425,7 +425,7 @@ static AstNodeIndex parseFnProto(Parser* p) {
}
static AstTokenIndex parseBlockLabel(Parser* p) {
if (p->token_tags[p->tok_i] == TOKENIZER_TAG_IDENTIFIER && p->token_tags[p->tok_i + 1] == TOKENIZER_TAG_COLON) {
if (p->token_tags[p->tok_i] == TOKEN_IDENTIFIER && p->token_tags[p->tok_i + 1] == TOKEN_COLON) {
const AstTokenIndex identifier = p->tok_i;
p->tok_i += 2;
return identifier;
@@ -435,7 +435,7 @@ static AstTokenIndex parseBlockLabel(Parser* p) {
static AstNodeIndex parseForStatement(Parser* p) {
bool ok;
const AstNodeIndex for_token = eatToken(p, TOKENIZER_TAG_KEYWORD_FOR, &ok);
const AstNodeIndex for_token = eatToken(p, TOKEN_KEYWORD_FOR, &ok);
if (!ok)
return null_node;
@@ -446,7 +446,7 @@ static AstNodeIndex parseForStatement(Parser* p) {
static AstNodeIndex parseWhileStatement(Parser* p) {
bool ok;
const AstNodeIndex while_token = eatToken(p, TOKENIZER_TAG_KEYWORD_WHILE, &ok);
const AstNodeIndex while_token = eatToken(p, TOKEN_KEYWORD_WHILE, &ok);
if (!ok)
return null_node;
@@ -457,7 +457,7 @@ static AstNodeIndex parseWhileStatement(Parser* p) {
static AstNodeIndex parseLoopStatement(Parser* p) {
bool ok_inline_token;
eatToken(p, TOKENIZER_TAG_KEYWORD_INLINE, &ok_inline_token);
eatToken(p, TOKEN_KEYWORD_INLINE, &ok_inline_token);
const AstNodeIndex for_statement = parseForStatement(p);
if (for_statement != 0)
@@ -492,21 +492,21 @@ static AstNodeIndex expectVarDeclExprStatement(Parser* p) {
static AstNodeIndex parseLabeledStatement(Parser*);
static AstNodeIndex expectStatement(Parser* p, bool allow_defer_var) {
bool ok;
if (eatToken(p, TOKENIZER_TAG_KEYWORD_COMPTIME, &ok), ok) {
if (eatToken(p, TOKEN_KEYWORD_COMPTIME, &ok), ok) {
fprintf(stderr, "expectStatement: comptime keyword not supported\n");
exit(1);
}
const AstNodeIndex tok = p->token_tags[p->tok_i];
switch (tok) {
case TOKENIZER_TAG_KEYWORD_NOSUSPEND:
case TOKENIZER_TAG_KEYWORD_SUSPEND:
case TOKENIZER_TAG_KEYWORD_DEFER:
case TOKENIZER_TAG_KEYWORD_ERRDEFER:
case TOKENIZER_TAG_KEYWORD_IF:
case TOKENIZER_TAG_KEYWORD_ENUM:
case TOKENIZER_TAG_KEYWORD_STRUCT:
case TOKENIZER_TAG_KEYWORD_UNION:;
case TOKEN_KEYWORD_NOSUSPEND:
case TOKEN_KEYWORD_SUSPEND:
case TOKEN_KEYWORD_DEFER:
case TOKEN_KEYWORD_ERRDEFER:
case TOKEN_KEYWORD_IF:
case TOKEN_KEYWORD_ENUM:
case TOKEN_KEYWORD_STRUCT:
case TOKEN_KEYWORD_UNION:;
const char* tok_str = tokenizerGetTagString(tok);
fprintf(stderr, "expectStatement does not support keyword %s\n", tok_str);
exit(1);
@@ -532,7 +532,7 @@ static void cleanupScratch(CleanupScratch* c) { c->scratch->len = c->old_len; }
static AstNodeIndex parseBlock(Parser* p) {
bool ok;
const AstNodeIndex lbrace = eatToken(p, TOKENIZER_TAG_L_BRACE, &ok);
const AstNodeIndex lbrace = eatToken(p, TOKEN_L_BRACE, &ok);
if (!ok)
return null_node;
@@ -542,7 +542,7 @@ static AstNodeIndex parseBlock(Parser* p) {
};
while (1) {
if (p->token_tags[p->tok_i] == TOKENIZER_TAG_R_BRACE)
if (p->token_tags[p->tok_i] == TOKEN_R_BRACE)
break;
// "const AstNodeIndex statement" once tinycc supports typeof_unqual (C23)
@@ -551,8 +551,8 @@ static AstNodeIndex parseBlock(Parser* p) {
break;
SLICE_APPEND(AstNodeIndex, &p->scratch, statement);
}
expectToken(p, TOKENIZER_TAG_R_BRACE, NULL);
const bool semicolon = (p->token_tags[p->tok_i] - 2 == TOKENIZER_TAG_SEMICOLON);
expectToken(p, TOKEN_R_BRACE, NULL);
const bool semicolon = (p->token_tags[p->tok_i] - 2 == TOKEN_SEMICOLON);
const uint32_t statements_len = p->scratch.len - scratch_top.old_len;
switch (statements_len) {
@@ -626,9 +626,9 @@ static AstNodeIndex parseLabeledStatement(Parser* p) {
static AstNodeIndex parseVarDeclProto(Parser* p) {
bool ok;
eatToken(p, TOKENIZER_TAG_KEYWORD_CONST, &ok);
eatToken(p, TOKEN_KEYWORD_CONST, &ok);
if (!ok) {
eatToken(p, TOKENIZER_TAG_KEYWORD_VAR, &ok);
eatToken(p, TOKEN_KEYWORD_VAR, &ok);
if (!ok)
return null_node;
}
@@ -651,12 +651,12 @@ static AstNodeIndex expectTopLevelDecl(Parser* p) {
AstTokenIndex extern_export_inline_token = nextToken(p);
switch (p->token_tags[extern_export_inline_token]) {
case TOKENIZER_TAG_KEYWORD_EXTERN:
eatToken(p, TOKENIZER_TAG_STRING_LITERAL, NULL);
case TOKEN_KEYWORD_EXTERN:
eatToken(p, TOKEN_STRING_LITERAL, NULL);
break;
case TOKENIZER_TAG_KEYWORD_EXPORT:
case TOKENIZER_TAG_KEYWORD_INLINE:
case TOKENIZER_TAG_KEYWORD_NOINLINE:
case TOKEN_KEYWORD_EXPORT:
case TOKEN_KEYWORD_INLINE:
case TOKEN_KEYWORD_NOINLINE:
break;
default:
p->tok_i--;
@@ -665,10 +665,10 @@ static AstNodeIndex expectTopLevelDecl(Parser* p) {
AstNodeIndex fn_proto = parseFnProto(p);
if (fn_proto != 0) {
switch (p->token_tags[p->tok_i]) {
case TOKENIZER_TAG_SEMICOLON:
case TOKEN_SEMICOLON:
p->tok_i++;
return fn_proto;
case TOKENIZER_TAG_L_BRACE:;
case TOKEN_L_BRACE:;
AstNodeIndex fn_decl_index = reserveNode(p, AST_NODE_TAG_FN_DECL);
AstNodeIndex body_block = parseBlock(p);
return setNode(
@@ -684,7 +684,7 @@ static AstNodeIndex expectTopLevelDecl(Parser* p) {
}
}
eatToken(p, TOKENIZER_TAG_KEYWORD_THREADLOCAL, NULL);
eatToken(p, TOKEN_KEYWORD_THREADLOCAL, NULL);
AstNodeIndex var_decl = parseGlobalVarDecl(p);
if (var_decl != 0) {
return var_decl;
@@ -704,46 +704,46 @@ void findNextContainerMember(Parser* p) {
switch (p->token_tags[tok]) {
// Any of these can start a new top level declaration
case TOKENIZER_TAG_KEYWORD_TEST:
case TOKENIZER_TAG_KEYWORD_COMPTIME:
case TOKENIZER_TAG_KEYWORD_PUB:
case TOKENIZER_TAG_KEYWORD_EXPORT:
case TOKENIZER_TAG_KEYWORD_EXTERN:
case TOKENIZER_TAG_KEYWORD_INLINE:
case TOKENIZER_TAG_KEYWORD_NOINLINE:
case TOKENIZER_TAG_KEYWORD_USINGNAMESPACE:
case TOKENIZER_TAG_KEYWORD_THREADLOCAL:
case TOKENIZER_TAG_KEYWORD_CONST:
case TOKENIZER_TAG_KEYWORD_VAR:
case TOKENIZER_TAG_KEYWORD_FN:
case TOKEN_KEYWORD_TEST:
case TOKEN_KEYWORD_COMPTIME:
case TOKEN_KEYWORD_PUB:
case TOKEN_KEYWORD_EXPORT:
case TOKEN_KEYWORD_EXTERN:
case TOKEN_KEYWORD_INLINE:
case TOKEN_KEYWORD_NOINLINE:
case TOKEN_KEYWORD_USINGNAMESPACE:
case TOKEN_KEYWORD_THREADLOCAL:
case TOKEN_KEYWORD_CONST:
case TOKEN_KEYWORD_VAR:
case TOKEN_KEYWORD_FN:
if (level == 0) {
p->tok_i--;
return;
}
break;
case TOKENIZER_TAG_IDENTIFIER:
if (p->token_tags[tok + 1] == TOKENIZER_TAG_COMMA && level == 0) {
case TOKEN_IDENTIFIER:
if (p->token_tags[tok + 1] == TOKEN_COMMA && level == 0) {
p->tok_i--;
return;
}
break;
case TOKENIZER_TAG_COMMA:
case TOKENIZER_TAG_SEMICOLON:
case TOKEN_COMMA:
case TOKEN_SEMICOLON:
// This decl was likely meant to end here
if (level == 0)
return;
break;
case TOKENIZER_TAG_L_PAREN:
case TOKENIZER_TAG_L_BRACKET:
case TOKENIZER_TAG_L_BRACE:
case TOKEN_L_PAREN:
case TOKEN_L_BRACKET:
case TOKEN_L_BRACE:
level++;
break;
case TOKENIZER_TAG_R_PAREN:
case TOKENIZER_TAG_R_BRACKET:
case TOKEN_R_PAREN:
case TOKEN_R_BRACKET:
if (level != 0)
level--;
break;
case TOKENIZER_TAG_R_BRACE:
case TOKEN_R_BRACE:
if (level == 0) {
// end of container, exit
p->tok_i--;
@@ -751,7 +751,7 @@ void findNextContainerMember(Parser* p) {
}
level--;
break;
case TOKENIZER_TAG_EOF:
case TOKEN_EOF:
p->tok_i--;
return;
default:
@@ -766,7 +766,7 @@ static Members parseContainerMembers(Parser* p) {
.old_len = p->scratch.len,
};
bool ok;
while (eatToken(p, TOKENIZER_TAG_CONTAINER_DOC_COMMENT, &ok), ok)
while (eatToken(p, TOKEN_CONTAINER_DOC_COMMENT, &ok), ok)
;
FieldState field_state = { .tag = FIELD_STATE_NONE };
@@ -775,13 +775,13 @@ static Members parseContainerMembers(Parser* p) {
while (1) {
eatDocComments(p);
switch (p->token_tags[p->tok_i]) {
case TOKENIZER_TAG_KEYWORD_TEST:
case TOKENIZER_TAG_KEYWORD_COMPTIME:
case TOKENIZER_TAG_KEYWORD_USINGNAMESPACE:;
case TOKEN_KEYWORD_TEST:
case TOKEN_KEYWORD_COMPTIME:
case TOKEN_KEYWORD_USINGNAMESPACE:;
const char* str = tokenizerGetTagString(p->token_tags[p->tok_i]);
fprintf(stderr, "%s not implemented in parseContainerMembers\n", str);
exit(1);
case TOKENIZER_TAG_KEYWORD_PUB: {
case TOKEN_KEYWORD_PUB: {
p->tok_i++;
AstNodeIndex top_level_decl = expectTopLevelDecl(p);
if (top_level_decl != 0) {
@@ -791,17 +791,17 @@ static Members parseContainerMembers(Parser* p) {
}
SLICE_APPEND(AstNodeIndex, &p->scratch, top_level_decl);
}
trailing = p->token_tags[p->tok_i - 1] == TOKENIZER_TAG_SEMICOLON;
trailing = p->token_tags[p->tok_i - 1] == TOKEN_SEMICOLON;
break;
}
case TOKENIZER_TAG_KEYWORD_CONST:
case TOKENIZER_TAG_KEYWORD_VAR:
case TOKENIZER_TAG_KEYWORD_THREADLOCAL:
case TOKENIZER_TAG_KEYWORD_EXPORT:
case TOKENIZER_TAG_KEYWORD_EXTERN:
case TOKENIZER_TAG_KEYWORD_INLINE:
case TOKENIZER_TAG_KEYWORD_NOINLINE:
case TOKENIZER_TAG_KEYWORD_FN: {
case TOKEN_KEYWORD_CONST:
case TOKEN_KEYWORD_VAR:
case TOKEN_KEYWORD_THREADLOCAL:
case TOKEN_KEYWORD_EXPORT:
case TOKEN_KEYWORD_EXTERN:
case TOKEN_KEYWORD_INLINE:
case TOKEN_KEYWORD_NOINLINE:
case TOKEN_KEYWORD_FN: {
const AstNodeIndex top_level_decl = expectTopLevelDecl(p);
if (top_level_decl != 0) {
if (field_state.tag == FIELD_STATE_SEEN) {
@@ -810,11 +810,11 @@ static Members parseContainerMembers(Parser* p) {
}
SLICE_APPEND(AstNodeIndex, &p->scratch, top_level_decl);
}
trailing = (p->token_tags[p->tok_i - 1] == TOKENIZER_TAG_SEMICOLON);
trailing = (p->token_tags[p->tok_i - 1] == TOKEN_SEMICOLON);
break;
}
case TOKENIZER_TAG_EOF:
case TOKENIZER_TAG_R_BRACE:
case TOKEN_EOF:
case TOKEN_R_BRACE:
goto break_loop;
default:;
// skip parseCStyleContainer
@@ -831,12 +831,12 @@ static Members parseContainerMembers(Parser* p) {
}
SLICE_APPEND(AstNodeIndex, &p->scratch, container_field);
switch (p->token_tags[p->tok_i]) {
case TOKENIZER_TAG_COMMA:
case TOKEN_COMMA:
p->tok_i++;
trailing = true;
continue;
case TOKENIZER_TAG_R_BRACE:
case TOKENIZER_TAG_EOF:
case TOKEN_R_BRACE:
case TOKEN_EOF:
trailing = false;
goto break_loop;
default:;