// SPDX-License-Identifier: Apache-2.0

#include <assert.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "sunder.h"

struct parser {

};

static struct parser*

parser_new(struct module* module, struct lexer* lexer);

static void

parser_del(struct parser* self);

static struct token

advance_token(struct parser* parser);

static bool

check_current(struct parser const* parser, enum token_kind kind);

static bool

check_peek(struct parser const* parser, enum token_kind kind);

static struct token

expect_current(struct parser* parser, enum token_kind kind);

static struct cst_identifier

parse_identifier(struct parser* parser);

static struct cst_block

parse_block(struct parser* parser);

static struct cst_switch_case

parse_switch_case(struct parser* parser);

static struct cst_module const*

parse_module(struct parser* parser);

static struct cst_namespace const*

parse_namespace(struct parser* parser);

static struct cst_import const*

parse_import(struct parser* parser);

static struct cst_decl const*

parse_decl(struct parser* parser);

static struct cst_decl const*

parse_decl_variable(struct parser* parser);

static struct cst_decl const*

parse_decl_constant(struct parser* parser);

static struct cst_decl const*

parse_decl_function(struct parser* parser);

static struct cst_decl const*

parse_decl_struct(struct parser* parser);

static struct cst_decl const*

parse_decl_union(struct parser* parser);

static struct cst_decl const*

parse_decl_enum(struct parser* parser);

static struct cst_decl const*

parse_decl_extend(struct parser* parser);

static struct cst_decl const*

parse_decl_alias(struct parser* parser);

static struct cst_decl const*

parse_decl_extern_variable(struct parser* parser);

static struct cst_decl const*

parse_decl_extern_function(struct parser* parser);

static struct cst_decl const*

parse_decl_extern_type(struct parser* parser);

static struct cst_stmt const*

parse_stmt(struct parser* parser);

static struct cst_stmt const*

parse_stmt_decl(struct parser* parser);

static struct cst_stmt const*

parse_stmt_defer(struct parser* parser);

static struct cst_stmt const*

parse_stmt_if(struct parser* parser);

static struct cst_stmt const*

parse_stmt_when(struct parser* parser);

static struct cst_stmt const*

parse_stmt_for(struct parser* parser);

static struct cst_stmt const*

parse_stmt_break(struct parser* parser);

static struct cst_stmt const*

parse_stmt_continue(struct parser* parser);

static struct cst_stmt const*

parse_stmt_switch(struct parser* parser);

static struct cst_stmt const*

parse_stmt_return(struct parser* parser);

static struct cst_stmt const*

parse_stmt_assert(struct parser* parser);

// Precedence levels roughly follow the precedence levels described in the

// operator precedence section of the Go Programming Language Specification.

// Sunder encourages using parentheses to disambiguate the order of evaluation

// for expressions with many operations, and an effort is made to keep the

// number of precedence levels small in comparison to the precedence levels of

// languages like C and C++.

enum precedence {

};

// Returns the precedence corresponding to provided token or PRECEDENCE_LOWEST

// if no precedence mapping exists.

static enum precedence

token_kind_precedence(enum token_kind kind);

static enum precedence

current_precedence(struct parser* parser);

// Parse function for a null denotation.

typedef struct cst_expr const* (*parse_nud_fn)(struct parser*);

// Parse function for a left denotation.

typedef struct cst_expr const* (*parse_led_fn)(

struct parser*, struct cst_expr const*);

// Returns NULL if no function is associated with the provided token kind.

static parse_nud_fn

token_kind_nud(enum token_kind kind);

// Returns NULL if no function is associated with the provided token kind.

static parse_led_fn

token_kind_led(enum token_kind kind);

static struct cst_expr const*

parse_expr(struct parser* parser);

static struct cst_expr const*

parse_expr_symbol(struct parser* parser);

static struct cst_expr const*

parse_expr_boolean(struct parser* parser);

static struct cst_expr const*

parse_expr_integer(struct parser* parser);

static struct cst_expr const*

parse_expr_ieee754(struct parser* parser);

static struct cst_expr const*

parse_expr_character(struct parser* parser);

static struct cst_expr const*

parse_expr_bytes(struct parser* parser);

static struct cst_expr const*

parse_expr_lparen(struct parser* parser);

static struct cst_expr const*

parse_expr_led_lparen(struct parser* parser, struct cst_expr const* lhs);

static struct cst_expr const*

parse_expr_led_lbracket(struct parser* parser, struct cst_expr const* lhs);

static struct cst_expr const*

parse_expr_led_dot_star(struct parser* parser, struct cst_expr const* lhs);

static struct cst_expr const*

parse_expr_led_dot(struct parser* parser, struct cst_expr const* lhs);

static struct cst_expr const*

parse_expr_defined(struct parser* parser);

static struct cst_expr const*

parse_expr_sizeof(struct parser* parser);

static struct cst_expr const*

parse_expr_alignof(struct parser* parser);

static struct cst_expr const*

parse_expr_fileof(struct parser* parser);

static struct cst_expr const*

parse_expr_lineof(struct parser* parser);

static struct cst_expr const*

parse_expr_embed(struct parser* parser);

static struct cst_expr const*

parse_expr_nud_unary(struct parser* parser);

static struct cst_expr const*

parse_expr_led_binary(struct parser* parser, struct cst_expr const* lhs);

static struct cst_symbol*

parse_symbol(struct parser* parser);

static struct cst_symbol_element*

parse_symbol_element(struct parser* parser);

static struct cst_identifier const*

parse_template_parameter_list(struct parser* parser);

static struct cst_type const* const*

parse_template_argument_list(struct parser* parser);

static struct cst_function_parameter const* const*

parse_function_parameter_list(struct parser* parser);

static struct cst_function_parameter const*

parse_function_parameter(struct parser* parser);

static struct cst_member const* const*

parse_member_list(struct parser* parser);

static struct cst_member const*

parse_member(struct parser* parser);

static struct cst_member const*

parse_member_variable(struct parser* parser);

static struct cst_member const*

parse_member_constant(struct parser* parser);

static struct cst_member const*

parse_member_function(struct parser* parser);

static struct cst_member_initializer const* const*

parse_member_initializer_list(struct parser* parser);

static struct cst_member_initializer const*

parse_member_initializer(struct parser* parser);

static struct cst_enum_value const*

parse_enum_value(struct parser* parser);

static struct cst_type const*

parse_type(struct parser* parser);

static struct cst_type const*

parse_type_symbol(struct parser* parser);

static struct cst_type const*

parse_type_function(struct parser* parser);

static struct cst_type const*

parse_type_pointer(struct parser* parser);

static struct cst_type const*

parse_type_array_or_slice(struct parser* parser);

static struct cst_type const*

parse_type_struct(struct parser* parser);

static struct cst_type const*

parse_type_union(struct parser* parser);

static struct cst_type const*

parse_type_enum(struct parser* parser);

static struct cst_type const*

parse_type_typeof(struct parser* parser);

static struct parser*

parser_new(struct module* module, struct lexer* lexer)

{

assert(module != NULL);

assert(lexer != NULL);

struct parser* const self = xalloc(NULL, sizeof(*self));

memset(self, 0x00, sizeof(*self));

self->module = module;

self->lexer = lexer;

advance_token(self);

advance_token(self);

return self;

}

static void

parser_del(struct parser* self)

{

assert(self != NULL);

memset(self, 0x00, sizeof(*self));

xalloc(self, XALLOC_FREE);

}

static struct token

advance_token(struct parser* parser)

{

assert(parser != NULL);

struct token const current_token = parser->current_token;

parser->current_token = parser->peek_token;

parser->peek_token = lexer_next_token(parser->lexer);

return current_token;

}

static bool

check_current(struct parser const* parser, enum token_kind kind)

{

assert(parser != NULL);

return parser->current_token.kind == kind;

}

static bool

check_peek(struct parser const* parser, enum token_kind kind)

{

assert(parser != NULL);

return parser->peek_token.kind == kind;

}

static struct token

expect_current(struct parser* parser, enum token_kind kind)

{

assert(parser != NULL);

if (!check_current(parser, kind)) {

char const* const expected = token_kind_to_cstr(kind);

char* const found = token_to_new_cstr(parser->current_token);

fatal(

parser->current_token.location,

"expected `%s`, found `%s`",

expected,

found);

}

return advance_token(parser);

}

static struct cst_identifier

parse_identifier(struct parser* parser)

{

assert(parser != NULL);

struct token const token = expect_current(parser, TOKEN_IDENTIFIER);

struct source_location const location = token.location;

struct cst_identifier product =

cst_identifier_init(location, token.data.identifier);

return product;

}

static struct cst_block

parse_block(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_LBRACE).location;

sbuf(struct cst_stmt const*) stmts = NULL;

while (!check_current(parser, TOKEN_RBRACE)) {

sbuf_push(stmts, parse_stmt(parser));

}

sbuf_freeze(stmts);

expect_current(parser, TOKEN_RBRACE);

struct cst_block const product = cst_block_init(location, stmts);

return product;

}

static struct cst_switch_case

parse_switch_case(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location = parser->current_token.location;

sbuf(struct cst_symbol const*) symbols = NULL;

if (check_current(parser, TOKEN_ELSE)) {

expect_current(parser, TOKEN_ELSE);

}

else {

sbuf_push(symbols, parse_symbol(parser));

while (check_current(parser, TOKEN_OR)) {

expect_current(parser, TOKEN_OR);

sbuf_push(symbols, parse_symbol(parser));

}

}

sbuf_freeze(symbols);

struct cst_block const block = parse_block(parser);

struct cst_switch_case product =

cst_switch_case_init(location, symbols, block);

return product;

}

static struct cst_module const*

parse_module(struct parser* parser)

{

assert(parser != NULL);

struct cst_namespace const* namespace = NULL;

if (check_current(parser, TOKEN_NAMESPACE)) {

namespace = parse_namespace(parser);

}

sbuf(struct cst_import const*) imports = NULL;

while (check_current(parser, TOKEN_IMPORT)) {

sbuf_push(imports, parse_import(parser));

}

sbuf_freeze(imports);

sbuf(struct cst_decl const*) decls = NULL;

while (!check_current(parser, TOKEN_EOF)) {

sbuf_push(decls, parse_decl(parser));

}

sbuf_freeze(decls);

struct cst_module* const product =

cst_module_new(namespace, imports, decls);

freeze(product);

return product;

}

static struct cst_namespace const*

parse_namespace(struct parser* parser)

{

struct source_location const location =

expect_current(parser, TOKEN_NAMESPACE).location;

sbuf(struct cst_identifier) identifiers = NULL;

sbuf_push(identifiers, parse_identifier(parser));

while (!check_current(parser, TOKEN_SEMICOLON)) {

expect_current(parser, TOKEN_COLON_COLON);

sbuf_push(identifiers, parse_identifier(parser));

}

expect_current(parser, TOKEN_SEMICOLON);

sbuf_freeze(identifiers);

struct cst_namespace* const product =

cst_namespace_new(location, identifiers);

freeze(product);

return product;

}

static struct cst_import const*

parse_import(struct parser* parser)

{

struct source_location const location =

expect_current(parser, TOKEN_IMPORT).location;

struct string const* const bytes =

expect_current(parser, TOKEN_BYTES).data.bytes;

char const* const path = intern_cstr(string_start(bytes));

expect_current(parser, TOKEN_SEMICOLON);

struct cst_import* const product = cst_import_new(location, path);

freeze(product);

return product;

}

static struct cst_decl const*

parse_decl(struct parser* parser)

{

assert(parser != NULL);

if (check_current(parser, TOKEN_VAR)) {

return parse_decl_variable(parser);

}

if (check_current(parser, TOKEN_LET)) {

return parse_decl_constant(parser);

}

if (check_current(parser, TOKEN_FUNC)) {

return parse_decl_function(parser);

}

if (check_current(parser, TOKEN_STRUCT)) {

return parse_decl_struct(parser);

}

if (check_current(parser, TOKEN_UNION)) {

return parse_decl_union(parser);

}

if (check_current(parser, TOKEN_ENUM)) {

return parse_decl_enum(parser);

}

if (check_current(parser, TOKEN_EXTEND)) {

return parse_decl_extend(parser);

}

if (check_current(parser, TOKEN_TYPE)) {

return parse_decl_alias(parser);

}

if (check_current(parser, TOKEN_EXTERN) && check_peek(parser, TOKEN_VAR)) {

return parse_decl_extern_variable(parser);

}

if (check_current(parser, TOKEN_EXTERN) && check_peek(parser, TOKEN_FUNC)) {

return parse_decl_extern_function(parser);

}

if (check_current(parser, TOKEN_EXTERN) && check_peek(parser, TOKEN_TYPE)) {

return parse_decl_extern_type(parser);

}

fatal(

parser->current_token.location,

"expected declaration, found `%s`",

token_to_new_cstr(parser->current_token));

return NULL;

}

static struct cst_decl const*

parse_decl_variable(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_VAR).location;

struct cst_identifier const identifier = parse_identifier(parser);

struct cst_type const* type = NULL;

if (check_current(parser, TOKEN_COLON)) {

expect_current(parser, TOKEN_COLON);

type = parse_type(parser);

}

expect_current(parser, TOKEN_ASSIGN);

struct cst_expr const* expr = NULL;

if (check_current(parser, TOKEN_UNINIT)) {

expect_current(parser, TOKEN_UNINIT);

if (type == NULL) {

fatal(

identifier.location,

"uninitialized variable `%s` requires a type specifier",

identifier.name);

}

}

else {

expr = parse_expr(parser);

}

expect_current(parser, TOKEN_SEMICOLON);

struct cst_decl* const product =

cst_decl_new_variable(location, identifier, type, expr);

freeze(product);

return product;

}

static struct cst_decl const*

parse_decl_constant(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_LET).location;

struct cst_identifier const identifier = parse_identifier(parser);

struct cst_type const* type = NULL;

if (check_current(parser, TOKEN_COLON)) {

expect_current(parser, TOKEN_COLON);

type = parse_type(parser);

}

expect_current(parser, TOKEN_ASSIGN);

struct cst_expr const* expr = NULL;

if (check_current(parser, TOKEN_UNINIT)) {

expect_current(parser, TOKEN_UNINIT);

if (type == NULL) {

fatal(

identifier.location,

"uninitialized constant `%s` requires a type specifier",

identifier.name);

}

}

else {

expr = parse_expr(parser);

}

expect_current(parser, TOKEN_SEMICOLON);

struct cst_decl* const product =

cst_decl_new_constant(location, identifier, type, expr);

freeze(product);

return product;

}

static struct cst_decl const*

parse_decl_function(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_FUNC).location;

struct cst_identifier const identifier = parse_identifier(parser);

sbuf(struct cst_identifier const) const template_parameters =

parse_template_parameter_list(parser);

expect_current(parser, TOKEN_LPAREN);

sbuf(struct cst_function_parameter const* const) const function_parameters =

parse_function_parameter_list(parser);

expect_current(parser, TOKEN_RPAREN);

struct cst_type const* const return_type = parse_type(parser);

struct cst_block const body = parse_block(parser);

struct cst_decl* const product = cst_decl_new_function(

location,

identifier,

template_parameters,

function_parameters,

return_type,

body);

freeze(product);

return product;

}

static struct cst_decl const*

parse_decl_struct(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_STRUCT).location;

struct cst_identifier const identifier = parse_identifier(parser);

sbuf(struct cst_identifier const) const template_parameters =

parse_template_parameter_list(parser);

expect_current(parser, TOKEN_LBRACE);

sbuf(struct cst_member const* const) members = parse_member_list(parser);

expect_current(parser, TOKEN_RBRACE);

struct cst_decl* const product =

cst_decl_new_struct(location, identifier, template_parameters, members);

freeze(product);

return product;

}

static struct cst_decl const*

parse_decl_union(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_UNION).location;

struct cst_identifier const identifier = parse_identifier(parser);

sbuf(struct cst_identifier const) const template_parameters =

parse_template_parameter_list(parser);

expect_current(parser, TOKEN_LBRACE);

sbuf(struct cst_member const* const) members = parse_member_list(parser);

expect_current(parser, TOKEN_RBRACE);

struct cst_decl* const product =

cst_decl_new_union(location, identifier, template_parameters, members);

freeze(product);

return product;

}

static struct cst_decl const*

parse_decl_enum(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_ENUM).location;

struct cst_identifier const identifier = parse_identifier(parser);

expect_current(parser, TOKEN_LBRACE);

sbuf(struct cst_enum_value const*) values = NULL;

while (!check_current(parser, TOKEN_RBRACE)

&& !check_current(parser, TOKEN_FUNC)) {

sbuf_push(values, parse_enum_value(parser));

}

sbuf_freeze(values);

sbuf(struct cst_member const*) member_functions = NULL;

while (!check_current(parser, TOKEN_RBRACE)) {

sbuf_push(member_functions, parse_member_function(parser));

}

sbuf_freeze(member_functions);

expect_current(parser, TOKEN_RBRACE);

struct cst_decl* const product =

cst_decl_new_enum(location, identifier, values, member_functions);

freeze(product);

return product;

}

static struct cst_decl const*

parse_decl_extend(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_EXTEND).location;

struct cst_type const* const type = parse_type(parser);

struct cst_decl const* const decl = parse_decl(parser);

struct cst_decl* const product = cst_decl_new_extend(location, type, decl);

freeze(product);

return product;

}

static struct cst_decl const*

parse_decl_alias(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_TYPE).location;

struct cst_identifier const identifier = parse_identifier(parser);

expect_current(parser, TOKEN_ASSIGN);

struct cst_type const* const type = parse_type(parser);

expect_current(parser, TOKEN_SEMICOLON);

struct cst_decl* const product =

cst_decl_new_alias(location, identifier, type);

freeze(product);

return product;

}

static struct cst_decl const*

parse_decl_extern_variable(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_EXTERN).location;

expect_current(parser, TOKEN_VAR);

struct cst_identifier const identifier = parse_identifier(parser);

expect_current(parser, TOKEN_COLON);

struct cst_type const* const type = parse_type(parser);

expect_current(parser, TOKEN_SEMICOLON);

struct cst_decl* const product =

cst_decl_new_extern_variable(location, identifier, type);

freeze(product);

return product;

}

static struct cst_decl const*

parse_decl_extern_function(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_EXTERN).location;

expect_current(parser, TOKEN_FUNC);

struct cst_identifier const identifier = parse_identifier(parser);

expect_current(parser, TOKEN_LPAREN);

sbuf(struct cst_function_parameter const* const) const function_parameters =

parse_function_parameter_list(parser);

expect_current(parser, TOKEN_RPAREN);

struct cst_type const* const return_type = parse_type(parser);

expect_current(parser, TOKEN_SEMICOLON);

struct cst_decl* const product = cst_decl_new_extern_function(

location, identifier, function_parameters, return_type);

freeze(product);

return product;

}

static struct cst_decl const*

parse_decl_extern_type(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_EXTERN).location;

expect_current(parser, TOKEN_TYPE);

struct cst_identifier const identifier = parse_identifier(parser);

expect_current(parser, TOKEN_SEMICOLON);

struct cst_decl* const product =

cst_decl_new_extern_type(location, identifier);

freeze(product);

return product;

}

static struct cst_stmt const*

parse_stmt(struct parser* parser)

{

assert(parser != NULL);

if (check_current(parser, TOKEN_VAR) || check_current(parser, TOKEN_LET)

|| check_current(parser, TOKEN_FUNC)

|| check_current(parser, TOKEN_TYPE)) {

return parse_stmt_decl(parser);

}

if (check_current(parser, TOKEN_DEFER)) {

return parse_stmt_defer(parser);

}

if (check_current(parser, TOKEN_IF)) {

return parse_stmt_if(parser);

}

if (check_current(parser, TOKEN_WHEN)) {

return parse_stmt_when(parser);

}

if (check_current(parser, TOKEN_FOR)) {

return parse_stmt_for(parser);

}

if (check_current(parser, TOKEN_BREAK)) {

return parse_stmt_break(parser);

}

if (check_current(parser, TOKEN_CONTINUE)) {

return parse_stmt_continue(parser);

}

if (check_current(parser, TOKEN_SWITCH)) {

return parse_stmt_switch(parser);

}

if (check_current(parser, TOKEN_RETURN)) {

return parse_stmt_return(parser);

}

if (check_current(parser, TOKEN_ASSERT)) {

return parse_stmt_assert(parser);

}

struct cst_expr const* const expr = parse_expr(parser);

static enum token_kind const assignment_ops[] = {

TOKEN_ASSIGN,

TOKEN_PLUS_ASSIGN,

TOKEN_DASH_ASSIGN,

TOKEN_STAR_ASSIGN,

TOKEN_FSLASH_ASSIGN,

TOKEN_PERCENT_ASSIGN,

TOKEN_PLUS_PERCENT_ASSIGN,

TOKEN_DASH_PERCENT_ASSIGN,

TOKEN_STAR_PERCENT_ASSIGN,

TOKEN_SHL_ASSIGN,

TOKEN_SHR_ASSIGN,

TOKEN_PIPE_ASSIGN,

TOKEN_CARET_ASSIGN,

TOKEN_AMPERSAND_ASSIGN,

};

for (size_t i = 0; i < ARRAY_COUNT(assignment_ops); ++i) {

if (check_current(parser, assignment_ops[i])) {

// <stmt-assign>

struct token const op = expect_current(parser, assignment_ops[i]);

struct source_location const location = op.location;

struct cst_expr const* const rhs = parse_expr(parser);

expect_current(parser, TOKEN_SEMICOLON);

struct cst_stmt* const product =

cst_stmt_new_assign(location, op, expr, rhs);

freeze(product);

return product;

}

}

// <stmt-expr>

expect_current(parser, TOKEN_SEMICOLON);

struct cst_stmt* const product = cst_stmt_new_expr(expr);

freeze(product);

return product;

}

static struct cst_stmt const*

parse_stmt_decl(struct parser* parser)

{

assert(parser != NULL);

struct cst_decl const* const decl = parse_decl(parser);

struct cst_stmt* const product = cst_stmt_new_decl(decl);

freeze(product);

return product;

}

static struct cst_stmt const*

parse_stmt_defer(struct parser* parser)

{

assert(parser != NULL);

struct source_location const location =

expect_current(parser, TOKEN_DEFER).location;

if (check_current(parser, TOKEN_LBRACE)) {

struct cst_block const block = parse_block(parser);

struct cst_stmt* const product =

cst_stmt_new_defer_block(location, block);

freeze(product);

return product;

}

struct cst_expr const* const expr = parse_expr(parser);

expect_current(parser, TOKEN_SEMICOLON);

struct cst_stmt* const product = cst_stmt_new_defer_expr(location, expr);

freeze(product);

return product;

}

static struct cst_stmt const*

parse_stmt_if(struct parser* parser)

{

assert(parser != NULL);

assert(check_current(parser, TOKEN_IF));

sbuf(struct cst_conditional) conditionals = NULL;

struct source_location location = expect_current(parser, TOKEN_IF).location;

struct cst_expr const* condition = parse_expr(parser);

struct cst_block body = parse_block(parser);

struct cst_conditional conditional =

cst_conditional_init(location, condition, body);

sbuf_push(conditionals, conditional);

while (check_current(parser, TOKEN_ELIF)) {

location = advance_token(parser).location;

condition = parse_expr(parser);

body = parse_block(parser);

conditional = cst_conditional_init(location, condition, body);

sbuf_push(conditionals, conditional);

}

if (check_current(parser, TOKEN_ELSE)) {

location = advance_token(parser).location;

body = parse_block(parser);

conditional = cst_conditional_init(location, NULL, body);

sbuf_push(conditionals, conditional);

}

sbuf_freeze(conditionals);

struct cst_stmt* const product = cst_stmt_new_if(conditionals);

freeze(product);

return product;

}

static struct cst_stmt const*

parse_stmt_when(struct parser* parser)

{

assert(parser != NULL);

assert(check_current(parser, TOKEN_WHEN));

sbuf(struct cst_conditional) conditionals = NULL;

struct source_location location =

expect_current(parser, TOKEN_WHEN).location;

struct cst_expr const* condition = parse_expr(parser);

struct cst_block body = parse_block(parser);

struct cst_conditional conditional =

cst_conditional_init(location, condition, body);

sbuf_push(conditionals, conditional);

while (check_current(parser, TOKEN_ELWHEN)) {

location = advance_token(parser).location;

condition = parse_expr(parser);

body = parse_block(parser);

conditional = cst_conditional_init(location, condition, body);

sbuf_push(conditionals, conditional);

}

if (check_current(parser, TOKEN_ELSE)) {

location = advance_token(parser).location;

body = parse_block(parser);

conditional = cst_conditional_init(location, NULL, body);

sbuf_push(conditionals, conditional);

}

sbuf_freeze(conditionals);

struct cst_stmt* const product = cst_stmt_new_when(conditionals);

freeze(product);

return product;

}

static struct cst_stmt const*

parse_stmt_for(struct parser* parser)

{

assert(parser != NULL);

assert(check_current(parser, TOKEN_FOR));

struct source_location const location =

expect_current(parser, TOKEN_FOR).location;

// <stmt-for-range>

bool const is_for_range = check_current(parser, TOKEN_IDENTIFIER)

&& (check_peek(parser, TOKEN_COLON) || check_peek(parser, TOKEN_IN));

if (is_for_range) {

struct cst_identifier const identifier = parse_identifier(parser);

struct cst_type const* type = NULL;

if (check_current(parser, TOKEN_COLON)) {

expect_current(parser, TOKEN_COLON);

type = parse_type(parser);

}

expect_current(parser, TOKEN_IN);

struct cst_expr const* begin = parse_expr(parser);

if (check_current(parser, TOKEN_COLON)) {

expect_current(parser, TOKEN_COLON);

struct cst_expr const* const end = parse_expr(parser);

struct cst_block const body = parse_block(parser);

struct cst_stmt* const product = cst_stmt_new_for_range(

location, identifier, type, begin, end, body);

freeze(product);

return product;

}

struct cst_expr const* const end = begin;

struct cst_block const body = parse_block(parser);

struct cst_stmt* const product =

cst_stmt_new_for_range(location, identifier, type, NULL, end, body);

freeze(product);

return product;

}

// <stmt-for-expr>

struct cst_expr const* const expr = parse_expr(parser);

struct cst_block const body = parse_block(parser);