#include "ctype.h" #include "stddef.h" #include "stdio.h" #include "stdlib.h" #include "string.h" typedef struct DynArr { void *items; size_t item_size; size_t item_cnts; size_t capacity; } DynArr; void da_init(DynArr *dyn_arr, size_t item_size, size_t capacity); DynArr *da_create(size_t item_size, size_t capacity); void *da_try_push_back(DynArr *dyn_arr); void *da_push_back(DynArr *dyn_arr, void *item); static inline void *da_get(DynArr *dyn_arr, size_t idx) { void *item = dyn_arr->items + idx * dyn_arr->item_size; return item; } static inline void da_set(DynArr *dyn_arr, size_t idx, void *item) { void *dest = dyn_arr->items + idx * dyn_arr->item_size; memcpy(dest, item, dyn_arr->item_size); return; } void da_free(DynArr *dyn_arr); typedef struct StrPoolNode { char *str; size_t len; char alloc_by_pool; } StrPoolNode; typedef struct StrPool { char *mempool; size_t mempool_offset; size_t mempool_size; DynArr pool_nodes; } StrPool; void str_pool_init(StrPool *pool, size_t mempool_size, size_t capacity); StrPool *str_pool_create(size_t mempool_size, size_t capacity); void str_pool_free(StrPool *str_pool); char *str_pool_intern(StrPool *str_pool, const char *string, size_t len); typedef struct VarIntData { int val; } VarIntData; typedef struct VarArrData { int *arr; } VarArrData; typedef union VarData { VarIntData i; VarArrData a; } VarData; typedef struct Interpreter { DynArr *stmts; DynArr *var_decls; } Interpreter; Interpreter *interpreter_create(DynArr *stmts, DynArr *var_decls); void interpreter_free(Interpreter *interpreter); void interpreter_execute(Interpreter *interpreter); enum TokType { TOK_EOF, TOK_IDENT, TOK_INT, TOK_PLUS, TOK_MINUS, TOK_COMMA, TOK_COLON, TOK_LBRACE, TOK_RBRACE, TOK_LBRACKET, TOK_RBRACKET, TOK_DOTDOT, TOK_KEYWORD_VARS, TOK_KEYWORD_SET, TOK_KEYWORD_YOSORO, TOK_KEYWORD_IHU, TOK_KEYWORD_HOR, TOK_KEYWORD_WHILE, TOK_KEYWORD_INT, TOK_KEYWORD_ARRAY, TOK_CMP_LT, TOK_CMP_GT, TOK_CMP_LE, TOK_CMP_GE, TOK_CMP_EQ, TOK_CMP_NEQ, }; typedef struct Token { enum TokType type; const char *str; } Token; typedef struct Lexer { char *src; size_t src_len; size_t ch_pos; DynArr toks; StrPool tok_val_pool; } Lexer; Lexer *lexer_create(char *src); void lexer_free(Lexer *lexer); void token_init(Token *tok, enum TokType tok_type, const char *str); Token *token_create(enum TokType tok_type, const char *str); void lexer_tokenize(Lexer *lexer); enum OperandTyp { OPERAND_INT_VAR, OPERAND_ARR_ELEM, }; enum ExprTermTyp { EXPR_TERM_CONST, EXPR_TERM_OPERAND, }; typedef struct Expr { DynArr terms; } Expr; typedef struct VarDecl VarDecl; typedef struct Operand { enum OperandTyp typ; size_t decl_idx; union { Expr idx_expr; }; } Operand; typedef struct ExprTerm { int coefficient; enum ExprTermTyp typ; union { int constant; Operand operand; }; } ExprTerm; enum StmtType { STMT_IHU_BLK = 0x00, STMT_WHILE_BLK, STMT_HOR_BLK, STMT_YOSORO_CMD = 0xf0, STMT_SET_CMD, }; enum VarType { VAR_INT, VAR_ARR, }; typedef struct VarDecl { enum VarType typ; VarData data; const char *name; struct { size_t start; size_t end; }; } VarDecl; typedef struct Cond { enum TokType typ; Expr left; Expr right; } Cond; typedef struct IhuStmt { Cond cond; DynArr stmts; } IhuStmt; typedef struct WhileStmt { Cond cond; DynArr stmts; } WhileStmt; typedef struct HorStmt { Operand var; Expr start; Expr end; DynArr stmts; } HorStmt; typedef struct YosoroStmt { Expr expr; } YosoroStmt; typedef struct SetStmt { Operand operand; Expr expr; } SetStmt; typedef struct Stmt { enum StmtType typ; union { IhuStmt ihu; WhileStmt while_stmt; HorStmt hor; YosoroStmt yosoro; SetStmt set; } inner; } Stmt; typedef struct Parser { DynArr *toks; size_t pos; DynArr stmts; DynArr var_decls; } Parser; Parser *parser_create(DynArr *toks); void parser_free(Parser *parser); size_t operand_finder(Parser *parser, const char *var_name, enum OperandTyp type); DynArr *parser_parse(Parser *parser); void var_decls_init_data(DynArr *var_decls) { for (int i = 0; i < var_decls->item_cnts; i++) { VarDecl *var_decl = da_get(var_decls, i); switch (var_decl->typ) { case VAR_INT: { VarIntData *int_data = &var_decl->data.i; int_data->val = 0; } break; case VAR_ARR: { VarArrData *arr_data = &var_decl->data.a; arr_data->arr = malloc((var_decl->end - var_decl->start + 1) * sizeof(int)); } break; } } } void var_decls_free_data(DynArr *var_decls) { for (int i = 0; i < var_decls->item_cnts; i++) { VarDecl *var_decl = da_get(var_decls, i); switch (var_decl->typ) { case VAR_INT: break; case VAR_ARR: { VarArrData *arr_data = &var_decl->data.a; free(arr_data->arr); } break; } } } Interpreter *interpreter_create(DynArr *stmts, DynArr *var_decls) { Interpreter *interpreter = malloc(sizeof(Interpreter)); interpreter->stmts = stmts; var_decls_init_data(var_decls); interpreter->var_decls = var_decls; return interpreter; } void interpreter_free(Interpreter *interpreter) { var_decls_free_data(interpreter->var_decls); free(interpreter); } int eval_expr(Interpreter *interpreter, Expr *expr); void write_operand(Interpreter *interpreter, Operand *operand, int data) { size_t decl_idx = operand->decl_idx; VarDecl *decl = da_get(interpreter->var_decls, decl_idx); switch (operand->typ) { case OPERAND_INT_VAR: decl->data.i.val = data; return; case OPERAND_ARR_ELEM: decl->data.a.arr[eval_expr(interpreter, &operand->idx_expr) - decl->start] = data; return; } } int read_operand(Interpreter *interpreter, Operand *operand) { size_t decl_idx = operand->decl_idx; VarDecl *decl = da_get(interpreter->var_decls, decl_idx); int data = 0; switch (operand->typ) { case OPERAND_INT_VAR: data = decl->data.i.val; break; case OPERAND_ARR_ELEM: data = decl->data.a .arr[eval_expr(interpreter, &operand->idx_expr) - decl->start]; break; } return data; } inline int eval_expr(Interpreter *interpreter, Expr *expr) { DynArr *terms = &expr->terms; int res = 0; for (int i = 0; i < terms->item_cnts; i++) { ExprTerm *term = da_get(terms, i); switch (term->typ) { case EXPR_TERM_CONST: res += term->coefficient * term->constant; break; case EXPR_TERM_OPERAND: res += term->coefficient * read_operand(interpreter, &term->operand); break; } } return res; } void execute_stmts(Interpreter *interpreter, DynArr *stmts); char execute_cond(Interpreter *interpreter, Cond *cond) { int left = eval_expr(interpreter, &cond->left); int right = eval_expr(interpreter, &cond->right); switch (cond->typ) { case TOK_CMP_LT: return left < right; case TOK_CMP_GT: return left > right; case TOK_CMP_LE: return left <= right; case TOK_CMP_GE: return left >= right; case TOK_CMP_EQ: return left == right; case TOK_CMP_NEQ: return left != right; default: return 0; } } void execute_stmt(Interpreter *interpreter, Stmt *stmt) { switch (stmt->typ) { case STMT_IHU_BLK: { IhuStmt *ihu = &stmt->inner.ihu; if (execute_cond(interpreter, &ihu->cond)) { execute_stmts(interpreter, &ihu->stmts); } } break; case STMT_WHILE_BLK: { WhileStmt *while_stmt = &stmt->inner.while_stmt; while (execute_cond(interpreter, &while_stmt->cond)) { execute_stmts(interpreter, &while_stmt->stmts); } } break; case STMT_HOR_BLK: { HorStmt *hor = &stmt->inner.hor; int start = eval_expr(interpreter, &hor->start); int end = eval_expr(interpreter, &hor->end); for (int i = start; i <= end; i++) { write_operand(interpreter, &hor->var, i); execute_stmts(interpreter, &hor->stmts); } write_operand(interpreter, &hor->var, end); } break; case STMT_YOSORO_CMD: { YosoroStmt *yosoro = &stmt->inner.yosoro; int res = eval_expr(interpreter, &yosoro->expr); printf("%d ", res); } break; case STMT_SET_CMD: { SetStmt *set = &stmt->inner.set; int res = eval_expr(interpreter, &set->expr); write_operand(interpreter, &set->operand, res); } break; } } void execute_stmts(Interpreter *interpreter, DynArr *stmts) { Stmt *stmt; for (int i = 0; i < stmts->item_cnts; i++) { stmt = da_get(stmts, i); execute_stmt(interpreter, stmt); } } void interpreter_execute(Interpreter *interpreter) { DynArr *stmts = interpreter->stmts; execute_stmts(interpreter, stmts); } Lexer *lexer_create(char *src) { Lexer *lexer = malloc(sizeof(Lexer)); str_pool_init(&lexer->tok_val_pool, 512, 16); lexer->src_len = strlen(src); lexer->src = src; lexer->ch_pos = 0; da_init(&lexer->toks, sizeof(Token), 128); return lexer; } void lexer_free(Lexer *lexer) { da_free(&lexer->toks); str_pool_free(&lexer->tok_val_pool); free(lexer); } void token_init(Token *tok, enum TokType tok_type, const char *str) { tok->type = tok_type; tok->str = str; return; } Token *token_create(enum TokType tok_type, const char *str) { Token *tok = malloc(sizeof(Token)); token_init(tok, tok_type, str); return tok; } inline static void add_token(Lexer *lexer, enum TokType tok_type, const char *val) { Token *tok = da_try_push_back(&lexer->toks); token_init(tok, tok_type, val); return; } inline static char is_identifier_char(char c) { return isalpha(c) || c == '_'; } const struct KeyWords { const enum TokType typ; const char *val; const size_t len; } keywords[] = { {TOK_KEYWORD_VARS, "vars", sizeof("vars") - 1}, {TOK_KEYWORD_SET, "set", sizeof("set") - 1}, {TOK_KEYWORD_YOSORO, "yosoro", sizeof("yosoro") - 1}, {TOK_KEYWORD_IHU, "ihu", sizeof("ihu") - 1}, {TOK_KEYWORD_HOR, "hor", sizeof("hor") - 1}, {TOK_KEYWORD_WHILE, "while", sizeof("while") - 1}, {TOK_KEYWORD_INT, "int", sizeof("int") - 1}, {TOK_KEYWORD_ARRAY, "array", sizeof("array") - 1}, {TOK_CMP_LT, "lt", sizeof("lt") - 1}, {TOK_CMP_GT, "gt", sizeof("gt") - 1}, {TOK_CMP_LE, "le", sizeof("le") - 1}, {TOK_CMP_GE, "ge", sizeof("ge") - 1}, {TOK_CMP_EQ, "eq", sizeof("eq") - 1}, {TOK_CMP_NEQ, "neq", sizeof("neq") - 1}, }; const size_t keyword_cnts = sizeof(keywords) / sizeof(*keywords); int check_keyword(const char *tok_val, size_t len) { for (int i = 0; i < keyword_cnts; ++i) { if (keywords[i].len == len && strncmp(tok_val, keywords[i].val, len) == 0) { return i; } } return -1; } void lexer_tokenize(Lexer *lexer) { while (lexer->ch_pos < lexer->src_len) { char ch = lexer->src[lexer->ch_pos]; if (isspace(ch)) { lexer->ch_pos++; continue; } if (isdigit(ch)) { size_t start = lexer->ch_pos; while (lexer->ch_pos < lexer->src_len && isdigit(lexer->src[lexer->ch_pos])) { lexer->ch_pos++; } size_t len = lexer->ch_pos - start; char *val = lexer->src + start; val = str_pool_intern(&lexer->tok_val_pool, val, len); add_token(lexer, TOK_INT, val); continue; } if (is_identifier_char(ch)) { size_t start = lexer->ch_pos; while (lexer->ch_pos < lexer->src_len && isalnum(lexer->src[lexer->ch_pos])) { lexer->ch_pos++; } size_t len = lexer->ch_pos - start; const char *val = lexer->src + start; int keyword_idx = check_keyword(val, len); enum TokType type; if (keyword_idx != -1) { type = keywords[keyword_idx].typ; val = keywords[keyword_idx].val; } else { type = TOK_IDENT; val = str_pool_intern(&lexer->tok_val_pool, val, len); } add_token(lexer, type, val); continue; } switch (ch) { case '+': add_token(lexer, TOK_PLUS, "'+'"); break; case '-': add_token(lexer, TOK_MINUS, "'-'"); break; case ',': add_token(lexer, TOK_COMMA, "','"); break; case ':': add_token(lexer, TOK_COLON, "':'"); break; case '{': add_token(lexer, TOK_LBRACE, "'{'"); break; case '}': add_token(lexer, TOK_RBRACE, "'}'"); break; case '[': add_token(lexer, TOK_LBRACKET, "'['"); break; case ']': add_token(lexer, TOK_RBRACKET, "']'"); break; default: if (ch == '.' && lexer->ch_pos + 1 < lexer->src_len && lexer->src[lexer->ch_pos + 1] == '.') { add_token(lexer, TOK_DOTDOT, ".."); lexer->ch_pos += 2; continue; } else { lexer->ch_pos++; continue; } break; } lexer->ch_pos++; } add_token(lexer, TOK_EOF, NULL); return; } void read_src(char **src) { // FILE *input = stdin; // fseek(input, 0, SEEK_END); // size_t input_size = ftell(input); // fseek(input, 0, SEEK_SET); // *src = malloc(input_size + 1); // fread(*src, 512, input_size / 512, input); // size_t remaining = input_size % 512; // fread(*src + input_size - remaining, 1, remaining, input); // (*src)[input_size] = '\0'; const char test_src[] = "{ vars\n" "fuck:int\n" "ccf:int\n" "}\n" ":set ccf, 38\n" ":set fuck, 250\n" ":yosoro 114514 - ccf + fuck\n" ; *src = malloc(sizeof(test_src)); memcpy(*src,test_src,sizeof(test_src)); } int main() { const char *src; read_src(&src); Lexer *lexer = lexer_create(src); lexer_tokenize(lexer); Parser *parser = parser_create(&lexer->toks); parser_parse(parser); Interpreter *interpreter = interpreter_create(&parser->stmts, &parser->var_decls); interpreter_execute(interpreter); interpreter_free(interpreter); parser_free(parser); lexer_free(lexer); free(src); return 0; } Parser *parser_create(DynArr *toks) { Parser *parser = malloc(sizeof(Parser)); parser->toks = toks; parser->pos = 0; da_init(&parser->stmts, sizeof(Stmt), 16); da_init(&parser->var_decls, sizeof(VarDecl), 16); return parser; } void free_operand(Operand *op); void free_expr(Expr *expr) { for (int i = 0; i < expr->terms.item_cnts; i++) { ExprTerm *term = da_get(&expr->terms, i); switch (term->typ) { case EXPR_TERM_CONST: continue; case EXPR_TERM_OPERAND: free_operand(&term->operand); break; } } da_free(&expr->terms); } void free_operand(Operand *op) { if (op->typ == OPERAND_ARR_ELEM) { free_expr(&op->idx_expr); } } void free_stmts(DynArr *stmts) { for (int i = 0; i < stmts->item_cnts; i++) { Stmt *stmt = da_get(stmts, i); switch (stmt->typ) { case STMT_YOSORO_CMD: free_expr(&stmt->inner.yosoro.expr); break; case STMT_SET_CMD: free_operand(&stmt->inner.set.operand); free_expr(&stmt->inner.set.expr); break; case STMT_IHU_BLK: free_expr(&stmt->inner.ihu.cond.left); free_expr(&stmt->inner.ihu.cond.right); free_stmts(&stmt->inner.ihu.stmts); break; case STMT_WHILE_BLK: free_expr(&stmt->inner.while_stmt.cond.left); free_expr(&stmt->inner.while_stmt.cond.right); free_stmts(&stmt->inner.while_stmt.stmts); break; case STMT_HOR_BLK: free_operand(&stmt->inner.hor.var); free_expr(&stmt->inner.hor.start); free_expr(&stmt->inner.hor.end); free_stmts(&stmt->inner.hor.stmts); } } da_free(stmts); } void parser_free(Parser *parser) { free_stmts(&parser->stmts); da_free(&parser->var_decls); free(parser); } static Token *current_token(Parser *parser) { if (parser->pos >= parser->toks->item_cnts) { return NULL; } return da_get(parser->toks, parser->pos); } static Token *peek_token(Parser *parser, size_t offset) { if (parser->pos + offset >= parser->toks->item_cnts) { return NULL; } return da_get(parser->toks, parser->pos + offset); } static void consume_token(Parser *parser) { parser->pos++; } static int match_token(Parser *parser, enum TokType typ) { Token *token = current_token(parser); return token && token->type == typ; } static Token *next_token(Parser *parser) { Token *token = current_token(parser); consume_token(parser); return token; } void parse_vars(Parser *parser) { consume_token(parser); consume_token(parser); DynArr *var_decls = &parser->var_decls; size_t cnt = 0; while (!match_token(parser, TOK_RBRACE)) { Token *ident = next_token(parser); consume_token(parser); VarDecl *decl = da_try_push_back(var_decls); decl->name = ident->str; if (match_token(parser, TOK_KEYWORD_INT)) { consume_token(parser); decl->typ = VAR_INT; } else if (match_token(parser, TOK_KEYWORD_ARRAY)) { consume_token(parser); consume_token(parser); consume_token(parser); consume_token(parser); decl->typ = VAR_ARR; decl->start = atoll(next_token(parser)->str); consume_token(parser); decl->end = atoll(next_token(parser)->str); consume_token(parser); } cnt++; } consume_token(parser); } void parse_blk(Parser *parser, DynArr *stmts); void parse_expr(Parser *parser, Expr *expr); size_t operand_finder(Parser *parser, const char *var_name, enum OperandTyp type) { enum VarType target_type = 0xff; switch (type) { case OPERAND_INT_VAR: target_type = VAR_INT; break; case OPERAND_ARR_ELEM: target_type = VAR_ARR; break; } for (int i = 0; i < parser->var_decls.item_cnts; i++) { VarDecl *decl = da_get(&parser->var_decls, i); if ((target_type == 0xff || decl->typ == target_type) && decl->name == var_name) { return i; } } return (size_t)-1; } void parse_operand(Parser *parser, Operand *operand) { Token *operand_tok = current_token(parser); consume_token(parser); operand->typ = OPERAND_INT_VAR; if (match_token(parser, TOK_LBRACKET)) { operand->typ = OPERAND_ARR_ELEM; consume_token(parser); parse_expr(parser, &operand->idx_expr); consume_token(parser); } operand->decl_idx = operand_finder(parser, operand_tok->str, operand->typ); } int is_operand_eq(Operand *a, Operand *b); int is_expr_eq(Expr *a, Expr *b) { int cnts = a->terms.item_cnts; if (cnts != b->terms.item_cnts) { return 0; } for (int i = 0; i < cnts; i++) { ExprTerm *a_term = da_get(&a->terms, i); ExprTerm *b_term = da_get(&b->terms, i); if (a_term->typ != b_term->typ) { return 0; } switch (a_term->typ) { case EXPR_TERM_CONST: return a_term->constant == b_term->constant; case EXPR_TERM_OPERAND: return is_operand_eq(&a_term->operand, &b_term->operand); } } return 1; } int is_operand_eq(Operand *a, Operand *b) { if (a->typ != b->typ || a->decl_idx != b->decl_idx) { return 0; } if (a->typ == OPERAND_INT_VAR) { return 1; } else { return is_expr_eq(&a->idx_expr, &b->idx_expr); } } void terms_add_operand(DynArr *terms, Operand op, int sign) { for (int i = 0; i < terms->item_cnts; i++) { ExprTerm *term = da_get(terms, i); if (term->typ == EXPR_TERM_OPERAND && is_operand_eq(&term->operand, &op)) { term->coefficient += sign; if (op.typ == OPERAND_ARR_ELEM) { da_free(&op.idx_expr.terms); } return; } } ExprTerm *term = da_try_push_back(terms); term->coefficient = sign; term->typ = EXPR_TERM_OPERAND; term->operand = op; return; } void parse_expr(Parser *parser, Expr *expr) { da_init(&expr->terms, sizeof(ExprTerm), 8); DynArr *terms = &expr->terms; int const_val = 0; short sign = 1; while (current_token(parser) && !(match_token(parser, TOK_EOF) || match_token(parser, TOK_COLON) || match_token(parser, TOK_COMMA) || match_token(parser, TOK_RBRACE) || match_token(parser, TOK_LBRACE) || match_token(parser, TOK_RBRACKET))) { sign = 1; if (match_token(parser, TOK_PLUS)) { consume_token(parser); } else if (match_token(parser, TOK_MINUS)) { sign = -1; consume_token(parser); } Token *term_tok = current_token(parser); if (term_tok->type == TOK_INT) { const_val += atoi(term_tok->str) * sign; consume_token(parser); continue; } Operand op; parse_operand(parser, &op); terms_add_operand(terms, op, sign); } if (const_val != 0 || terms->item_cnts == 0) { ExprTerm *const_term = da_try_push_back(terms); const_term->coefficient = 1; const_term->typ = EXPR_TERM_CONST; const_term->constant = const_val; } } void parse_cond(Parser *parser, Cond *cond) { cond->typ = next_token(parser)->type; consume_token(parser); parse_expr(parser, &cond->left); consume_token(parser); parse_expr(parser, &cond->right); } void parse_ihu(Parser *parser, Stmt *stmt) { consume_token(parser); consume_token(parser); stmt->typ = STMT_IHU_BLK; IhuStmt *ihu = &stmt->inner.ihu; parse_cond(parser, &ihu->cond); da_init(&ihu->stmts, sizeof(Stmt), 16); parse_blk(parser, &ihu->stmts); consume_token(parser); } void parse_while(Parser *parser, Stmt *stmt) { consume_token(parser); consume_token(parser); stmt->typ = STMT_WHILE_BLK; WhileStmt *while_stmt = &stmt->inner.while_stmt; parse_cond(parser, &while_stmt->cond); da_init(&while_stmt->stmts, sizeof(Stmt), 16); parse_blk(parser, &while_stmt->stmts); consume_token(parser); } void parse_hor(Parser *parser, Stmt *stmt) { consume_token(parser); consume_token(parser); stmt->typ = STMT_HOR_BLK; HorStmt *hor = &stmt->inner.hor; parse_operand(parser, &hor->var); consume_token(parser); parse_expr(parser, &hor->start); consume_token(parser); parse_expr(parser, &hor->end); da_init(&hor->stmts, sizeof(Stmt), 16); parse_blk(parser, &hor->stmts); consume_token(parser); } void parse_yosoro(Parser *parser, Stmt *stmt) { consume_token(parser); consume_token(parser); stmt->typ = STMT_YOSORO_CMD; YosoroStmt *yosoro = &stmt->inner.yosoro; parse_expr(parser, &yosoro->expr); } void parse_set(Parser *parser, Stmt *stmt) { consume_token(parser); consume_token(parser); stmt->typ = STMT_SET_CMD; SetStmt *set = &stmt->inner.set; parse_operand(parser, &set->operand); consume_token(parser); parse_expr(parser, &set->expr); } static void parse_stmts(Parser *parser, DynArr *stmts) { Token *tok = current_token(parser); if (!tok) { return; } Stmt *cur_stmt; switch (tok->type) { case TOK_LBRACE: tok = peek_token(parser, 1); if (!tok) { consume_token(parser); return; } switch (tok->type) { case TOK_KEYWORD_VARS: parse_vars(parser); break; case TOK_KEYWORD_IHU: cur_stmt = da_try_push_back(stmts); parse_ihu(parser, cur_stmt); break; case TOK_KEYWORD_WHILE: cur_stmt = da_try_push_back(stmts); parse_while(parser, cur_stmt); break; case TOK_KEYWORD_HOR: cur_stmt = da_try_push_back(stmts); parse_hor(parser, cur_stmt); break; default: break; } return; case TOK_COLON: tok = peek_token(parser, 1); if (!tok) { consume_token(parser); return; } cur_stmt = da_try_push_back(stmts); switch (tok->type) { case TOK_KEYWORD_YOSORO: parse_yosoro(parser, cur_stmt); break; case TOK_KEYWORD_SET: parse_set(parser, cur_stmt); break; default: break; } break; default: consume_token(parser); return; } } void parse_blk(Parser *parser, DynArr *stmts) { while (!match_token(parser, TOK_RBRACE) && parser->pos < parser->toks->item_cnts && !match_token(parser, TOK_EOF)) { parse_stmts(parser, stmts); } } DynArr *parser_parse(Parser *parser) { while (parser->pos < parser->toks->item_cnts && !match_token(parser, TOK_EOF)) { parse_stmts(parser, &parser->stmts); } return &parser->stmts; } void da_init(DynArr *dyn_arr, size_t item_size, size_t capacity) { dyn_arr->item_cnts = 0; dyn_arr->capacity = capacity; dyn_arr->item_size = item_size; dyn_arr->items = malloc(capacity * dyn_arr->item_size); } DynArr *da_create(size_t item_size, size_t capacity) { DynArr *dyn_arr = malloc(sizeof(DynArr)); da_init(dyn_arr, item_size, capacity); return dyn_arr; } void *da_try_push_back(DynArr *dyn_arr) { if (dyn_arr->item_cnts >= dyn_arr->capacity) { dyn_arr->capacity *= 2; dyn_arr->items = realloc(dyn_arr->items, dyn_arr->capacity * dyn_arr->item_size); } void *dest = dyn_arr->items + dyn_arr->item_cnts * dyn_arr->item_size; ++dyn_arr->item_cnts; return dest; } void *da_push_back(DynArr *dyn_arr, void *item) { void *dest = da_try_push_back(dyn_arr); memcpy(dest, item, dyn_arr->item_size); return dest; } void da_free(DynArr *dyn_arr) { free(dyn_arr->items); } void str_pool_init(StrPool *pool, size_t mempool_size, size_t capacity) { pool->mempool_size = mempool_size; pool->mempool = malloc(mempool_size); da_init(&pool->pool_nodes, sizeof(StrPoolNode), capacity); return; } StrPool *str_pool_create(size_t mempool_size, size_t capacity) { StrPool *pool = malloc(sizeof(StrPool)); str_pool_init(pool, mempool_size, capacity); return pool; } void str_pool_free(StrPool *str_pool) { StrPoolNode *node; for (size_t i = 0; i < str_pool->pool_nodes.item_cnts; i++) { node = da_get(&str_pool->pool_nodes, i); if (!node->alloc_by_pool) { free(node->str); } } da_free(&str_pool->pool_nodes); free(str_pool->mempool); return; } char *str_pool_intern(StrPool *str_pool, const char *string, size_t len) { StrPoolNode *dest_node = NULL; size_t str_node_cnts = str_pool->pool_nodes.item_cnts; for (size_t i = 0; i < str_node_cnts; i++) { dest_node = da_get(&str_pool->pool_nodes, i); if (dest_node->len == len && (strncmp(dest_node->str, string, len) == 0)) { return dest_node->str; } } dest_node = da_try_push_back(&str_pool->pool_nodes); dest_node->len = len; if (len + 1 < str_pool->mempool_size - str_pool->mempool_offset) { dest_node->alloc_by_pool = 1; dest_node->str = &str_pool->mempool[str_pool->mempool_offset]; str_pool->mempool_offset += len + 1; } else { dest_node->alloc_by_pool = 0; dest_node->str = malloc(len + 1); } memcpy(dest_node->str, string, len); dest_node->str[len] = '\0'; return dest_node->str; }

Public snippets