diff options
Diffstat (limited to 'src/parser.cpp')
| -rw-r--r-- | src/parser.cpp | 4255 |
1 files changed, 4255 insertions, 0 deletions
diff --git a/src/parser.cpp b/src/parser.cpp new file mode 100644 index 000000000..ed87b2cb2 --- /dev/null +++ b/src/parser.cpp @@ -0,0 +1,4255 @@ +typedef struct AstNode AstNode; +typedef struct Scope Scope; +typedef struct DeclInfo DeclInfo; + +typedef enum ParseFileError { + ParseFile_None, + + ParseFile_WrongExtension, + ParseFile_InvalidFile, + ParseFile_EmptyFile, + ParseFile_Permission, + ParseFile_NotFound, + ParseFile_InvalidToken, + + ParseFile_Count, +} ParseFileError; + +typedef Array(AstNode *) AstNodeArray; + +typedef struct AstFile { + i32 id; + gbArena arena; + Tokenizer tokenizer; + Array(Token) tokens; + isize curr_token_index; + Token curr_token; + Token prev_token; // previous non-comment + + // >= 0: In Expression + // < 0: In Control Clause + // NOTE(bill): Used to prevent type literals in control clauses + isize expr_level; + bool allow_range; // NOTE(bill): Ranges are only allowed in certain cases + + AstNodeArray decls; + bool is_global_scope; + + AstNode * curr_proc; + isize scope_level; + Scope * scope; // NOTE(bill): Created in checker + DeclInfo * decl_info; // NOTE(bill): Created in checker + + // TODO(bill): Error recovery +#define PARSER_MAX_FIX_COUNT 6 + isize fix_count; + TokenPos fix_prev_pos; +} AstFile; + +typedef struct ImportedFile { + String path; + String rel_path; + TokenPos pos; // #import +} ImportedFile; + +typedef struct Parser { + String init_fullpath; + Array(AstFile) files; + Array(ImportedFile) imports; + gbAtomic32 import_index; + isize total_token_count; + isize total_line_count; + gbMutex mutex; +} Parser; + +typedef enum ProcTag { + ProcTag_bounds_check = 1<<0, + ProcTag_no_bounds_check = 1<<1, + + ProcTag_require_results = 1<<4, + + ProcTag_foreign = 1<<10, + ProcTag_export = 1<<11, + ProcTag_link_name = 1<<12, + ProcTag_inline = 1<<13, + ProcTag_no_inline = 1<<14, + // ProcTag_dll_import = 1<<15, + // ProcTag_dll_export = 1<<16, +} ProcTag; + +typedef enum ProcCallingConvention { + ProcCC_Odin = 0, + ProcCC_C = 1, + ProcCC_Std = 2, + ProcCC_Fast = 3, + + ProcCC_Invalid, +} ProcCallingConvention; + +typedef enum VarDeclFlag { + VarDeclFlag_using = 1<<0, + VarDeclFlag_immutable = 1<<1, + VarDeclFlag_thread_local = 1<<2, +} VarDeclFlag; + +typedef enum StmtStateFlag { + StmtStateFlag_bounds_check = 1<<0, + StmtStateFlag_no_bounds_check = 1<<1, +} StmtStateFlag; + +typedef enum FieldFlag { + FieldFlag_ellipsis = 1<<0, + FieldFlag_using = 1<<1, + FieldFlag_no_alias = 1<<2, + FieldFlag_immutable = 1<<3, + + FieldFlag_Signature = FieldFlag_ellipsis|FieldFlag_using|FieldFlag_no_alias|FieldFlag_immutable, +} FieldListTag; + +typedef enum StmtAllowFlag { + StmtAllowFlag_None = 0, + StmtAllowFlag_In = 1<<0, + StmtAllowFlag_Label = 1<<1, +} StmtAllowFlag; + + + +AstNodeArray make_ast_node_array(AstFile *f) { + AstNodeArray a; + // array_init(&a, gb_arena_allocator(&f->arena)); + array_init(&a, heap_allocator()); + return a; +} + + +// NOTE(bill): This massive define is so it is possible to create a discriminated union (and extra debug info) +// for the AstNode. I personally prefer discriminated unions over subtype polymorphism as I can preallocate +// all the nodes and even memcpy in a different kind of node +#define AST_NODE_KINDS \ + AST_NODE_KIND(Ident, "identifier", Token) \ + AST_NODE_KIND(Implicit, "implicit", Token) \ + AST_NODE_KIND(BasicLit, "basic literal", Token) \ + AST_NODE_KIND(BasicDirective, "basic directive", struct { \ + Token token; \ + String name; \ + }) \ + AST_NODE_KIND(Ellipsis, "ellipsis", struct { \ + Token token; \ + AstNode *expr; \ + }) \ + AST_NODE_KIND(ProcLit, "procedure literal", struct { \ + AstNode *type; \ + AstNode *body; \ + u64 tags; \ + AstNode *foreign_library; \ + String foreign_name; \ + String link_name; \ + }) \ + AST_NODE_KIND(CompoundLit, "compound literal", struct { \ + AstNode *type; \ + AstNodeArray elems; \ + Token open, close; \ + }) \ + AST_NODE_KIND(Alias, "alias", struct { \ + Token token; \ + AstNode *expr; \ + }) \ +AST_NODE_KIND(_ExprBegin, "", i32) \ + AST_NODE_KIND(BadExpr, "bad expression", struct { Token begin, end; }) \ + AST_NODE_KIND(TagExpr, "tag expression", struct { Token token, name; AstNode *expr; }) \ + AST_NODE_KIND(RunExpr, "run expression", struct { Token token, name; AstNode *expr; }) \ + AST_NODE_KIND(UnaryExpr, "unary expression", struct { Token op; AstNode *expr; }) \ + AST_NODE_KIND(BinaryExpr, "binary expression", struct { Token op; AstNode *left, *right; } ) \ + AST_NODE_KIND(ParenExpr, "parentheses expression", struct { AstNode *expr; Token open, close; }) \ + AST_NODE_KIND(SelectorExpr, "selector expression", struct { Token token; AstNode *expr, *selector; }) \ + AST_NODE_KIND(IndexExpr, "index expression", struct { AstNode *expr, *index; Token open, close; }) \ + AST_NODE_KIND(DerefExpr, "dereference expression", struct { Token op; AstNode *expr; }) \ + AST_NODE_KIND(SliceExpr, "slice expression", struct { \ + AstNode *expr; \ + Token open, close; \ + Token interval0; \ + Token interval1; \ + bool index3; \ + AstNode *low, *high, *max; \ + }) \ + AST_NODE_KIND(CallExpr, "call expression", struct { \ + AstNode * proc; \ + AstNodeArray args; \ + Token open; \ + Token close; \ + Token ellipsis; \ + }) \ + AST_NODE_KIND(MacroCallExpr, "macro call expression", struct { \ + AstNode * macro; \ + Token bang; \ + AstNodeArray args; \ + Token open; \ + Token close; \ + }) \ + AST_NODE_KIND(FieldValue, "field value", struct { Token eq; AstNode *field, *value; }) \ + AST_NODE_KIND(TernaryExpr, "ternary expression", struct { AstNode *cond, *x, *y; }) \ + AST_NODE_KIND(TypeAssertion, "type assertion", struct { AstNode *expr; Token dot; AstNode *type; }) \ +AST_NODE_KIND(_ExprEnd, "", i32) \ +AST_NODE_KIND(_StmtBegin, "", i32) \ + AST_NODE_KIND(BadStmt, "bad statement", struct { Token begin, end; }) \ + AST_NODE_KIND(EmptyStmt, "empty statement", struct { Token token; }) \ + AST_NODE_KIND(ExprStmt, "expression statement", struct { AstNode *expr; } ) \ + AST_NODE_KIND(TagStmt, "tag statement", struct { \ + Token token; \ + Token name; \ + AstNode *stmt; \ + }) \ + AST_NODE_KIND(AssignStmt, "assign statement", struct { \ + Token op; \ + AstNodeArray lhs, rhs; \ + }) \ + AST_NODE_KIND(IncDecStmt, "increment decrement statement", struct { \ + Token op; \ + AstNode *expr; \ + }) \ +AST_NODE_KIND(_ComplexStmtBegin, "", i32) \ + AST_NODE_KIND(BlockStmt, "block statement", struct { \ + AstNodeArray stmts; \ + Token open, close; \ + }) \ + AST_NODE_KIND(IfStmt, "if statement", struct { \ + Token token; \ + AstNode *init; \ + AstNode *cond; \ + AstNode *body; \ + AstNode *else_stmt; \ + }) \ + AST_NODE_KIND(WhenStmt, "when statement", struct { \ + Token token; \ + AstNode *cond; \ + AstNode *body; \ + AstNode *else_stmt; \ + }) \ + AST_NODE_KIND(ReturnStmt, "return statement", struct { \ + Token token; \ + AstNodeArray results; \ + }) \ + AST_NODE_KIND(ForStmt, "for statement", struct { \ + Token token; \ + AstNode *label; \ + AstNode *init; \ + AstNode *cond; \ + AstNode *post; \ + AstNode *body; \ + }) \ + AST_NODE_KIND(RangeStmt, "range statement", struct { \ + Token token; \ + AstNode *label; \ + AstNode *value; \ + AstNode *index; \ + Token in_token; \ + AstNode *expr; \ + AstNode *body; \ + }) \ + AST_NODE_KIND(CaseClause, "case clause", struct { \ + Token token; \ + AstNodeArray list; \ + AstNodeArray stmts; \ + }) \ + AST_NODE_KIND(MatchStmt, "match statement", struct { \ + Token token; \ + AstNode *label; \ + AstNode *init; \ + AstNode *tag; \ + AstNode *body; \ + }) \ + AST_NODE_KIND(TypeMatchStmt, "type match statement", struct { \ + Token token; \ + AstNode *label; \ + AstNode *tag; \ + AstNode *body; \ + }) \ + AST_NODE_KIND(DeferStmt, "defer statement", struct { Token token; AstNode *stmt; }) \ + AST_NODE_KIND(BranchStmt, "branch statement", struct { Token token; AstNode *label; }) \ + AST_NODE_KIND(UsingStmt, "using statement", struct { \ + Token token; \ + AstNodeArray list; \ + }) \ + AST_NODE_KIND(AsmOperand, "assembly operand", struct { \ + Token string; \ + AstNode *operand; \ + }) \ + AST_NODE_KIND(AsmStmt, "assembly statement", struct { \ + Token token; \ + bool is_volatile; \ + Token open, close; \ + Token code_string; \ + AstNode *output_list; \ + AstNode *input_list; \ + AstNode *clobber_list; \ + isize output_count, input_count, clobber_count; \ + }) \ + AST_NODE_KIND(PushAllocator, "push_allocator statement", struct { \ + Token token; \ + AstNode *expr; \ + AstNode *body; \ + }) \ + AST_NODE_KIND(PushContext, "push_context statement", struct { \ + Token token; \ + AstNode *expr; \ + AstNode *body; \ + }) \ +AST_NODE_KIND(_ComplexStmtEnd, "", i32) \ +AST_NODE_KIND(_StmtEnd, "", i32) \ +AST_NODE_KIND(_DeclBegin, "", i32) \ + AST_NODE_KIND(BadDecl, "bad declaration", struct { Token begin, end; }) \ + AST_NODE_KIND(ValueDecl, "value declaration", struct { \ + bool is_var; \ + AstNodeArray names; \ + AstNode * type; \ + AstNodeArray values; \ + u32 flags; \ + }) \ + AST_NODE_KIND(ImportDecl, "import declaration", struct { \ + Token token; \ + bool is_import; \ + Token relpath; \ + String fullpath; \ + Token import_name; \ + AstNode *cond; \ + AstNode *note; \ + }) \ + AST_NODE_KIND(ForeignLibrary, "foreign library", struct { \ + Token token, filepath; \ + Token library_name; \ + String base_dir; \ + AstNode *cond; \ + bool is_system; \ + }) \ + AST_NODE_KIND(Label, "label", struct { \ + Token token; \ + AstNode *name; \ + }) \ +AST_NODE_KIND(_DeclEnd, "", i32) \ + AST_NODE_KIND(Field, "field", struct { \ + AstNodeArray names; \ + AstNode * type; \ + u32 flags; \ + }) \ + AST_NODE_KIND(FieldList, "field list", struct { \ + Token token; \ + AstNodeArray list; \ + }) \ + AST_NODE_KIND(UnionField, "union field", struct { \ + AstNode *name; \ + AstNode *list; \ + }) \ +AST_NODE_KIND(_TypeBegin, "", i32) \ + AST_NODE_KIND(HelperType, "type", struct { \ + Token token; \ + AstNode *type; \ + }) \ + AST_NODE_KIND(ProcType, "procedure type", struct { \ + Token token; \ + AstNode *params; \ + AstNode *results; \ + u64 tags; \ + ProcCallingConvention calling_convention; \ + }) \ + AST_NODE_KIND(PointerType, "pointer type", struct { \ + Token token; \ + AstNode *type; \ + }) \ + AST_NODE_KIND(AtomicType, "atomic type", struct { \ + Token token; \ + AstNode *type; \ + }) \ + AST_NODE_KIND(ArrayType, "array type", struct { \ + Token token; \ + AstNode *count; \ + AstNode *elem; \ + }) \ + AST_NODE_KIND(DynamicArrayType, "dynamic array type", struct { \ + Token token; \ + AstNode *elem; \ + }) \ + AST_NODE_KIND(VectorType, "vector type", struct { \ + Token token; \ + AstNode *count; \ + AstNode *elem; \ + }) \ + AST_NODE_KIND(StructType, "struct type", struct { \ + Token token; \ + AstNodeArray fields; \ + isize field_count; \ + bool is_packed; \ + bool is_ordered; \ + AstNode *align; \ + }) \ + AST_NODE_KIND(UnionType, "union type", struct { \ + Token token; \ + AstNodeArray fields; \ + isize field_count; \ + AstNodeArray variants; \ + }) \ + AST_NODE_KIND(RawUnionType, "raw union type", struct { \ + Token token; \ + AstNodeArray fields; \ + isize field_count; \ + }) \ + AST_NODE_KIND(EnumType, "enum type", struct { \ + Token token; \ + AstNode *base_type; \ + AstNodeArray fields; /* FieldValue */ \ + }) \ + AST_NODE_KIND(BitFieldType, "bit field type", struct { \ + Token token; \ + AstNodeArray fields; /* FieldValue with : */ \ + AstNode *align; \ + }) \ + AST_NODE_KIND(MapType, "map type", struct { \ + Token token; \ + AstNode *count; \ + AstNode *key; \ + AstNode *value; \ + }) \ +AST_NODE_KIND(_TypeEnd, "", i32) + +typedef enum AstNodeKind { + AstNode_Invalid, +#define AST_NODE_KIND(_kind_name_, ...) GB_JOIN2(AstNode_, _kind_name_), + AST_NODE_KINDS +#undef AST_NODE_KIND + AstNode_Count, +} AstNodeKind; + +String const ast_node_strings[] = { + {cast(u8 *)"invalid node", gb_size_of("invalid node")}, +#define AST_NODE_KIND(_kind_name_, name, ...) {cast(u8 *)name, gb_size_of(name)-1}, + AST_NODE_KINDS +#undef AST_NODE_KIND +}; + +#define AST_NODE_KIND(_kind_name_, name, ...) typedef __VA_ARGS__ GB_JOIN2(AstNode, _kind_name_); + AST_NODE_KINDS +#undef AST_NODE_KIND + +typedef struct AstNode { + AstNodeKind kind; + u32 stmt_state_flags; + union { +#define AST_NODE_KIND(_kind_name_, name, ...) GB_JOIN2(AstNode, _kind_name_) _kind_name_; + AST_NODE_KINDS +#undef AST_NODE_KIND + }; +} AstNode; + + +#define ast_node(n_, Kind_, node_) GB_JOIN2(AstNode, Kind_) *n_ = &(node_)->Kind_; GB_ASSERT((node_)->kind == GB_JOIN2(AstNode_, Kind_)) +#define case_ast_node(n_, Kind_, node_) case GB_JOIN2(AstNode_, Kind_): { ast_node(n_, Kind_, node_); +#ifndef case_end +#define case_end } break; +#endif + + +gb_inline bool is_ast_node_expr(AstNode *node) { + return gb_is_between(node->kind, AstNode__ExprBegin+1, AstNode__ExprEnd-1); +} +gb_inline bool is_ast_node_stmt(AstNode *node) { + return gb_is_between(node->kind, AstNode__StmtBegin+1, AstNode__StmtEnd-1); +} +gb_inline bool is_ast_node_complex_stmt(AstNode *node) { + return gb_is_between(node->kind, AstNode__ComplexStmtBegin+1, AstNode__ComplexStmtEnd-1); +} +gb_inline bool is_ast_node_decl(AstNode *node) { + return gb_is_between(node->kind, AstNode__DeclBegin+1, AstNode__DeclEnd-1); +} +gb_inline bool is_ast_node_type(AstNode *node) { + return gb_is_between(node->kind, AstNode__TypeBegin+1, AstNode__TypeEnd-1); +} +gb_inline bool is_ast_node_when_stmt(AstNode *node) { + return node->kind == AstNode_WhenStmt; +} + + +Token ast_node_token(AstNode *node) { + switch (node->kind) { + case AstNode_Ident: return node->Ident; + case AstNode_Implicit: return node->Implicit; + case AstNode_BasicLit: return node->BasicLit; + case AstNode_BasicDirective: return node->BasicDirective.token; + case AstNode_ProcLit: return ast_node_token(node->ProcLit.type); + case AstNode_CompoundLit: + if (node->CompoundLit.type != NULL) { + return ast_node_token(node->CompoundLit.type); + } + return node->CompoundLit.open; + case AstNode_Alias: return node->Alias.token; + + case AstNode_TagExpr: return node->TagExpr.token; + case AstNode_RunExpr: return node->RunExpr.token; + case AstNode_BadExpr: return node->BadExpr.begin; + case AstNode_UnaryExpr: return node->UnaryExpr.op; + case AstNode_BinaryExpr: return ast_node_token(node->BinaryExpr.left); + case AstNode_ParenExpr: return node->ParenExpr.open; + case AstNode_CallExpr: return ast_node_token(node->CallExpr.proc); + case AstNode_MacroCallExpr: return ast_node_token(node->MacroCallExpr.macro); + case AstNode_SelectorExpr: + if (node->SelectorExpr.selector != NULL) { + return ast_node_token(node->SelectorExpr.selector); + } + return node->SelectorExpr.token; + case AstNode_IndexExpr: return node->IndexExpr.open; + case AstNode_SliceExpr: return node->SliceExpr.open; + case AstNode_Ellipsis: return node->Ellipsis.token; + case AstNode_FieldValue: return node->FieldValue.eq; + case AstNode_DerefExpr: return node->DerefExpr.op; + case AstNode_TernaryExpr: return ast_node_token(node->TernaryExpr.cond); + case AstNode_TypeAssertion: return ast_node_token(node->TypeAssertion.expr); + + case AstNode_BadStmt: return node->BadStmt.begin; + case AstNode_EmptyStmt: return node->EmptyStmt.token; + case AstNode_ExprStmt: return ast_node_token(node->ExprStmt.expr); + case AstNode_TagStmt: return node->TagStmt.token; + case AstNode_AssignStmt: return node->AssignStmt.op; + case AstNode_IncDecStmt: return ast_node_token(node->IncDecStmt.expr); + case AstNode_BlockStmt: return node->BlockStmt.open; + case AstNode_IfStmt: return node->IfStmt.token; + case AstNode_WhenStmt: return node->WhenStmt.token; + case AstNode_ReturnStmt: return node->ReturnStmt.token; + case AstNode_ForStmt: return node->ForStmt.token; + case AstNode_RangeStmt: return node->RangeStmt.token; + case AstNode_CaseClause: return node->CaseClause.token; + case AstNode_MatchStmt: return node->MatchStmt.token; + case AstNode_TypeMatchStmt: return node->TypeMatchStmt.token; + case AstNode_DeferStmt: return node->DeferStmt.token; + case AstNode_BranchStmt: return node->BranchStmt.token; + case AstNode_UsingStmt: return node->UsingStmt.token; + case AstNode_AsmStmt: return node->AsmStmt.token; + case AstNode_PushAllocator: return node->PushAllocator.token; + case AstNode_PushContext: return node->PushContext.token; + + case AstNode_BadDecl: return node->BadDecl.begin; + case AstNode_ValueDecl: return ast_node_token(node->ValueDecl.names.e[0]); + case AstNode_ImportDecl: return node->ImportDecl.token; + case AstNode_ForeignLibrary: return node->ForeignLibrary.token; + case AstNode_Label: return node->Label.token; + + + case AstNode_Field: + if (node->Field.names.count > 0) { + return ast_node_token(node->Field.names.e[0]); + } + return ast_node_token(node->Field.type); + case AstNode_FieldList: + return node->FieldList.token; + case AstNode_UnionField: + return ast_node_token(node->UnionField.name); + + case AstNode_HelperType: return node->HelperType.token; + case AstNode_ProcType: return node->ProcType.token; + case AstNode_PointerType: return node->PointerType.token; + case AstNode_AtomicType: return node->AtomicType.token; + case AstNode_ArrayType: return node->ArrayType.token; + case AstNode_DynamicArrayType: return node->DynamicArrayType.token; + case AstNode_VectorType: return node->VectorType.token; + case AstNode_StructType: return node->StructType.token; + case AstNode_UnionType: return node->UnionType.token; + case AstNode_RawUnionType: return node->RawUnionType.token; + case AstNode_EnumType: return node->EnumType.token; + case AstNode_BitFieldType: return node->BitFieldType.token; + case AstNode_MapType: return node->MapType.token; + } + + return empty_token; +} + +AstNode *clone_ast_node(gbAllocator a, AstNode *node); +AstNodeArray clone_ast_node_array(gbAllocator a, AstNodeArray array) { + AstNodeArray result = {}; + if (array.count > 0) { + array_init_count(&result, a, array.count); + for_array(i, array) { + result.e[i] = clone_ast_node(a, array.e[i]); + } + } + return result; +} + +AstNode *clone_ast_node(gbAllocator a, AstNode *node) { + if (node == NULL) { + return NULL; + } + AstNode *n = gb_alloc_item(a, AstNode); + gb_memmove(n, node, gb_size_of(AstNode)); + + switch (n->kind) { + case AstNode_Ident: break; + case AstNode_Implicit: break; + case AstNode_BasicLit: break; + case AstNode_BasicDirective: break; + case AstNode_Ellipsis: + n->Ellipsis.expr = clone_ast_node(a, n->Ellipsis.expr); + break; + case AstNode_ProcLit: + n->ProcLit.type = clone_ast_node(a, n->ProcLit.type); + n->ProcLit.body = clone_ast_node(a, n->ProcLit.body); + n->ProcLit.foreign_library = clone_ast_node(a, n->ProcLit.foreign_library); + break; + case AstNode_CompoundLit: + n->CompoundLit.type = clone_ast_node(a, n->CompoundLit.type); + n->CompoundLit.elems = clone_ast_node_array(a, n->CompoundLit.elems); + break; + case AstNode_Alias: + n->Alias.expr = clone_ast_node(a, n->Alias.expr); + break; + + case AstNode_BadExpr: break; + case AstNode_TagExpr: + n->TagExpr.expr = clone_ast_node(a, n->TagExpr.expr); + break; + case AstNode_RunExpr: + n->RunExpr.expr = clone_ast_node(a, n->RunExpr.expr); + break; + case AstNode_UnaryExpr: + n->RunExpr.expr = clone_ast_node(a, n->RunExpr.expr); + break; + case AstNode_BinaryExpr: + n->BinaryExpr.left = clone_ast_node(a, n->BinaryExpr.left); + n->BinaryExpr.right = clone_ast_node(a, n->BinaryExpr.right); + break; + case AstNode_ParenExpr: + n->ParenExpr.expr = clone_ast_node(a, n->ParenExpr.expr); + break; + case AstNode_SelectorExpr: + n->SelectorExpr.expr = clone_ast_node(a, n->SelectorExpr.expr); + n->SelectorExpr.selector = clone_ast_node(a, n->SelectorExpr.selector); + break; + case AstNode_IndexExpr: + n->IndexExpr.expr = clone_ast_node(a, n->IndexExpr.expr); + n->IndexExpr.index = clone_ast_node(a, n->IndexExpr.index); + break; + case AstNode_DerefExpr: + n->DerefExpr.expr = clone_ast_node(a, n->DerefExpr.expr); + break; + case AstNode_SliceExpr: + n->SliceExpr.expr = clone_ast_node(a, n->SliceExpr.expr); + n->SliceExpr.low = clone_ast_node(a, n->SliceExpr.low); + n->SliceExpr.high = clone_ast_node(a, n->SliceExpr.high); + n->SliceExpr.max = clone_ast_node(a, n->SliceExpr.max); + break; + case AstNode_CallExpr: + n->CallExpr.proc = clone_ast_node(a, n->CallExpr.proc); + n->CallExpr.args = clone_ast_node_array(a, n->CallExpr.args); + break; + case AstNode_MacroCallExpr: + n->MacroCallExpr.macro = clone_ast_node(a, n->MacroCallExpr.macro); + n->MacroCallExpr.args = clone_ast_node_array(a, n->MacroCallExpr.args); + break; + + case AstNode_FieldValue: + n->FieldValue.field = clone_ast_node(a, n->FieldValue.field); + n->FieldValue.value = clone_ast_node(a, n->FieldValue.value); + break; + + case AstNode_TernaryExpr: + n->TernaryExpr.cond = clone_ast_node(a, n->TernaryExpr.cond); + n->TernaryExpr.x = clone_ast_node(a, n->TernaryExpr.x); + n->TernaryExpr.y = clone_ast_node(a, n->TernaryExpr.cond); + break; + case AstNode_TypeAssertion: + n->TypeAssertion.expr = clone_ast_node(a, n->TypeAssertion.expr); + n->TypeAssertion.type = clone_ast_node(a, n->TypeAssertion.type); + break; + + case AstNode_BadStmt: break; + case AstNode_EmptyStmt: break; + case AstNode_ExprStmt: + n->ExprStmt.expr = clone_ast_node(a, n->ExprStmt.expr); + break; + case AstNode_TagStmt: + n->TagStmt.stmt = clone_ast_node(a, n->TagStmt.stmt); + break; + case AstNode_AssignStmt: + n->AssignStmt.lhs = clone_ast_node_array(a, n->AssignStmt.lhs); + n->AssignStmt.rhs = clone_ast_node_array(a, n->AssignStmt.rhs); + break; + case AstNode_IncDecStmt: + n->IncDecStmt.expr = clone_ast_node(a, n->IncDecStmt.expr); + break; + case AstNode_BlockStmt: + n->BlockStmt.stmts = clone_ast_node_array(a, n->BlockStmt.stmts); + break; + case AstNode_IfStmt: + n->IfStmt.init = clone_ast_node(a, n->IfStmt.init); + n->IfStmt.cond = clone_ast_node(a, n->IfStmt.cond); + n->IfStmt.body = clone_ast_node(a, n->IfStmt.body); + n->IfStmt.else_stmt = clone_ast_node(a, n->IfStmt.else_stmt); + break; + case AstNode_WhenStmt: + n->WhenStmt.cond = clone_ast_node(a, n->WhenStmt.cond); + n->WhenStmt.body = clone_ast_node(a, n->WhenStmt.body); + n->WhenStmt.else_stmt = clone_ast_node(a, n->WhenStmt.else_stmt); + break; + case AstNode_ReturnStmt: + n->ReturnStmt.results = clone_ast_node_array(a, n->ReturnStmt.results); + break; + case AstNode_ForStmt: + n->ForStmt.label = clone_ast_node(a, n->ForStmt.label); + n->ForStmt.init = clone_ast_node(a, n->ForStmt.init); + n->ForStmt.cond = clone_ast_node(a, n->ForStmt.cond); + n->ForStmt.post = clone_ast_node(a, n->ForStmt.post); + n->ForStmt.body = clone_ast_node(a, n->ForStmt.body); + break; + case AstNode_RangeStmt: + n->RangeStmt.label = clone_ast_node(a, n->RangeStmt.label); + n->RangeStmt.value = clone_ast_node(a, n->RangeStmt.value); + n->RangeStmt.index = clone_ast_node(a, n->RangeStmt.index); + n->RangeStmt.expr = clone_ast_node(a, n->RangeStmt.expr); + n->RangeStmt.body = clone_ast_node(a, n->RangeStmt.body); + break; + case AstNode_CaseClause: + n->CaseClause.list = clone_ast_node_array(a, n->CaseClause.list); + n->CaseClause.stmts = clone_ast_node_array(a, n->CaseClause.stmts); + break; + case AstNode_MatchStmt: + n->MatchStmt.label = clone_ast_node(a, n->MatchStmt.label); + n->MatchStmt.init = clone_ast_node(a, n->MatchStmt.init); + n->MatchStmt.tag = clone_ast_node(a, n->MatchStmt.tag); + n->MatchStmt.body = clone_ast_node(a, n->MatchStmt.body); + break; + case AstNode_TypeMatchStmt: + n->TypeMatchStmt.label = clone_ast_node(a, n->TypeMatchStmt.label); + n->TypeMatchStmt.tag = clone_ast_node(a, n->TypeMatchStmt.tag); + n->TypeMatchStmt.body = clone_ast_node(a, n->TypeMatchStmt.body); + break; + case AstNode_DeferStmt: + n->DeferStmt.stmt = clone_ast_node(a, n->DeferStmt.stmt); + break; + case AstNode_BranchStmt: + n->BranchStmt.label = clone_ast_node(a, n->BranchStmt.label); + break; + case AstNode_UsingStmt: + n->UsingStmt.list = clone_ast_node_array(a, n->UsingStmt.list); + break; + case AstNode_AsmOperand: + n->AsmOperand.operand = clone_ast_node(a, n->AsmOperand.operand); + break; + case AstNode_AsmStmt: + n->AsmStmt.output_list = clone_ast_node(a, n->AsmStmt.output_list); + n->AsmStmt.input_list = clone_ast_node(a, n->AsmStmt.input_list); + n->AsmStmt.clobber_list = clone_ast_node(a, n->AsmStmt.clobber_list); + break; + case AstNode_PushAllocator: + n->PushAllocator.expr = clone_ast_node(a, n->PushAllocator.expr); + n->PushAllocator.body = clone_ast_node(a, n->PushAllocator.body); + break; + case AstNode_PushContext: + n->PushContext.expr = clone_ast_node(a, n->PushContext.expr); + n->PushContext.body = clone_ast_node(a, n->PushContext.body); + break; + + case AstNode_BadDecl: break; + case AstNode_ValueDecl: + n->ValueDecl.names = clone_ast_node_array(a, n->ValueDecl.names); + n->ValueDecl.type = clone_ast_node(a, n->ValueDecl.type); + n->ValueDecl.values = clone_ast_node_array(a, n->ValueDecl.values); + break; + case AstNode_ImportDecl: + n->ImportDecl.cond = clone_ast_node(a, n->ImportDecl.cond); + n->ImportDecl.note = clone_ast_node(a, n->ImportDecl.note); + break; + case AstNode_ForeignLibrary: + n->ForeignLibrary.cond = clone_ast_node(a, n->ForeignLibrary.cond); + break; + case AstNode_Label: + n->Label.name = clone_ast_node(a, n->Label.name); + break; + + + case AstNode_Field: + n->Field.names = clone_ast_node_array(a, n->Field.names); + n->Field.type = clone_ast_node(a, n->Field.type); + break; + case AstNode_FieldList: + n->FieldList.list = clone_ast_node_array(a, n->FieldList.list); + break; + case AstNode_UnionField: + n->UnionField.name = clone_ast_node(a, n->UnionField.name); + n->UnionField.list = clone_ast_node(a, n->UnionField.list); + break; + + case AstNode_HelperType: + n->HelperType.type = clone_ast_node(a, n->HelperType.type); + break; + case AstNode_ProcType: + break; + case AstNode_PointerType: + n->PointerType.type = clone_ast_node(a, n->PointerType.type); + break; + case AstNode_AtomicType: + n->AtomicType.type = clone_ast_node(a, n->AtomicType.type); + break; + case AstNode_ArrayType: + n->ArrayType.count = clone_ast_node(a, n->ArrayType.count); + n->ArrayType.elem = clone_ast_node(a, n->ArrayType.elem); + break; + case AstNode_DynamicArrayType: + n->DynamicArrayType.elem = clone_ast_node(a, n->DynamicArrayType.elem); + break; + case AstNode_VectorType: + n->VectorType.count = clone_ast_node(a, n->VectorType.count); + n->VectorType.elem = clone_ast_node(a, n->VectorType.elem); + break; + case AstNode_StructType: + n->StructType.fields = clone_ast_node_array(a, n->StructType.fields); + break; + case AstNode_UnionType: + n->UnionType.fields = clone_ast_node_array(a, n->UnionType.fields); + n->UnionType.variants = clone_ast_node_array(a, n->UnionType.variants); + break; + case AstNode_RawUnionType: + n->RawUnionType.fields = clone_ast_node_array(a, n->RawUnionType.fields); + break; + case AstNode_EnumType: + n->EnumType.base_type = clone_ast_node(a, n->EnumType.base_type); + n->EnumType.fields = clone_ast_node_array(a, n->EnumType.fields); + break; + case AstNode_BitFieldType: + n->BitFieldType.fields = clone_ast_node_array(a, n->BitFieldType.fields); + n->BitFieldType.align = clone_ast_node(a, n->BitFieldType.align); + case AstNode_MapType: + n->MapType.count = clone_ast_node(a, n->MapType.count); + n->MapType.key = clone_ast_node(a, n->MapType.key); + n->MapType.value = clone_ast_node(a, n->MapType.value); + break; + } + + return n; +} + + +void error_node(AstNode *node, char *fmt, ...) { + va_list va; + va_start(va, fmt); + error_va(ast_node_token(node), fmt, va); + va_end(va); +} + +void warning_node(AstNode *node, char *fmt, ...) { + va_list va; + va_start(va, fmt); + warning_va(ast_node_token(node), fmt, va); + va_end(va); +} + +void syntax_error_node(AstNode *node, char *fmt, ...) { + va_list va; + va_start(va, fmt); + syntax_error_va(ast_node_token(node), fmt, va); + va_end(va); +} + + +bool ast_node_expect(AstNode *node, AstNodeKind kind) { + if (node->kind != kind) { + error_node(node, "Expected %.*s, got %.*s", LIT(ast_node_strings[node->kind])); + return false; + } + return true; +} + + +// NOTE(bill): And this below is why is I/we need a new language! Discriminated unions are a pain in C/C++ +AstNode *make_ast_node(AstFile *f, AstNodeKind kind) { + gbArena *arena = &f->arena; + if (gb_arena_size_remaining(arena, GB_DEFAULT_MEMORY_ALIGNMENT) <= gb_size_of(AstNode)) { + // NOTE(bill): If a syntax error is so bad, just quit! + gb_exit(1); + } + AstNode *node = gb_alloc_item(gb_arena_allocator(arena), AstNode); + node->kind = kind; + return node; +} + +AstNode *ast_bad_expr(AstFile *f, Token begin, Token end) { + AstNode *result = make_ast_node(f, AstNode_BadExpr); + result->BadExpr.begin = begin; + result->BadExpr.end = end; + return result; +} + +AstNode *ast_tag_expr(AstFile *f, Token token, Token name, AstNode *expr) { + AstNode *result = make_ast_node(f, AstNode_TagExpr); + result->TagExpr.token = token; + result->TagExpr.name = name; + result->TagExpr.expr = expr; + return result; +} + +AstNode *ast_run_expr(AstFile *f, Token token, Token name, AstNode *expr) { + AstNode *result = make_ast_node(f, AstNode_RunExpr); + result->RunExpr.token = token; + result->RunExpr.name = name; + result->RunExpr.expr = expr; + return result; +} + + +AstNode *ast_tag_stmt(AstFile *f, Token token, Token name, AstNode *stmt) { + AstNode *result = make_ast_node(f, AstNode_TagStmt); + result->TagStmt.token = token; + result->TagStmt.name = name; + result->TagStmt.stmt = stmt; + return result; +} + +AstNode *ast_unary_expr(AstFile *f, Token op, AstNode *expr) { + AstNode *result = make_ast_node(f, AstNode_UnaryExpr); + result->UnaryExpr.op = op; + result->UnaryExpr.expr = expr; + return result; +} + +AstNode *ast_binary_expr(AstFile *f, Token op, AstNode *left, AstNode *right) { + AstNode *result = make_ast_node(f, AstNode_BinaryExpr); + + if (left == NULL) { + syntax_error(op, "No lhs expression for binary expression `%.*s`", LIT(op.string)); + left = ast_bad_expr(f, op, op); + } + if (right == NULL) { + syntax_error(op, "No rhs expression for binary expression `%.*s`", LIT(op.string)); + right = ast_bad_expr(f, op, op); + } + + result->BinaryExpr.op = op; + result->BinaryExpr.left = left; + result->BinaryExpr.right = right; + + return result; +} + +AstNode *ast_paren_expr(AstFile *f, AstNode *expr, Token open, Token close) { + AstNode *result = make_ast_node(f, AstNode_ParenExpr); + result->ParenExpr.expr = expr; + result->ParenExpr.open = open; + result->ParenExpr.close = close; + return result; +} + +AstNode *ast_call_expr(AstFile *f, AstNode *proc, AstNodeArray args, Token open, Token close, Token ellipsis) { + AstNode *result = make_ast_node(f, AstNode_CallExpr); + result->CallExpr.proc = proc; + result->CallExpr.args = args; + result->CallExpr.open = open; + result->CallExpr.close = close; + result->CallExpr.ellipsis = ellipsis; + return result; +} + +AstNode *ast_macro_call_expr(AstFile *f, AstNode *macro, Token bang, AstNodeArray args, Token open, Token close) { + AstNode *result = make_ast_node(f, AstNode_MacroCallExpr); + result->MacroCallExpr.macro = macro; + result->MacroCallExpr.bang = bang; + result->MacroCallExpr.args = args; + result->MacroCallExpr.open = open; + result->MacroCallExpr.close = close; + return result; +} + + +AstNode *ast_selector_expr(AstFile *f, Token token, AstNode *expr, AstNode *selector) { + AstNode *result = make_ast_node(f, AstNode_SelectorExpr); + result->SelectorExpr.expr = expr; + result->SelectorExpr.selector = selector; + return result; +} + +AstNode *ast_index_expr(AstFile *f, AstNode *expr, AstNode *index, Token open, Token close) { + AstNode *result = make_ast_node(f, AstNode_IndexExpr); + result->IndexExpr.expr = expr; + result->IndexExpr.index = index; + result->IndexExpr.open = open; + result->IndexExpr.close = close; + return result; +} + + +AstNode *ast_slice_expr(AstFile *f, AstNode *expr, Token open, Token close, Token interval0, Token interval1, bool index3, AstNode *low, AstNode *high, AstNode *max) { + AstNode *result = make_ast_node(f, AstNode_SliceExpr); + result->SliceExpr.expr = expr; + result->SliceExpr.open = open; + result->SliceExpr.close = close; + result->SliceExpr.interval0 = interval0; + result->SliceExpr.interval1 = interval1; + result->SliceExpr.index3 = index3; + result->SliceExpr.low = low; + result->SliceExpr.high = high; + result->SliceExpr.max = max; + return result; +} + +AstNode *ast_deref_expr(AstFile *f, AstNode *expr, Token op) { + AstNode *result = make_ast_node(f, AstNode_DerefExpr); + result->DerefExpr.expr = expr; + result->DerefExpr.op = op; + return result; +} + + + + +AstNode *ast_ident(AstFile *f, Token token) { + AstNode *result = make_ast_node(f, AstNode_Ident); + result->Ident = token; + return result; +} + +AstNode *ast_implicit(AstFile *f, Token token) { + AstNode *result = make_ast_node(f, AstNode_Implicit); + result->Implicit = token; + return result; +} + + +AstNode *ast_basic_lit(AstFile *f, Token basic_lit) { + AstNode *result = make_ast_node(f, AstNode_BasicLit); + result->BasicLit = basic_lit; + return result; +} + +AstNode *ast_basic_directive(AstFile *f, Token token, String name) { + AstNode *result = make_ast_node(f, AstNode_BasicDirective); + result->BasicDirective.token = token; + result->BasicDirective.name = name; + return result; +} + +AstNode *ast_ellipsis(AstFile *f, Token token, AstNode *expr) { + AstNode *result = make_ast_node(f, AstNode_Ellipsis); + result->Ellipsis.token = token; + result->Ellipsis.expr = expr; + return result; +} + + +AstNode *ast_proc_lit(AstFile *f, AstNode *type, AstNode *body, u64 tags, AstNode *foreign_library, String foreign_name, String link_name) { + AstNode *result = make_ast_node(f, AstNode_ProcLit); + result->ProcLit.type = type; + result->ProcLit.body = body; + result->ProcLit.tags = tags; + result->ProcLit.foreign_library = foreign_library; + result->ProcLit.foreign_name = foreign_name; + result->ProcLit.link_name = link_name; + return result; +} + +AstNode *ast_field_value(AstFile *f, AstNode *field, AstNode *value, Token eq) { + AstNode *result = make_ast_node(f, AstNode_FieldValue); + result->FieldValue.field = field; + result->FieldValue.value = value; + result->FieldValue.eq = eq; + return result; +} + +AstNode *ast_compound_lit(AstFile *f, AstNode *type, AstNodeArray elems, Token open, Token close) { + AstNode *result = make_ast_node(f, AstNode_CompoundLit); + result->CompoundLit.type = type; + result->CompoundLit.elems = elems; + result->CompoundLit.open = open; + result->CompoundLit.close = close; + return result; +} +AstNode *ast_alias(AstFile *f, Token token, AstNode *expr) { + AstNode *result = make_ast_node(f, AstNode_Alias); + result->Alias.token = token; + result->Alias.expr = expr; + return result; +} + + +AstNode *ast_ternary_expr(AstFile *f, AstNode *cond, AstNode *x, AstNode *y) { + AstNode *result = make_ast_node(f, AstNode_TernaryExpr); + result->TernaryExpr.cond = cond; + result->TernaryExpr.x = x; + result->TernaryExpr.y = y; + return result; +} +AstNode *ast_type_assertion(AstFile *f, AstNode *expr, Token dot, AstNode *type) { + AstNode *result = make_ast_node(f, AstNode_TypeAssertion); + result->TypeAssertion.expr = expr; + result->TypeAssertion.dot = dot; + result->TypeAssertion.type = type; + return result; +} + + + + +AstNode *ast_bad_stmt(AstFile *f, Token begin, Token end) { + AstNode *result = make_ast_node(f, AstNode_BadStmt); + result->BadStmt.begin = begin; + result->BadStmt.end = end; + return result; +} + +AstNode *ast_empty_stmt(AstFile *f, Token token) { + AstNode *result = make_ast_node(f, AstNode_EmptyStmt); + result->EmptyStmt.token = token; + return result; +} + +AstNode *ast_expr_stmt(AstFile *f, AstNode *expr) { + AstNode *result = make_ast_node(f, AstNode_ExprStmt); + result->ExprStmt.expr = expr; + return result; +} + +AstNode *ast_assign_stmt(AstFile *f, Token op, AstNodeArray lhs, AstNodeArray rhs) { + AstNode *result = make_ast_node(f, AstNode_AssignStmt); + result->AssignStmt.op = op; + result->AssignStmt.lhs = lhs; + result->AssignStmt.rhs = rhs; + return result; +} + + +AstNode *ast_inc_dec_stmt(AstFile *f, Token op, AstNode *expr) { + AstNode *result = make_ast_node(f, AstNode_IncDecStmt); + result->IncDecStmt.op = op; + result->IncDecStmt.expr = expr; + return result; +} + + + +AstNode *ast_block_stmt(AstFile *f, AstNodeArray stmts, Token open, Token close) { + AstNode *result = make_ast_node(f, AstNode_BlockStmt); + result->BlockStmt.stmts = stmts; + result->BlockStmt.open = open; + result->BlockStmt.close = close; + return result; +} + +AstNode *ast_if_stmt(AstFile *f, Token token, AstNode *init, AstNode *cond, AstNode *body, AstNode *else_stmt) { + AstNode *result = make_ast_node(f, AstNode_IfStmt); + result->IfStmt.token = token; + result->IfStmt.init = init; + result->IfStmt.cond = cond; + result->IfStmt.body = body; + result->IfStmt.else_stmt = else_stmt; + return result; +} + +AstNode *ast_when_stmt(AstFile *f, Token token, AstNode *cond, AstNode *body, AstNode *else_stmt) { + AstNode *result = make_ast_node(f, AstNode_WhenStmt); + result->WhenStmt.token = token; + result->WhenStmt.cond = cond; + result->WhenStmt.body = body; + result->WhenStmt.else_stmt = else_stmt; + return result; +} + + +AstNode *ast_return_stmt(AstFile *f, Token token, AstNodeArray results) { + AstNode *result = make_ast_node(f, AstNode_ReturnStmt); + result->ReturnStmt.token = token; + result->ReturnStmt.results = results; + return result; +} + + +AstNode *ast_for_stmt(AstFile *f, Token token, AstNode *init, AstNode *cond, AstNode *post, AstNode *body) { + AstNode *result = make_ast_node(f, AstNode_ForStmt); + result->ForStmt.token = token; + result->ForStmt.init = init; + result->ForStmt.cond = cond; + result->ForStmt.post = post; + result->ForStmt.body = body; + return result; +} + +AstNode *ast_range_stmt(AstFile *f, Token token, AstNode *value, AstNode *index, Token in_token, AstNode *expr, AstNode *body) { + AstNode *result = make_ast_node(f, AstNode_RangeStmt); + result->RangeStmt.token = token; + result->RangeStmt.value = value; + result->RangeStmt.index = index; + result->RangeStmt.in_token = in_token; + result->RangeStmt.expr = expr; + result->RangeStmt.body = body; + return result; +} + +AstNode *ast_match_stmt(AstFile *f, Token token, AstNode *init, AstNode *tag, AstNode *body) { + AstNode *result = make_ast_node(f, AstNode_MatchStmt); + result->MatchStmt.token = token; + result->MatchStmt.init = init; + result->MatchStmt.tag = tag; + result->MatchStmt.body = body; + return result; +} + + +AstNode *ast_type_match_stmt(AstFile *f, Token token, AstNode *tag, AstNode *body) { + AstNode *result = make_ast_node(f, AstNode_TypeMatchStmt); + result->TypeMatchStmt.token = token; + result->TypeMatchStmt.tag = tag; + result->TypeMatchStmt.body = body; + return result; +} + +AstNode *ast_case_clause(AstFile *f, Token token, AstNodeArray list, AstNodeArray stmts) { + AstNode *result = make_ast_node(f, AstNode_CaseClause); + result->CaseClause.token = token; + result->CaseClause.list = list; + result->CaseClause.stmts = stmts; + return result; +} + + +AstNode *ast_defer_stmt(AstFile *f, Token token, AstNode *stmt) { + AstNode *result = make_ast_node(f, AstNode_DeferStmt); + result->DeferStmt.token = token; + result->DeferStmt.stmt = stmt; + return result; +} + +AstNode *ast_branch_stmt(AstFile *f, Token token, AstNode *label) { + AstNode *result = make_ast_node(f, AstNode_BranchStmt); + result->BranchStmt.token = token; + result->BranchStmt.label = label; + return result; +} + +AstNode *ast_using_stmt(AstFile *f, Token token, AstNodeArray list) { + AstNode *result = make_ast_node(f, AstNode_UsingStmt); + result->UsingStmt.token = token; + result->UsingStmt.list = list; + return result; +} + + +AstNode *ast_asm_operand(AstFile *f, Token string, AstNode *operand) { + AstNode *result = make_ast_node(f, AstNode_AsmOperand); + result->AsmOperand.string = string; + result->AsmOperand.operand = operand; + return result; + +} + +AstNode *ast_asm_stmt(AstFile *f, Token token, bool is_volatile, Token open, Token close, Token code_string, + AstNode *output_list, AstNode *input_list, AstNode *clobber_list, + isize output_count, isize input_count, isize clobber_count) { + AstNode *result = make_ast_node(f, AstNode_AsmStmt); + result->AsmStmt.token = token; + result->AsmStmt.is_volatile = is_volatile; + result->AsmStmt.open = open; + result->AsmStmt.close = close; + result->AsmStmt.code_string = code_string; + result->AsmStmt.output_list = output_list; + result->AsmStmt.input_list = input_list; + result->AsmStmt.clobber_list = clobber_list; + result->AsmStmt.output_count = output_count; + result->AsmStmt.input_count = input_count; + result->AsmStmt.clobber_count = clobber_count; + return result; +} + +AstNode *ast_push_allocator(AstFile *f, Token token, AstNode *expr, AstNode *body) { + AstNode *result = make_ast_node(f, AstNode_PushAllocator); + result->PushAllocator.token = token; + result->PushAllocator.expr = expr; + result->PushAllocator.body = body; + return result; +} + +AstNode *ast_push_context(AstFile *f, Token token, AstNode *expr, AstNode *body) { + AstNode *result = make_ast_node(f, AstNode_PushContext); + result->PushContext.token = token; + result->PushContext.expr = expr; + result->PushContext.body = body; + return result; +} + + + + +AstNode *ast_bad_decl(AstFile *f, Token begin, Token end) { + AstNode *result = make_ast_node(f, AstNode_BadDecl); + result->BadDecl.begin = begin; + result->BadDecl.end = end; + return result; +} + +AstNode *ast_field(AstFile *f, AstNodeArray names, AstNode *type, u32 flags) { + AstNode *result = make_ast_node(f, AstNode_Field); + result->Field.names = names; + result->Field.type = type; + result->Field.flags = flags; + return result; +} + +AstNode *ast_field_list(AstFile *f, Token token, AstNodeArray list) { + AstNode *result = make_ast_node(f, AstNode_FieldList); + result->FieldList.token = token; + result->FieldList.list = list; + return result; +} +AstNode *ast_union_field(AstFile *f, AstNode *name, AstNode *list) { + AstNode *result = make_ast_node(f, AstNode_UnionField); + result->UnionField.name = name; + result->UnionField.list = list; + return result; +} + + +AstNode *ast_helper_type(AstFile *f, Token token, AstNode *type) { + AstNode *result = make_ast_node(f, AstNode_HelperType); + result->HelperType.token = token; + result->HelperType.type = type; + return result; +} + + +AstNode *ast_proc_type(AstFile *f, Token token, AstNode *params, AstNode *results, u64 tags, ProcCallingConvention calling_convention) { + AstNode *result = make_ast_node(f, AstNode_ProcType); + result->ProcType.token = token; + result->ProcType.params = params; + result->ProcType.results = results; + result->ProcType.tags = tags; + result->ProcType.calling_convention = calling_convention; + return result; +} + +AstNode *ast_pointer_type(AstFile *f, Token token, AstNode *type) { + AstNode *result = make_ast_node(f, AstNode_PointerType); + result->PointerType.token = token; + result->PointerType.type = type; + return result; +} + +AstNode *ast_atomic_type(AstFile *f, Token token, AstNode *type) { + AstNode *result = make_ast_node(f, AstNode_AtomicType); + result->AtomicType.token = token; + result->AtomicType.type = type; + return result; +} + +AstNode *ast_array_type(AstFile *f, Token token, AstNode *count, AstNode *elem) { + AstNode *result = make_ast_node(f, AstNode_ArrayType); + result->ArrayType.token = token; + result->ArrayType.count = count; + result->ArrayType.elem = elem; + return result; +} + +AstNode *ast_dynamic_array_type(AstFile *f, Token token, AstNode *elem) { + AstNode *result = make_ast_node(f, AstNode_DynamicArrayType); + result->DynamicArrayType.token = token; + result->DynamicArrayType.elem = elem; + return result; +} + +AstNode *ast_vector_type(AstFile *f, Token token, AstNode *count, AstNode *elem) { + AstNode *result = make_ast_node(f, AstNode_VectorType); + result->VectorType.token = token; + result->VectorType.count = count; + result->VectorType.elem = elem; + return result; +} + +AstNode *ast_struct_type(AstFile *f, Token token, AstNodeArray fields, isize field_count, + bool is_packed, bool is_ordered, AstNode *align) { + AstNode *result = make_ast_node(f, AstNode_StructType); + result->StructType.token = token; + result->StructType.fields = fields; + result->StructType.field_count = field_count; + result->StructType.is_packed = is_packed; + result->StructType.is_ordered = is_ordered; + result->StructType.align = align; + return result; +} + + +AstNode *ast_union_type(AstFile *f, Token token, AstNodeArray fields, isize field_count, AstNodeArray variants) { + AstNode *result = make_ast_node(f, AstNode_UnionType); + result->UnionType.token = token; + result->UnionType.fields = fields; + result->UnionType.field_count = field_count; + result->UnionType.variants = variants; + return result; +} + +AstNode *ast_raw_union_type(AstFile *f, Token token, AstNodeArray fields, isize field_count) { + AstNode *result = make_ast_node(f, AstNode_RawUnionType); + result->RawUnionType.token = token; + result->RawUnionType.fields = fields; + result->RawUnionType.field_count = field_count; + return result; +} + + +AstNode *ast_enum_type(AstFile *f, Token token, AstNode *base_type, AstNodeArray fields) { + AstNode *result = make_ast_node(f, AstNode_EnumType); + result->EnumType.token = token; + result->EnumType.base_type = base_type; + result->EnumType.fields = fields; + return result; +} + +AstNode *ast_bit_field_type(AstFile *f, Token token, AstNodeArray fields, AstNode *align) { + AstNode *result = make_ast_node(f, AstNode_BitFieldType); + result->BitFieldType.token = token; + result->BitFieldType.fields = fields; + result->BitFieldType.align = align; + return result; +} + +AstNode *ast_map_type(AstFile *f, Token token, AstNode *count, AstNode *key, AstNode *value) { + AstNode *result = make_ast_node(f, AstNode_MapType); + result->MapType.token = token; + result->MapType.count = count; + result->MapType.key = key; + result->MapType.value = value; + return result; +} + + +AstNode *ast_value_decl(AstFile *f, bool is_var, AstNodeArray names, AstNode *type, AstNodeArray values) { + AstNode *result = make_ast_node(f, AstNode_ValueDecl); + result->ValueDecl.is_var = is_var; + result->ValueDecl.names = names; + result->ValueDecl.type = type; + result->ValueDecl.values = values; + return result; +} + + +AstNode *ast_import_decl(AstFile *f, Token token, bool is_import, Token relpath, Token import_name, AstNode *cond) { + AstNode *result = make_ast_node(f, AstNode_ImportDecl); + result->ImportDecl.token = token; + result->ImportDecl.is_import = is_import; + result->ImportDecl.relpath = relpath; + result->ImportDecl.import_name = import_name; + result->ImportDecl.cond = cond; + return result; +} + +AstNode *ast_foreign_library(AstFile *f, Token token, Token filepath, Token library_name, AstNode *cond, bool is_system) { + AstNode *result = make_ast_node(f, AstNode_ForeignLibrary); + result->ForeignLibrary.token = token; + result->ForeignLibrary.filepath = filepath; + result->ForeignLibrary.library_name = library_name; + result->ForeignLibrary.cond = cond; + result->ForeignLibrary.is_system = is_system; + return result; +} + +AstNode *ast_label_decl(AstFile *f, Token token, AstNode *name) { + AstNode *result = make_ast_node(f, AstNode_Label); + result->Label.token = token; + result->Label.name = name; + return result; +} + + +bool next_token(AstFile *f) { + Token prev = f->curr_token; + if (f->curr_token_index+1 < f->tokens.count) { + if (f->curr_token.kind != Token_Comment) { + f->prev_token = f->curr_token; + } + + f->curr_token_index++; + f->curr_token = f->tokens.e[f->curr_token_index]; + if (f->curr_token.kind == Token_Comment) { + return next_token(f); + } + return true; + } + syntax_error(f->curr_token, "Token is EOF"); + return false; +} + +TokenKind look_ahead_token_kind(AstFile *f, isize amount) { + GB_ASSERT(amount > 0); + + TokenKind kind = Token_Invalid; + isize index = f->curr_token_index; + while (amount > 0) { + index++; + kind = f->tokens.e[index].kind; + if (kind != Token_Comment) { + amount--; + } + } + return kind; +} + +Token expect_token(AstFile *f, TokenKind kind) { + Token prev = f->curr_token; + if (prev.kind != kind) { + String p = token_strings[prev.kind]; + syntax_error(f->curr_token, "Expected `%.*s`, got `%.*s`", + LIT(token_strings[kind]), + LIT(token_strings[prev.kind])); + if (prev.kind == Token_EOF) { + gb_exit(1); + } + } + + next_token(f); + return prev; +} + +Token expect_token_after(AstFile *f, TokenKind kind, char *msg) { + Token prev = f->curr_token; + if (prev.kind != kind) { + String p = token_strings[prev.kind]; + syntax_error(f->curr_token, "Expected `%.*s` after %s, got `%.*s`", + LIT(token_strings[kind]), + msg, + LIT(p)); + } + next_token(f); + return prev; +} + + +Token expect_operator(AstFile *f) { + Token prev = f->curr_token; + if (!gb_is_between(prev.kind, Token__OperatorBegin+1, Token__OperatorEnd-1)) { + syntax_error(f->curr_token, "Expected an operator, got `%.*s`", + LIT(token_strings[prev.kind])); + } else if (!f->allow_range && (prev.kind == Token_Ellipsis || prev.kind == Token_HalfClosed)) { + syntax_error(f->curr_token, "Expected an non-range operator, got `%.*s`", + LIT(token_strings[prev.kind])); + } + next_token(f); + return prev; +} + +Token expect_keyword(AstFile *f) { + Token prev = f->curr_token; + if (!gb_is_between(prev.kind, Token__KeywordBegin+1, Token__KeywordEnd-1)) { + syntax_error(f->curr_token, "Expected a keyword, got `%.*s`", + LIT(token_strings[prev.kind])); + } + next_token(f); + return prev; +} + +bool allow_token(AstFile *f, TokenKind kind) { + Token prev = f->curr_token; + if (prev.kind == kind) { + next_token(f); + return true; + } + return false; +} + + +bool is_blank_ident(String str) { + if (str.len == 1) { + return str.text[0] == '_'; + } + return false; +} + + +// NOTE(bill): Go to next statement to prevent numerous error messages popping up +void fix_advance_to_next_stmt(AstFile *f) { + // TODO(bill): fix_advance_to_next_stmt +#if 1 + for (;;) { + Token t = f->curr_token; + switch (t.kind) { + case Token_EOF: + case Token_Semicolon: + return; + + case Token_if: + case Token_when: + case Token_return: + case Token_match: + case Token_defer: + case Token_asm: + case Token_using: + case Token_immutable: + // case Token_thread_local: + // case Token_no_alias: + + case Token_break: + case Token_continue: + case Token_fallthrough: + + case Token_push_allocator: + case Token_push_context: + + case Token_Hash: + { + if (token_pos_eq(t.pos, f->fix_prev_pos) && + f->fix_count < PARSER_MAX_FIX_COUNT) { + f->fix_count++; + return; + } + if (token_pos_cmp(f->fix_prev_pos, t.pos) < 0) { + f->fix_prev_pos = t.pos; + f->fix_count = 0; // NOTE(bill): Reset + return; + } + // NOTE(bill): Reaching here means there is a parsing bug + } break; + } + next_token(f); + } +#endif +} + +Token expect_closing(AstFile *f, TokenKind kind, String context) { + if (f->curr_token.kind != kind && + f->curr_token.kind == Token_Semicolon && + str_eq(f->curr_token.string, str_lit("\n"))) { + error(f->curr_token, "Missing `,` before newline in %.*s", LIT(context)); + next_token(f); + } + return expect_token(f, kind); +} + +bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) { + if (s == NULL) { + return false; + } + + switch (s->kind) { + case AstNode_IfStmt: + case AstNode_WhenStmt: + case AstNode_ForStmt: + case AstNode_RangeStmt: + case AstNode_MatchStmt: + case AstNode_TypeMatchStmt: + return true; + + case AstNode_HelperType: + return is_semicolon_optional_for_node(f, s->HelperType.type); + + case AstNode_PointerType: + return is_semicolon_optional_for_node(f, s->PointerType.type); + + case AstNode_AtomicType: + return is_semicolon_optional_for_node(f, s->AtomicType.type); + + case AstNode_StructType: + case AstNode_UnionType: + case AstNode_RawUnionType: + case AstNode_EnumType: + case AstNode_BitFieldType: + return true; + case AstNode_ProcLit: + return s->ProcLit.body != NULL; + + case AstNode_ValueDecl: + if (!s->ValueDecl.is_var) { + if (s->ValueDecl.values.count > 0) { + AstNode *last = s->ValueDecl.values.e[s->ValueDecl.values.count-1]; + return is_semicolon_optional_for_node(f, last); + } + } + break; + } + + return false; +} + +void expect_semicolon(AstFile *f, AstNode *s) { + if (allow_token(f, Token_Semicolon)) { + return; + } + Token prev_token = f->prev_token; + + switch (f->curr_token.kind) { + case Token_EOF: + return; + } + + if (s != NULL) { + if (prev_token.pos.line != f->curr_token.pos.line) { + if (is_semicolon_optional_for_node(f, s)) { + return; + } + } else { + // switch (s->kind) { + // case AstNode_GiveExpr: + // if (f->curr_token.kind == Token_CloseBrace) { + // return; + // } + // break; + // } + } + syntax_error(prev_token, "Expected `;` after %.*s, got %.*s", + LIT(ast_node_strings[s->kind]), LIT(token_strings[prev_token.kind])); + } else { + syntax_error(prev_token, "Expected `;`"); + } + fix_advance_to_next_stmt(f); +} + + +AstNode * parse_expr(AstFile *f, bool lhs); +AstNode * parse_proc_type(AstFile *f, AstNode **foreign_library, String *foreign_name, String *link_name); +AstNodeArray parse_stmt_list(AstFile *f); +AstNode * parse_stmt(AstFile *f); +AstNode * parse_body(AstFile *f); + + + + +AstNode *parse_ident(AstFile *f) { + Token token = f->curr_token; + if (token.kind == Token_Ident) { + next_token(f); + } else { + token.string = str_lit("_"); + expect_token(f, Token_Ident); + } + return ast_ident(f, token); +} + +AstNode *parse_tag_expr(AstFile *f, AstNode *expression) { + Token token = expect_token(f, Token_Hash); + Token name = expect_token(f, Token_Ident); + return ast_tag_expr(f, token, name, expression); +} + +AstNode *unparen_expr(AstNode *node) { + for (;;) { + if (node == NULL) { + return NULL; + } + if (node->kind != AstNode_ParenExpr) { + return node; + } + node = node->ParenExpr.expr; + } +} + +AstNode *parse_value(AstFile *f); + +AstNodeArray parse_element_list(AstFile *f) { + AstNodeArray elems = make_ast_node_array(f); + + while (f->curr_token.kind != Token_CloseBrace && + f->curr_token.kind != Token_EOF) { + AstNode *elem = parse_value(f); + if (f->curr_token.kind == Token_Eq) { + Token eq = expect_token(f, Token_Eq); + AstNode *value = parse_value(f); + elem = ast_field_value(f, elem, value, eq); + } + + array_add(&elems, elem); + + if (!allow_token(f, Token_Comma)) { + break; + } + } + + return elems; +} + +AstNode *parse_literal_value(AstFile *f, AstNode *type) { + AstNodeArray elems = {}; + Token open = expect_token(f, Token_OpenBrace); + f->expr_level++; + if (f->curr_token.kind != Token_CloseBrace) { + elems = parse_element_list(f); + } + f->expr_level--; + Token close = expect_closing(f, Token_CloseBrace, str_lit("compound literal")); + + return ast_compound_lit(f, type, elems, open, close); +} + +AstNode *parse_value(AstFile *f) { + if (f->curr_token.kind == Token_OpenBrace) { + return parse_literal_value(f, NULL); + } + + AstNode *value = parse_expr(f, false); + return value; +} + +AstNode *parse_type_or_ident(AstFile *f); + + +void check_proc_add_tag(AstFile *f, AstNode *tag_expr, u64 *tags, ProcTag tag, String tag_name) { + if (*tags & tag) { + syntax_error_node(tag_expr, "Procedure tag already used: %.*s", LIT(tag_name)); + } + *tags |= tag; +} + +bool is_foreign_name_valid(String name) { + // TODO(bill): is_foreign_name_valid + if (name.len == 0) + return false; + isize offset = 0; + while (offset < name.len) { + Rune rune; + isize remaining = name.len - offset; + isize width = gb_utf8_decode(name.text+offset, remaining, &rune); + if (rune == GB_RUNE_INVALID && width == 1) { + return false; + } else if (rune == GB_RUNE_BOM && remaining > 0) { + return false; + } + + if (offset == 0) { + switch (rune) { + case '-': + case '$': + case '.': + case '_': + break; + default: + if (!gb_char_is_alpha(cast(char)rune)) + return false; + break; + } + } else { + switch (rune) { + case '-': + case '$': + case '.': + case '_': + break; + default: + if (!gb_char_is_alphanumeric(cast(char)rune)) { + return false; + } + break; + } + } + + offset += width; + } + + return true; +} + +void parse_proc_tags(AstFile *f, u64 *tags, AstNode **foreign_library_token, String *foreign_name, String *link_name, ProcCallingConvention *calling_convention) { + // TODO(bill): Add this to procedure literals too + GB_ASSERT(tags != NULL); + GB_ASSERT(link_name != NULL); + GB_ASSERT(link_name != NULL); + + ProcCallingConvention cc = ProcCC_Invalid; + + while (f->curr_token.kind == Token_Hash) { + AstNode *tag_expr = parse_tag_expr(f, NULL); + ast_node(te, TagExpr, tag_expr); + String tag_name = te->name.string; + + #define ELSE_IF_ADD_TAG(name) \ + else if (str_eq(tag_name, str_lit(#name))) { \ + check_proc_add_tag(f, tag_expr, tags, ProcTag_##name, tag_name); \ + } + + if (str_eq(tag_name, str_lit("foreign"))) { + check_proc_add_tag(f, tag_expr, tags, ProcTag_foreign, tag_name); + *foreign_library_token = parse_ident(f); + if (f->curr_token.kind == Token_String) { + *foreign_name = f->curr_token.string; + // TODO(bill): Check if valid string + if (!is_foreign_name_valid(*foreign_name)) { + syntax_error_node(tag_expr, "Invalid alternative foreign procedure name: `%.*s`", LIT(*foreign_name)); + } + + next_token(f); + } + } else if (str_eq(tag_name, str_lit("link_name"))) { + check_proc_add_tag(f, tag_expr, tags, ProcTag_link_name, tag_name); + if (f->curr_token.kind == Token_String) { + *link_name = f->curr_token.string; + // TODO(bill): Check if valid string + if (!is_foreign_name_valid(*link_name)) { + syntax_error_node(tag_expr, "Invalid alternative link procedure name `%.*s`", LIT(*link_name)); + } + + next_token(f); + } else { + expect_token(f, Token_String); + } + } + ELSE_IF_ADD_TAG(require_results) + ELSE_IF_ADD_TAG(export) + ELSE_IF_ADD_TAG(bounds_check) + ELSE_IF_ADD_TAG(no_bounds_check) + ELSE_IF_ADD_TAG(inline) + ELSE_IF_ADD_TAG(no_inline) + // ELSE_IF_ADD_TAG(dll_import) + // ELSE_IF_ADD_TAG(dll_export) + else if (str_eq(tag_name, str_lit("cc_odin"))) { + if (cc == ProcCC_Invalid) { + cc = ProcCC_Odin; + } else { + syntax_error_node(tag_expr, "Multiple calling conventions for procedure type"); + } + } else if (str_eq(tag_name, str_lit("cc_c"))) { + if (cc == ProcCC_Invalid) { + cc = ProcCC_C; + } else { + syntax_error_node(tag_expr, "Multiple calling conventions for procedure type"); + } + } else if (str_eq(tag_name, str_lit("cc_std"))) { + if (cc == ProcCC_Invalid) { + cc = ProcCC_Std; + } else { + syntax_error_node(tag_expr, "Multiple calling conventions for procedure type"); + } + } else if (str_eq(tag_name, str_lit("cc_fast"))) { + if (cc == ProcCC_Invalid) { + cc = ProcCC_Fast; + } else { + syntax_error_node(tag_expr, "Multiple calling conventions for procedure type"); + } + } else { + syntax_error_node(tag_expr, "Unknown procedure tag #%.*s\n", LIT(tag_name)); + } + + #undef ELSE_IF_ADD_TAG + } + + if (cc == ProcCC_Invalid) { + if ((*tags) & ProcTag_foreign) { + cc = ProcCC_C; + } else { + cc = ProcCC_Odin; + } + } + + if (calling_convention) { + *calling_convention = cc; + } + + if ((*tags & ProcTag_foreign) && (*tags & ProcTag_export)) { + syntax_error(f->curr_token, "You cannot apply both #foreign and #export to a procedure"); + } + + if ((*tags & ProcTag_inline) && (*tags & ProcTag_no_inline)) { + syntax_error(f->curr_token, "You cannot apply both #inline and #no_inline to a procedure"); + } + + if ((*tags & ProcTag_bounds_check) && (*tags & ProcTag_no_bounds_check)) { + syntax_error(f->curr_token, "You cannot apply both #bounds_check and #no_bounds_check to a procedure"); + } + + if (((*tags & ProcTag_bounds_check) || (*tags & ProcTag_no_bounds_check)) && (*tags & ProcTag_foreign)) { + syntax_error(f->curr_token, "You cannot apply both #bounds_check or #no_bounds_check to a procedure without a body"); + } +} + + +AstNodeArray parse_lhs_expr_list(AstFile *f); +AstNodeArray parse_rhs_expr_list(AstFile *f); +AstNode * parse_simple_stmt (AstFile *f, StmtAllowFlag flags); +AstNode * parse_type (AstFile *f); + +AstNode *convert_stmt_to_expr(AstFile *f, AstNode *statement, String kind) { + if (statement == NULL) { + return NULL; + } + + if (statement->kind == AstNode_ExprStmt) { + return statement->ExprStmt.expr; + } + + syntax_error(f->curr_token, "Expected `%.*s`, found a simple statement.", LIT(kind)); + return ast_bad_expr(f, f->curr_token, f->tokens.e[f->curr_token_index+1]); +} + + + +AstNode *parse_operand(AstFile *f, bool lhs) { + AstNode *operand = NULL; // Operand + switch (f->curr_token.kind) { + case Token_Ident: + return parse_ident(f); + + case Token_context: + return ast_implicit(f, expect_token(f, Token_context)); + + case Token_Integer: + case Token_Float: + case Token_Imag: + case Token_Rune: + operand = ast_basic_lit(f, f->curr_token); + next_token(f); + return operand; + + case Token_String: { + Token token = f->curr_token; + next_token(f); + if (f->curr_token.kind == Token_String) { + // NOTE(bill): Allow neighbouring string literals to be merge together to + // become one big string + String s = f->curr_token.string; + Array(u8) data; + array_init_reserve(&data, heap_allocator(), token.string.len+s.len); + gb_memmove(data.e, token.string.text, token.string.len); + data.count += token.string.len; + + while (f->curr_token.kind == Token_String) { + String s = f->curr_token.string; + isize old_count = data.count; + array_resize(&data, data.count + s.len); + gb_memmove(data.e+old_count, s.text, s.len); + next_token(f); + } + + token.string = make_string(data.e, data.count); + array_add(&f->tokenizer.allocated_strings, token.string); + } + + return ast_basic_lit(f, token); + } + + + case Token_OpenParen: { + Token open, close; + // NOTE(bill): Skip the Paren Expression + open = expect_token(f, Token_OpenParen); + f->expr_level++; + operand = parse_expr(f, false); + f->expr_level--; + close = expect_token(f, Token_CloseParen); + return ast_paren_expr(f, operand, open, close); + } + + case Token_Hash: { + Token token = expect_token(f, Token_Hash); + Token name = expect_token(f, Token_Ident); + if (str_eq(name.string, str_lit("run"))) { + AstNode *expr = parse_expr(f, false); + operand = ast_run_expr(f, token, name, expr); + if (unparen_expr(expr)->kind != AstNode_CallExpr) { + error_node(expr, "#run can only be applied to procedure calls"); + operand = ast_bad_expr(f, token, f->curr_token); + } + warning(token, "#run is not yet implemented"); + } else if (str_eq(name.string, str_lit("file"))) { return ast_basic_directive(f, token, name.string); + } else if (str_eq(name.string, str_lit("line"))) { return ast_basic_directive(f, token, name.string); + } else if (str_eq(name.string, str_lit("procedure"))) { return ast_basic_directive(f, token, name.string); + } else if (str_eq(name.string, str_lit("type"))) { return ast_helper_type(f, token, parse_type(f)); + } else if (!lhs && str_eq(name.string, str_lit("alias"))) { return ast_alias(f, token, parse_expr(f, false)); + } else { + operand = ast_tag_expr(f, token, name, parse_expr(f, false)); + } + return operand; + } + + // Parse Procedure Type or Literal + case Token_proc: { + Token token = f->curr_token; + AstNode *foreign_library = NULL; + String foreign_name = {}; + String link_name = {}; + AstNode *type = parse_proc_type(f, &foreign_library, &foreign_name, &link_name); + u64 tags = type->ProcType.tags; + + if (f->curr_token.kind == Token_OpenBrace) { + if ((tags & ProcTag_foreign) != 0) { + syntax_error(token, "A procedure tagged as `#foreign` cannot have a body"); + } + AstNode *curr_proc = f->curr_proc; + AstNode *body = NULL; + f->curr_proc = type; + body = parse_body(f); + f->curr_proc = curr_proc; + + return ast_proc_lit(f, type, body, tags, foreign_library, foreign_name, link_name); + } + + if ((tags & ProcTag_foreign) != 0) { + return ast_proc_lit(f, type, NULL, tags, foreign_library, foreign_name, link_name); + } + if (tags != 0) { + // syntax_error(token, "A procedure type cannot have tags"); + } + + return type; + } + + default: { + AstNode *type = parse_type_or_ident(f); + if (type != NULL) { + // TODO(bill): Is this correct??? + // NOTE(bill): Sanity check as identifiers should be handled already + TokenPos pos = ast_node_token(type).pos; + GB_ASSERT_MSG(type->kind != AstNode_Ident, "Type cannot be identifier %.*s(%td:%td)", LIT(pos.file), pos.line, pos.column); + return type; + } + break; + } + } + + return NULL; +} + +bool is_literal_type(AstNode *node) { + node = unparen_expr(node); + switch (node->kind) { + case AstNode_BadExpr: + case AstNode_Ident: + case AstNode_SelectorExpr: + case AstNode_ArrayType: + case AstNode_VectorType: + case AstNode_StructType: + case AstNode_DynamicArrayType: + case AstNode_MapType: + return true; + } + return false; +} + +AstNode *parse_call_expr(AstFile *f, AstNode *operand) { + AstNodeArray args = make_ast_node_array(f); + Token open_paren, close_paren; + Token ellipsis = {}; + + f->expr_level++; + open_paren = expect_token(f, Token_OpenParen); + + while (f->curr_token.kind != Token_CloseParen && + f->curr_token.kind != Token_EOF && + ellipsis.pos.line == 0) { + if (f->curr_token.kind == Token_Comma) { + syntax_error(f->curr_token, "Expected an expression not a ,"); + } + + if (f->curr_token.kind == Token_Ellipsis) { + ellipsis = f->curr_token; + next_token(f); + } + + AstNode *arg = parse_expr(f, false); + array_add(&args, arg); + + if (!allow_token(f, Token_Comma)) { + break; + } + } + + f->expr_level--; + close_paren = expect_closing(f, Token_CloseParen, str_lit("argument list")); + + return ast_call_expr(f, operand, args, open_paren, close_paren, ellipsis); +} + + +AstNode *parse_macro_call_expr(AstFile *f, AstNode *operand) { + AstNodeArray args = make_ast_node_array(f); + Token bang, open_paren, close_paren; + + bang = expect_token(f, Token_Not); + + f->expr_level++; + open_paren = expect_token(f, Token_OpenParen); + + while (f->curr_token.kind != Token_CloseParen && + f->curr_token.kind != Token_EOF) { + if (f->curr_token.kind == Token_Comma) { + syntax_error(f->curr_token, "Expected an expression not a ,"); + } + + AstNode *arg = parse_expr(f, false); + array_add(&args, arg); + + if (!allow_token(f, Token_Comma)) { + break; + } + } + + f->expr_level--; + close_paren = expect_closing(f, Token_CloseParen, str_lit("argument list")); + + return ast_macro_call_expr(f, operand, bang, args, open_paren, close_paren); +} + +AstNode *parse_atom_expr(AstFile *f, bool lhs) { + AstNode *operand = parse_operand(f, lhs); + if (operand == NULL) { + Token begin = f->curr_token; + syntax_error(begin, "Expected an operand"); + fix_advance_to_next_stmt(f); + operand = ast_bad_expr(f, begin, f->curr_token); + } + + bool loop = true; + while (loop) { + switch (f->curr_token.kind) { + case Token_OpenParen: + operand = parse_call_expr(f, operand); + break; + case Token_Not: + operand = parse_macro_call_expr(f, operand); + break; + + case Token_Period: { + Token token = f->curr_token; + next_token(f); + switch (f->curr_token.kind) { + case Token_Ident: + operand = ast_selector_expr(f, token, operand, parse_ident(f)); + break; + case Token_Integer: + operand = ast_selector_expr(f, token, operand, parse_expr(f, lhs)); + break; + case Token_OpenParen: { + Token open = expect_token(f, Token_OpenParen); + AstNode *type = parse_type(f); + Token close = expect_token(f, Token_CloseParen); + operand = ast_type_assertion(f, operand, token, type); + } break; + + default: + syntax_error(f->curr_token, "Expected a selector"); + next_token(f); + operand = ast_bad_expr(f, ast_node_token(operand), f->curr_token); + // operand = ast_selector_expr(f, f->curr_token, operand, NULL); + break; + } + } break; + + case Token_OpenBracket: { + if (lhs) { + // TODO(bill): Handle this + } + bool prev_allow_range = f->allow_range; + f->allow_range = false; + + Token open = {}, close = {}, interval = {}; + AstNode *indices[3] = {}; + isize ellipsis_count = 0; + Token ellipses[2] = {}; + + f->expr_level++; + open = expect_token(f, Token_OpenBracket); + + if (f->curr_token.kind != Token_Ellipsis && + f->curr_token.kind != Token_HalfClosed) { + indices[0] = parse_expr(f, false); + } + bool is_index = true; + + while ((f->curr_token.kind == Token_Ellipsis || + f->curr_token.kind == Token_HalfClosed) + && ellipsis_count < gb_count_of(ellipses)) { + ellipses[ellipsis_count++] = f->curr_token; + next_token(f); + if (f->curr_token.kind != Token_Ellipsis && + f->curr_token.kind != Token_HalfClosed && + f->curr_token.kind != Token_CloseBracket && + f->curr_token.kind != Token_EOF) { + indices[ellipsis_count] = parse_expr(f, false); + } + } + + + f->expr_level--; + close = expect_token(f, Token_CloseBracket); + + if (ellipsis_count > 0) { + bool index3 = false; + if (ellipsis_count == 2) { + index3 = true; + // 2nd and 3rd index must be present + if (indices[1] == NULL) { + error(ellipses[0], "2nd index required in 3-index slice expression"); + indices[1] = ast_bad_expr(f, ellipses[0], ellipses[1]); + } + if (indices[2] == NULL) { + error(ellipses[1], "3rd index required in 3-index slice expression"); + indices[2] = ast_bad_expr(f, ellipses[1], close); + } + } + operand = ast_slice_expr(f, operand, open, close, ellipses[0], ellipses[1], index3, indices[0], indices[1], indices[2]); + } else { + operand = ast_index_expr(f, operand, indices[0], open, close); + } + + f->allow_range = prev_allow_range; + } break; + + case Token_Pointer: // Deference + operand = ast_deref_expr(f, operand, expect_token(f, Token_Pointer)); + break; + + case Token_OpenBrace: + if (!lhs && is_literal_type(operand) && f->expr_level >= 0) { + operand = parse_literal_value(f, operand); + } else { + loop = false; + } + break; + + default: + loop = false; + break; + } + + lhs = false; // NOTE(bill): 'tis not lhs anymore + } + + return operand; +} + + +AstNode *parse_unary_expr(AstFile *f, bool lhs) { + switch (f->curr_token.kind) { + case Token_Add: + case Token_Sub: + case Token_Not: + case Token_Xor: + case Token_And: { + Token op = f->curr_token; + next_token(f); + return ast_unary_expr(f, op, parse_unary_expr(f, lhs)); + } break; + } + + return parse_atom_expr(f, lhs); +} + +bool is_ast_node_a_range(AstNode *expr) { + if (expr == NULL) { + return false; + } + if (expr->kind != AstNode_BinaryExpr) { + return false; + } + TokenKind op = expr->BinaryExpr.op.kind; + switch (op) { + case Token_Ellipsis: + case Token_HalfClosed: + return true; + } + return false; +} + +// NOTE(bill): result == priority +i32 token_precedence(AstFile *f, TokenKind t) { + switch (t) { + case Token_Question: + return 1; + case Token_Ellipsis: + case Token_HalfClosed: + if (f->allow_range) { + return 2; + } + return 0; + case Token_CmpOr: + return 3; + case Token_CmpAnd: + return 4; + case Token_CmpEq: + case Token_NotEq: + case Token_Lt: + case Token_Gt: + case Token_LtEq: + case Token_GtEq: + return 5; + case Token_Add: + case Token_Sub: + case Token_Or: + case Token_Xor: + return 6; + case Token_Mul: + case Token_Quo: + case Token_Mod: + case Token_ModMod: + case Token_And: + case Token_AndNot: + case Token_Shl: + case Token_Shr: + return 7; + } + return 0; +} + +AstNode *parse_binary_expr(AstFile *f, bool lhs, i32 prec_in) { + AstNode *expr = parse_unary_expr(f, lhs); + for (i32 prec = token_precedence(f, f->curr_token.kind); prec >= prec_in; prec--) { + for (;;) { + Token op = f->curr_token; + i32 op_prec = token_precedence(f, op.kind); + if (op_prec != prec) { + // NOTE(bill): This will also catch operators that are not valid "binary" operators + break; + } + expect_operator(f); // NOTE(bill): error checks too + + if (op.kind == Token_Question) { + AstNode *cond = expr; + // Token_Question + AstNode *x = parse_expr(f, lhs); + Token token_c = expect_token(f, Token_Colon); + AstNode *y = parse_expr(f, lhs); + expr = ast_ternary_expr(f, cond, x, y); + } else { + AstNode *right = parse_binary_expr(f, false, prec+1); + if (right == NULL) { + syntax_error(op, "Expected expression on the right-hand side of the binary operator"); + } + expr = ast_binary_expr(f, op, expr, right); + } + + lhs = false; + } + } + return expr; +} + +AstNode *parse_expr(AstFile *f, bool lhs) { + return parse_binary_expr(f, lhs, 0+1); +} + + +AstNodeArray parse_expr_list(AstFile *f, bool lhs) { + AstNodeArray list = make_ast_node_array(f); + for (;;) { + AstNode *e = parse_expr(f, lhs); + array_add(&list, e); + if (f->curr_token.kind != Token_Comma || + f->curr_token.kind == Token_EOF) { + break; + } + next_token(f); + } + + return list; +} + +AstNodeArray parse_lhs_expr_list(AstFile *f) { + return parse_expr_list(f, true); +} + +AstNodeArray parse_rhs_expr_list(AstFile *f) { + return parse_expr_list(f, false); +} + +AstNodeArray parse_ident_list(AstFile *f) { + AstNodeArray list = make_ast_node_array(f); + + do { + array_add(&list, parse_ident(f)); + if (f->curr_token.kind != Token_Comma || + f->curr_token.kind == Token_EOF) { + break; + } + next_token(f); + } while (true); + + return list; +} + + +AstNode *parse_type_attempt(AstFile *f) { + AstNode *type = parse_type_or_ident(f); + if (type != NULL) { + // TODO(bill): Handle? + } + return type; +} + +AstNode *parse_type(AstFile *f) { + AstNode *type = parse_type_attempt(f); + if (type == NULL) { + Token token = f->curr_token; + syntax_error(token, "Expected a type"); + next_token(f); + return ast_bad_expr(f, token, f->curr_token); + } + return type; +} + + +AstNode *parse_value_decl(AstFile *f, AstNodeArray lhs) { + AstNode *type = NULL; + AstNodeArray values = {}; + bool is_mutable = true; + + if (allow_token(f, Token_Colon)) { + type = parse_type_attempt(f); + } else if (f->curr_token.kind != Token_Eq && + f->curr_token.kind != Token_Semicolon) { + syntax_error(f->curr_token, "Expected a type separator `:` or `=`"); + } + + + switch (f->curr_token.kind) { + case Token_Colon: + is_mutable = false; + /*fallthrough*/ + case Token_Eq: + next_token(f); + values = parse_rhs_expr_list(f); + if (values.count > lhs.count) { + syntax_error(f->curr_token, "Too many values on the right hand side of the declaration"); + } else if (values.count < lhs.count && !is_mutable) { + syntax_error(f->curr_token, "All constant declarations must be defined"); + } else if (values.count == 0) { + syntax_error(f->curr_token, "Expected an expression for this declaration"); + } + break; + } + + if (is_mutable) { + if (type == NULL && values.count == 0) { + syntax_error(f->curr_token, "Missing variable type or initialization"); + return ast_bad_decl(f, f->curr_token, f->curr_token); + } + } else { + if (type == NULL && values.count == 0 && lhs.count > 0) { + syntax_error(f->curr_token, "Missing constant value"); + return ast_bad_decl(f, f->curr_token, f->curr_token); + } + } + + if (values.e == NULL) { + values = make_ast_node_array(f); + } + + AstNodeArray specs = {}; + array_init_reserve(&specs, heap_allocator(), 1); + return ast_value_decl(f, is_mutable, lhs, type, values); +} + + + +AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) { + AstNodeArray lhs = parse_lhs_expr_list(f); + Token token = f->curr_token; + switch (token.kind) { + case Token_Eq: + case Token_AddEq: + case Token_SubEq: + case Token_MulEq: + case Token_QuoEq: + case Token_ModEq: + case Token_ModModEq: + case Token_AndEq: + case Token_OrEq: + case Token_XorEq: + case Token_ShlEq: + case Token_ShrEq: + case Token_AndNotEq: + case Token_CmpAndEq: + case Token_CmpOrEq: + { + if (f->curr_proc == NULL) { + syntax_error(f->curr_token, "You cannot use a simple statement in the file scope"); + return ast_bad_stmt(f, f->curr_token, f->curr_token); + } + next_token(f); + AstNodeArray rhs = parse_rhs_expr_list(f); + if (rhs.count == 0) { + syntax_error(token, "No right-hand side in assignment statement."); + return ast_bad_stmt(f, token, f->curr_token); + } + return ast_assign_stmt(f, token, lhs, rhs); + } break; + + case Token_in: + if (flags&StmtAllowFlag_In) { + allow_token(f, Token_in); + bool prev_allow_range = f->allow_range; + f->allow_range = true; + AstNode *expr = parse_expr(f, false); + f->allow_range = prev_allow_range; + + AstNodeArray rhs = {}; + array_init_count(&rhs, heap_allocator(), 1); + rhs.e[0] = expr; + + return ast_assign_stmt(f, token, lhs, rhs); + } + break; + + case Token_Colon: + if ((flags&StmtAllowFlag_Label) && lhs.count == 1) { + TokenKind next = look_ahead_token_kind(f, 1); + switch (next) { + case Token_for: + case Token_match: { + next_token(f); + AstNode *name = lhs.e[0]; + AstNode *label = ast_label_decl(f, ast_node_token(name), name); + AstNode *stmt = parse_stmt(f); + #define _SET_LABEL(Kind_, label_) case GB_JOIN2(AstNode_, Kind_): (stmt->Kind_).label = label_; break + switch (stmt->kind) { + _SET_LABEL(ForStmt, label); + _SET_LABEL(RangeStmt, label); + _SET_LABEL(MatchStmt, label); + _SET_LABEL(TypeMatchStmt, label); + default: + syntax_error(token, "Labels can only be applied to a loop or match statement"); + break; + } + #undef _SET_LABEL + return stmt; + } break; + } + } + + return parse_value_decl(f, lhs); + } + + if (lhs.count > 1) { + syntax_error(token, "Expected 1 expression"); + return ast_bad_stmt(f, token, f->curr_token); + } + + + + switch (token.kind) { + case Token_Inc: + case Token_Dec: + next_token(f); + return ast_inc_dec_stmt(f, token, lhs.e[0]); + } + + return ast_expr_stmt(f, lhs.e[0]); +} + + + +AstNode *parse_block_stmt(AstFile *f, b32 is_when) { + if (!is_when && f->curr_proc == NULL) { + syntax_error(f->curr_token, "You cannot use a block statement in the file scope"); + return ast_bad_stmt(f, f->curr_token, f->curr_token); + } + return parse_body(f); +} + +AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, TokenKind follow); + + +AstNode *parse_results(AstFile *f) { + if (!allow_token(f, Token_ArrowRight)) { + return NULL; + } + + if (f->curr_token.kind != Token_OpenParen) { + Token begin_token = f->curr_token; + AstNodeArray empty_names = {}; + AstNodeArray list = make_ast_node_array(f); + AstNode *type = parse_type(f); + array_add(&list, ast_field(f, empty_names, type, 0)); + return ast_field_list(f, begin_token, list); + } + + AstNode *list = NULL; + expect_token(f, Token_OpenParen); + list = parse_field_list(f, NULL, 0, Token_CloseParen); + expect_token_after(f, Token_CloseParen, "parameter list"); + return list; +} + +AstNode *parse_proc_type(AstFile *f, AstNode **foreign_library_, String *foreign_name_, String *link_name_) { + AstNode *params = {}; + AstNode *results = {}; + + Token proc_token = expect_token(f, Token_proc); + expect_token(f, Token_OpenParen); + params = parse_field_list(f, NULL, FieldFlag_Signature, Token_CloseParen); + expect_token_after(f, Token_CloseParen, "parameter list"); + results = parse_results(f); + + u64 tags = 0; + String foreign_name = {}; + String link_name = {}; + AstNode *foreign_library = NULL; + ProcCallingConvention cc = ProcCC_Odin; + + parse_proc_tags(f, &tags, &foreign_library, &foreign_name, &link_name, &cc); + + if (foreign_library_) *foreign_library_ = foreign_library; + if (foreign_name_) *foreign_name_ = foreign_name; + if (link_name_) *link_name_ = link_name; + + return ast_proc_type(f, proc_token, params, results, tags, cc); +} + +AstNode *parse_var_type(AstFile *f, bool allow_ellipsis) { + if (allow_ellipsis && f->curr_token.kind == Token_Ellipsis) { + Token tok = f->curr_token; + next_token(f); + AstNode *type = parse_type_or_ident(f); + if (type == NULL) { + error(tok, "variadic field missing type after `...`"); + type = ast_bad_expr(f, tok, f->curr_token); + } + return ast_ellipsis(f, tok, type); + } + AstNode *type = parse_type_attempt(f); + if (type == NULL) { + Token tok = f->curr_token; + error(tok, "Expected a type"); + type = ast_bad_expr(f, tok, f->curr_token); + } + return type; +} + + +typedef enum FieldPrefixKind { + FieldPrefix_Invalid, + + FieldPrefix_Using, + FieldPrefix_Immutable, + FieldPrefix_NoAlias, +} FieldPrefixKind; + +FieldPrefixKind is_token_field_prefix(AstFile *f) { + switch (f->curr_token.kind) { + case Token_EOF: + return FieldPrefix_Invalid; + + case Token_using: + return FieldPrefix_Using; + + case Token_immutable: + return FieldPrefix_Immutable; + + case Token_Hash: { + next_token(f); + switch (f->curr_token.kind) { + case Token_Ident: + if (str_eq(f->curr_token.string, str_lit("no_alias"))) { + return FieldPrefix_NoAlias; + } + break; + } + } break; + } + return FieldPrefix_Invalid; +} + + +u32 parse_field_prefixes(AstFile *f) { + i32 using_count = 0; + i32 no_alias_count = 0; + i32 immutable_count = 0; + + for (;;) { + FieldPrefixKind kind = is_token_field_prefix(f); + if (kind == FieldPrefix_Invalid) { + break; + } + switch (kind) { + case FieldPrefix_Using: using_count += 1; next_token(f); break; + case FieldPrefix_Immutable: immutable_count += 1; next_token(f); break; + case FieldPrefix_NoAlias: no_alias_count += 1; next_token(f); break; + } + } + if (using_count > 1) syntax_error(f->curr_token, "Multiple `using` in this field list"); + if (immutable_count > 1) syntax_error(f->curr_token, "Multiple `immutable` in this field list"); + if (no_alias_count > 1) syntax_error(f->curr_token, "Multiple `#no_alias` in this field list"); + + + u32 field_flags = 0; + if (using_count > 0) field_flags |= FieldFlag_using; + if (no_alias_count > 0) field_flags |= FieldFlag_no_alias; + if (immutable_count > 0) field_flags |= FieldFlag_immutable; + return field_flags; +} + +u32 check_field_prefixes(AstFile *f, isize name_count, u32 allowed_flags, u32 set_flags) { + if (name_count > 1 && (set_flags&FieldFlag_using)) { + syntax_error(f->curr_token, "Cannot apply `using` to more than one of the same type"); + set_flags &= ~FieldFlag_using; + } + + if ((allowed_flags&FieldFlag_using) == 0 && (set_flags&FieldFlag_using)) { + syntax_error(f->curr_token, "`using` is not allowed within this field list"); + set_flags &= ~FieldFlag_using; + } + if ((allowed_flags&FieldFlag_no_alias) == 0 && (set_flags&FieldFlag_no_alias)) { + syntax_error(f->curr_token, "`no_alias` is not allowed within this field list"); + set_flags &= ~FieldFlag_no_alias; + } + if ((allowed_flags&FieldFlag_immutable) == 0 && (set_flags&FieldFlag_immutable)) { + syntax_error(f->curr_token, "`immutable` is not allowed within this field list"); + set_flags &= ~FieldFlag_immutable; + } + return set_flags; +} + +typedef struct AstNodeAndFlags { + AstNode *node; + u32 flags; +} AstNodeAndFlags; + +typedef Array(AstNodeAndFlags) AstNodeAndFlagsArray; + +AstNodeArray convert_to_ident_list(AstFile *f, AstNodeAndFlagsArray list, bool ignore_flags) { + AstNodeArray idents = {}; + array_init_reserve(&idents, heap_allocator(), list.count); + // Convert to ident list + for_array(i, list) { + AstNode *ident = list.e[i].node; + + if (!ignore_flags) { + if (i != 0) { + error_node(ident, "Illegal use of prefixes in parameter list"); + } + } + + switch (ident->kind) { + case AstNode_Ident: + case AstNode_BadExpr: + break; + default: + error_node(ident, "Expected an identifier"); + ident = ast_ident(f, blank_token); + break; + } + array_add(&idents, ident); + } + return idents; +} + + +bool parse_expect_field_separator(AstFile *f, AstNode *param) { + Token token = f->curr_token; + if (allow_token(f, Token_Comma)) { + return true; + } + if (token.kind == Token_Semicolon) { + next_token(f); + error(f->curr_token, "Expected a comma, got a semicolon"); + return true; + } + return false; +} + +AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, TokenKind follow) { + TokenKind separator = Token_Comma; + Token start_token = f->curr_token; + + AstNodeArray params = make_ast_node_array(f); + AstNodeAndFlagsArray list = {}; array_init(&list, heap_allocator()); // LEAK(bill): + isize total_name_count = 0; + bool allow_ellipsis = allowed_flags&FieldFlag_ellipsis; + + while (f->curr_token.kind != follow && + f->curr_token.kind != Token_Colon && + f->curr_token.kind != Token_EOF) { + u32 flags = parse_field_prefixes(f); + AstNode *param = parse_var_type(f, allow_ellipsis); + AstNodeAndFlags naf = {param, flags}; + array_add(&list, naf); + if (f->curr_token.kind != Token_Comma) { + break; + } + next_token(f); + } + + if (f->curr_token.kind == Token_Colon) { + AstNodeArray names = convert_to_ident_list(f, list, true); // Copy for semantic reasons + if (names.count == 0) { + syntax_error(f->curr_token, "Empty field declaration"); + } + u32 set_flags = 0; + if (list.count > 0) { + set_flags = list.e[0].flags; + } + set_flags = check_field_prefixes(f, names.count, allowed_flags, set_flags); + total_name_count += names.count; + + expect_token_after(f, Token_Colon, "field list"); + AstNode *type = parse_var_type(f, allow_ellipsis); + AstNode *param = ast_field(f, names, type, set_flags); + array_add(¶ms, param); + + parse_expect_field_separator(f, type); + + while (f->curr_token.kind != follow && + f->curr_token.kind != Token_EOF) { + u32 set_flags = parse_field_prefixes(f); + AstNodeArray names = parse_ident_list(f); + if (names.count == 0) { + syntax_error(f->curr_token, "Empty field declaration"); + break; + } + set_flags = check_field_prefixes(f, names.count, allowed_flags, set_flags); + total_name_count += names.count; + + expect_token_after(f, Token_Colon, "field list"); + AstNode *type = parse_var_type(f, allow_ellipsis); + AstNode *param = ast_field(f, names, type, set_flags); + array_add(¶ms, param); + + if (!parse_expect_field_separator(f, param)) { + break; + } + } + + if (name_count_) *name_count_ = total_name_count; + return ast_field_list(f, start_token, params); + } + + for_array(i, list) { + AstNodeArray names = {}; + AstNode *type = list.e[i].node; + Token token = blank_token; + + array_init_count(&names, heap_allocator(), 1); + token.pos = ast_node_token(type).pos; + names.e[0] = ast_ident(f, token); + u32 flags = check_field_prefixes(f, list.count, allowed_flags, list.e[i].flags); + + AstNode *param = ast_field(f, names, list.e[i].node, flags); + array_add(¶ms, param); + } + + if (name_count_) *name_count_ = total_name_count; + return ast_field_list(f, start_token, params); +} + + +AstNode *parse_record_fields(AstFile *f, isize *field_count_, u32 flags, String context) { + return parse_field_list(f, field_count_, flags, Token_CloseBrace); +} + +AstNode *parse_type_or_ident(AstFile *f) { + switch (f->curr_token.kind) { + case Token_Ident: + { + AstNode *e = parse_ident(f); + while (f->curr_token.kind == Token_Period) { + Token token = f->curr_token; + next_token(f); + AstNode *sel = parse_ident(f); + e = ast_selector_expr(f, token, e, sel); + } + // TODO(bill): Merge type_or_ident into the general parsing for expressions + // if (f->curr_token.kind == Token_OpenParen) { + // HACK NOTE(bill): For type_of_val(expr) et al. + // e = parse_call_expr(f, e); + // } + return e; + } + + case Token_Hash: { + Token hash_token = expect_token(f, Token_Hash); + Token name = expect_token(f, Token_Ident); + String tag = name.string; + if (str_eq(tag, str_lit("type"))) { + AstNode *type = parse_type(f); + return ast_helper_type(f, hash_token, type); + } + syntax_error(name, "Expected `type` after #"); + return ast_bad_expr(f, hash_token, f->curr_token); + } + + case Token_Pointer: { + Token token = expect_token(f, Token_Pointer); + AstNode *elem = parse_type(f); + return ast_pointer_type(f, token, elem); + } + + case Token_atomic: { + Token token = expect_token(f, Token_atomic); + AstNode *elem = parse_type(f); + return ast_atomic_type(f, token, elem); + } + + case Token_OpenBracket: { + Token token = expect_token(f, Token_OpenBracket); + AstNode *count_expr = NULL; + bool is_vector = false; + + if (f->curr_token.kind == Token_Ellipsis) { + count_expr = ast_unary_expr(f, expect_token(f, Token_Ellipsis), NULL); + } else if (f->curr_token.kind == Token_vector) { + next_token(f); + if (f->curr_token.kind != Token_CloseBracket) { + f->expr_level++; + count_expr = parse_expr(f, false); + f->expr_level--; + } else { + syntax_error(f->curr_token, "Vector type missing count"); + } + is_vector = true; + } else if (f->curr_token.kind == Token_dynamic) { + next_token(f); + expect_token(f, Token_CloseBracket); + return ast_dynamic_array_type(f, token, parse_type(f)); + } else if (f->curr_token.kind != Token_CloseBracket) { + f->expr_level++; + count_expr = parse_expr(f, false); + f->expr_level--; + } + expect_token(f, Token_CloseBracket); + if (is_vector) { + return ast_vector_type(f, token, count_expr, parse_type(f)); + } + return ast_array_type(f, token, count_expr, parse_type(f)); + } + + case Token_map: { + Token token = expect_token(f, Token_map); + AstNode *count = NULL; + AstNode *key = NULL; + AstNode *value = NULL; + + Token open = expect_token_after(f, Token_OpenBracket, "map"); + key = parse_expr(f, true); + if (allow_token(f, Token_Comma)) { + count = key; + key = parse_type(f); + } + Token close = expect_token(f, Token_CloseBracket); + value = parse_type(f); + + return ast_map_type(f, token, count, key, value); + } break; + + case Token_struct: { + Token token = expect_token(f, Token_struct); + bool is_packed = false; + bool is_ordered = false; + AstNode *align = NULL; + + isize prev_level = f->expr_level; + f->expr_level = -1; + + while (allow_token(f, Token_Hash)) { + Token tag = expect_token_after(f, Token_Ident, "#"); + if (str_eq(tag.string, str_lit("packed"))) { + if (is_packed) { + syntax_error(tag, "Duplicate struct tag `#%.*s`", LIT(tag.string)); + } + is_packed = true; + } else if (str_eq(tag.string, str_lit("ordered"))) { + if (is_ordered) { + syntax_error(tag, "Duplicate struct tag `#%.*s`", LIT(tag.string)); + } + is_ordered = true; + } else if (str_eq(tag.string, str_lit("align"))) { + if (align) { + syntax_error(tag, "Duplicate struct tag `#%.*s`", LIT(tag.string)); + } + align = parse_expr(f, true); + } else { + syntax_error(tag, "Invalid struct tag `#%.*s`", LIT(tag.string)); + } + } + + f->expr_level = prev_level; + + if (is_packed && is_ordered) { + syntax_error(token, "`#ordered` is not needed with `#packed` which implies ordering"); + } + + Token open = expect_token_after(f, Token_OpenBrace, "struct"); + isize decl_count = 0; + AstNode *fields = parse_record_fields(f, &decl_count, FieldFlag_using, str_lit("struct")); + Token close = expect_token(f, Token_CloseBrace); + + AstNodeArray decls = {}; + if (fields != NULL) { + GB_ASSERT(fields->kind == AstNode_FieldList); + decls = fields->FieldList.list; + } + + return ast_struct_type(f, token, decls, decl_count, is_packed, is_ordered, align); + } break; + + case Token_union: { + Token token = expect_token(f, Token_union); + Token open = expect_token_after(f, Token_OpenBrace, "union"); + AstNodeArray decls = make_ast_node_array(f); + AstNodeArray variants = make_ast_node_array(f); + isize total_decl_name_count = 0; + + while (f->curr_token.kind != Token_CloseBrace && + f->curr_token.kind != Token_EOF) { + u32 decl_flags = parse_field_prefixes(f); + if (decl_flags != 0) { + AstNodeArray names = parse_ident_list(f); + if (names.count == 0) { + syntax_error(f->curr_token, "Empty field declaration"); + } + u32 set_flags = check_field_prefixes(f, names.count, FieldFlag_using, decl_flags); + total_decl_name_count += names.count; + expect_token_after(f, Token_Colon, "field list"); + AstNode *type = parse_var_type(f, false); + array_add(&decls, ast_field(f, names, type, set_flags)); + } else { + AstNodeArray names = parse_ident_list(f); + if (names.count == 0) { + break; + } + if (names.count > 1 || f->curr_token.kind == Token_Colon) { + u32 set_flags = check_field_prefixes(f, names.count, FieldFlag_using, decl_flags); + total_decl_name_count += names.count; + expect_token_after(f, Token_Colon, "field list"); + AstNode *type = parse_var_type(f, false); + array_add(&decls, ast_field(f, names, type, set_flags)); + } else { + AstNode *name = names.e[0]; + Token open = expect_token(f, Token_OpenBrace); + isize decl_count = 0; + AstNode *list = parse_record_fields(f, &decl_count, FieldFlag_using, str_lit("union")); + Token close = expect_token(f, Token_CloseBrace); + + array_add(&variants, ast_union_field(f, name, list)); + } + } + if (f->curr_token.kind != Token_Comma) { + break; + } + next_token(f); + } + + Token close = expect_token(f, Token_CloseBrace); + + + return ast_union_type(f, token, decls, total_decl_name_count, variants); + } + + case Token_raw_union: { + Token token = expect_token(f, Token_raw_union); + Token open = expect_token_after(f, Token_OpenBrace, "raw_union"); + isize decl_count = 0; + AstNode *fields = parse_record_fields(f, &decl_count, FieldFlag_using, str_lit("raw_union")); + Token close = expect_token(f, Token_CloseBrace); + + AstNodeArray decls = {}; + if (fields != NULL) { + GB_ASSERT(fields->kind == AstNode_FieldList); + decls = fields->FieldList.list; + } + + return ast_raw_union_type(f, token, decls, decl_count); + } + + case Token_enum: { + Token token = expect_token(f, Token_enum); + AstNode *base_type = NULL; + if (f->curr_token.kind != Token_OpenBrace) { + base_type = parse_type(f); + } + Token open = expect_token(f, Token_OpenBrace); + + AstNodeArray values = parse_element_list(f); + Token close = expect_token(f, Token_CloseBrace); + + return ast_enum_type(f, token, base_type, values); + } + + case Token_bit_field: { + Token token = expect_token(f, Token_bit_field); + AstNodeArray fields = make_ast_node_array(f); + AstNode *align = NULL; + Token open, close; + + isize prev_level = f->expr_level; + f->expr_level = -1; + + while (allow_token(f, Token_Hash)) { + Token tag = expect_token_after(f, Token_Ident, "#"); + if (str_eq(tag.string, str_lit("align"))) { + if (align) { + syntax_error(tag, "Duplicate bit_field tag `#%.*s`", LIT(tag.string)); + } + align = parse_expr(f, true); + } else { + syntax_error(tag, "Invalid bit_field tag `#%.*s`", LIT(tag.string)); + } + } + + f->expr_level = prev_level; + + open = expect_token_after(f, Token_OpenBrace, "bit_field"); + + while (f->curr_token.kind != Token_EOF && + f->curr_token.kind != Token_CloseBrace) { + AstNode *name = parse_ident(f); + Token colon = expect_token(f, Token_Colon); + AstNode *value = parse_expr(f, true); + + AstNode *field = ast_field_value(f, name, value, colon); + array_add(&fields, field); + + if (f->curr_token.kind != Token_Comma) { + break; + } + next_token(f); + } + + close = expect_token(f, Token_CloseBrace); + + return ast_bit_field_type(f, token, fields, align); + } + + case Token_proc: { + Token token = f->curr_token; + AstNode *pt = parse_proc_type(f, NULL, NULL, NULL); + if (pt->ProcType.tags != 0) { + syntax_error(token, "A procedure type cannot have tags"); + } + return pt; + } + + case Token_OpenParen: { + Token open = expect_token(f, Token_OpenParen); + AstNode *type = parse_type(f); + Token close = expect_token(f, Token_CloseParen); + return ast_paren_expr(f, type, open, close); + } break; + } + + // No type found + return NULL; +} + + +AstNode *parse_body(AstFile *f) { + AstNodeArray stmts = {}; + Token open, close; + isize prev_expr_level = f->expr_level; + + // NOTE(bill): The body may be within an expression so reset to zero + f->expr_level = 0; + open = expect_token(f, Token_OpenBrace); + stmts = parse_stmt_list(f); + close = expect_token(f, Token_CloseBrace); + f->expr_level = prev_expr_level; + + return ast_block_stmt(f, stmts, open, close); +} + +AstNode *parse_if_stmt(AstFile *f) { + if (f->curr_proc == NULL) { + syntax_error(f->curr_token, "You cannot use an if statement in the file scope"); + return ast_bad_stmt(f, f->curr_token, f->curr_token); + } + + Token token = expect_token(f, Token_if); + AstNode *init = NULL; + AstNode *cond = NULL; + AstNode *body = NULL; + AstNode *else_stmt = NULL; + + isize prev_level = f->expr_level; + f->expr_level = -1; + + if (allow_token(f, Token_Semicolon)) { + cond = parse_expr(f, false); + } else { + init = parse_simple_stmt(f, StmtAllowFlag_None); + if (allow_token(f, Token_Semicolon)) { + cond = parse_expr(f, false); + } else { + cond = convert_stmt_to_expr(f, init, str_lit("boolean expression")); + init = NULL; + } + } + + f->expr_level = prev_level; + + if (cond == NULL) { + syntax_error(f->curr_token, "Expected condition for if statement"); + } + + body = parse_block_stmt(f, false); + + if (allow_token(f, Token_else)) { + switch (f->curr_token.kind) { + case Token_if: + else_stmt = parse_if_stmt(f); + break; + case Token_OpenBrace: + else_stmt = parse_block_stmt(f, false); + break; + default: + syntax_error(f->curr_token, "Expected if statement block statement"); + else_stmt = ast_bad_stmt(f, f->curr_token, f->tokens.e[f->curr_token_index+1]); + break; + } + } + + return ast_if_stmt(f, token, init, cond, body, else_stmt); +} + +AstNode *parse_when_stmt(AstFile *f) { + Token token = expect_token(f, Token_when); + AstNode *cond = NULL; + AstNode *body = NULL; + AstNode *else_stmt = NULL; + + isize prev_level = f->expr_level; + f->expr_level = -1; + + cond = parse_expr(f, false); + + f->expr_level = prev_level; + + if (cond == NULL) { + syntax_error(f->curr_token, "Expected condition for when statement"); + } + + body = parse_block_stmt(f, true); + + if (allow_token(f, Token_else)) { + switch (f->curr_token.kind) { + case Token_when: + else_stmt = parse_when_stmt(f); + break; + case Token_OpenBrace: + else_stmt = parse_block_stmt(f, true); + break; + default: + syntax_error(f->curr_token, "Expected when statement block statement"); + else_stmt = ast_bad_stmt(f, f->curr_token, f->tokens.e[f->curr_token_index+1]); + break; + } + } + + return ast_when_stmt(f, token, cond, body, else_stmt); +} + + +AstNode *parse_return_stmt(AstFile *f) { + if (f->curr_proc == NULL) { + syntax_error(f->curr_token, "You cannot use a return statement in the file scope"); + return ast_bad_stmt(f, f->curr_token, f->curr_token); + } + if (f->expr_level > 0) { + syntax_error(f->curr_token, "You cannot use a return statement within an expression"); + return ast_bad_stmt(f, f->curr_token, f->curr_token); + } + + Token token = expect_token(f, Token_return); + AstNodeArray results; + if (f->curr_token.kind != Token_Semicolon && f->curr_token.kind != Token_CloseBrace) { + results = parse_rhs_expr_list(f); + } else { + results = make_ast_node_array(f); + } + + expect_semicolon(f, results.e[0]); + return ast_return_stmt(f, token, results); +} + + +// AstNode *parse_give_stmt(AstFile *f) { +// if (f->curr_proc == NULL) { +// syntax_error(f->curr_token, "You cannot use a give statement in the file scope"); +// return ast_bad_stmt(f, f->curr_token, f->curr_token); +// } +// if (f->expr_level == 0) { +// syntax_error(f->curr_token, "A give statement must be used within an expression"); +// return ast_bad_stmt(f, f->curr_token, f->curr_token); +// } + +// Token token = expect_token(f, Token_give); +// AstNodeArray results; +// if (f->curr_token.kind != Token_Semicolon && f->curr_token.kind != Token_CloseBrace) { +// results = parse_rhs_expr_list(f); +// } else { +// results = make_ast_node_array(f); +// } +// AstNode *ge = ast_give_expr(f, token, results); +// expect_semicolon(f, ge); +// return ast_expr_stmt(f, ge); +// } + +AstNode *parse_for_stmt(AstFile *f) { + if (f->curr_proc == NULL) { + syntax_error(f->curr_token, "You cannot use a for statement in the file scope"); + return ast_bad_stmt(f, f->curr_token, f->curr_token); + } + + Token token = expect_token(f, Token_for); + + AstNode *init = NULL; + AstNode *cond = NULL; + AstNode *post = NULL; + AstNode *body = NULL; + bool is_range = false; + + if (f->curr_token.kind != Token_OpenBrace) { + isize prev_level = f->expr_level; + f->expr_level = -1; + if (f->curr_token.kind != Token_Semicolon) { + cond = parse_simple_stmt(f, StmtAllowFlag_In); + if (cond->kind == AstNode_AssignStmt && cond->AssignStmt.op.kind == Token_in) { + is_range = true; + } + } + + if (!is_range && f->curr_token.kind == Token_Semicolon) { + next_token(f); + init = cond; + cond = NULL; + if (f->curr_token.kind != Token_Semicolon) { + cond = parse_simple_stmt(f, StmtAllowFlag_None); + } + expect_semicolon(f, cond); + if (f->curr_token.kind != Token_OpenBrace) { + post = parse_simple_stmt(f, StmtAllowFlag_None); + } + } + + f->expr_level = prev_level; + } + + body = parse_block_stmt(f, false); + + if (is_range) { + GB_ASSERT(cond->kind == AstNode_AssignStmt); + Token in_token = cond->AssignStmt.op; + AstNode *value = NULL; + AstNode *index = NULL; + switch (cond->AssignStmt.lhs.count) { + case 1: + value = cond->AssignStmt.lhs.e[0]; + break; + case 2: + value = cond->AssignStmt.lhs.e[0]; + index = cond->AssignStmt.lhs.e[1]; + break; + default: + error_node(cond, "Expected at 1 or 2 identifiers"); + return ast_bad_stmt(f, token, f->curr_token); + } + + AstNode *rhs = NULL; + if (cond->AssignStmt.rhs.count > 0) { + rhs = cond->AssignStmt.rhs.e[0]; + } + return ast_range_stmt(f, token, value, index, in_token, rhs, body); + } + + cond = convert_stmt_to_expr(f, cond, str_lit("boolean expression")); + return ast_for_stmt(f, token, init, cond, post, body); +} + + +AstNode *parse_case_clause(AstFile *f, bool is_type) { + Token token = f->curr_token; + AstNodeArray list = make_ast_node_array(f); + expect_token(f, Token_case); + bool prev_allow_range = f->allow_range; + f->allow_range = !is_type; + if (f->curr_token.kind != Token_Colon) { + list = parse_rhs_expr_list(f); + } + f->allow_range = prev_allow_range; + expect_token(f, Token_Colon); // TODO(bill): Is this the best syntax? + AstNodeArray stmts = parse_stmt_list(f); + + return ast_case_clause(f, token, list, stmts); +} + + +AstNode *parse_match_stmt(AstFile *f) { + if (f->curr_proc == NULL) { + syntax_error(f->curr_token, "You cannot use a match statement in the file scope"); + return ast_bad_stmt(f, f->curr_token, f->curr_token); + } + + Token token = expect_token(f, Token_match); + AstNode *init = NULL; + AstNode *tag = NULL; + AstNode *body = NULL; + Token open, close; + bool is_type_match = false; + AstNodeArray list = make_ast_node_array(f); + + if (f->curr_token.kind != Token_OpenBrace) { + isize prev_level = f->expr_level; + f->expr_level = -1; + + tag = parse_simple_stmt(f, StmtAllowFlag_In); + if (tag->kind == AstNode_AssignStmt && tag->AssignStmt.op.kind == Token_in) { + is_type_match = true; + } else { + if (allow_token(f, Token_Semicolon)) { + init = tag; + tag = NULL; + if (f->curr_token.kind != Token_OpenBrace) { + tag = parse_simple_stmt(f, StmtAllowFlag_None); + } + } + } + f->expr_level = prev_level; + } + open = expect_token(f, Token_OpenBrace); + + while (f->curr_token.kind == Token_case) { + array_add(&list, parse_case_clause(f, is_type_match)); + } + + close = expect_token(f, Token_CloseBrace); + + body = ast_block_stmt(f, list, open, close); + + if (!is_type_match) { + tag = convert_stmt_to_expr(f, tag, str_lit("match expression")); + return ast_match_stmt(f, token, init, tag, body); + } else { + return ast_type_match_stmt(f, token, tag, body); + } +} + +AstNode *parse_defer_stmt(AstFile *f) { + if (f->curr_proc == NULL) { + syntax_error(f->curr_token, "You cannot use a defer statement in the file scope"); + return ast_bad_stmt(f, f->curr_token, f->curr_token); + } + + Token token = expect_token(f, Token_defer); + AstNode *stmt = parse_stmt(f); + switch (stmt->kind) { + case AstNode_EmptyStmt: + syntax_error(token, "Empty statement after defer (e.g. `;`)"); + break; + case AstNode_DeferStmt: + syntax_error(token, "You cannot defer a defer statement"); + stmt = stmt->DeferStmt.stmt; + break; + case AstNode_ReturnStmt: + syntax_error(token, "You cannot a return statement"); + break; + } + + return ast_defer_stmt(f, token, stmt); +} + +AstNode *parse_asm_stmt(AstFile *f) { + Token token = expect_token(f, Token_asm); + bool is_volatile = false; + Token open, close, code_string; + open = expect_token(f, Token_OpenBrace); + code_string = expect_token(f, Token_String); + AstNode *output_list = NULL; + AstNode *input_list = NULL; + AstNode *clobber_list = NULL; + isize output_count = 0; + isize input_count = 0; + isize clobber_count = 0; + + // TODO(bill): Finish asm statement and determine syntax + + // if (f->curr_token.kind != Token_CloseBrace) { + // expect_token(f, Token_Colon); + // } + + close = expect_token(f, Token_CloseBrace); + + return ast_asm_stmt(f, token, is_volatile, open, close, code_string, + output_list, input_list, clobber_list, + output_count, input_count, clobber_count); + +} + + +AstNode *parse_stmt(AstFile *f) { + AstNode *s = NULL; + Token token = f->curr_token; + switch (token.kind) { + // Operands + case Token_context: + case Token_Ident: + case Token_Integer: + case Token_Float: + case Token_Imag: + case Token_Rune: + case Token_String: + case Token_OpenParen: + case Token_Pointer: + // Unary Operators + case Token_Add: + case Token_Sub: + case Token_Xor: + case Token_Not: + case Token_And: + s = parse_simple_stmt(f, StmtAllowFlag_Label); + expect_semicolon(f, s); + return s; + + case Token_if: return parse_if_stmt(f); + case Token_when: return parse_when_stmt(f); + case Token_for: return parse_for_stmt(f); + case Token_match: return parse_match_stmt(f); + case Token_defer: return parse_defer_stmt(f); + case Token_asm: return parse_asm_stmt(f); + case Token_return: return parse_return_stmt(f); + // case Token_give: return parse_give_stmt(f); + + case Token_break: + case Token_continue: + case Token_fallthrough: { + AstNode *label = NULL; + next_token(f); + if (token.kind != Token_fallthrough && + f->curr_token.kind == Token_Ident) { + label = parse_ident(f); + } + s = ast_branch_stmt(f, token, label); + expect_semicolon(f, s); + return s; + } + + case Token_using: { + // TODO(bill): Make using statements better + Token token = expect_token(f, Token_using); + AstNodeArray list = parse_lhs_expr_list(f); + if (list.count == 0) { + syntax_error(token, "Illegal use of `using` statement"); + expect_semicolon(f, NULL); + return ast_bad_stmt(f, token, f->curr_token); + } + + if (f->curr_token.kind != Token_Colon) { + expect_semicolon(f, list.e[list.count-1]); + return ast_using_stmt(f, token, list); + } + + AstNode *decl = parse_value_decl(f, list); + expect_semicolon(f, decl); + + if (decl->kind == AstNode_ValueDecl) { + #if 1 + if (!decl->ValueDecl.is_var) { + syntax_error(token, "`using` may not be applied to constant declarations"); + return decl; + } + if (f->curr_proc == NULL) { + syntax_error(token, "`using` is not allowed at the file scope"); + } else { + decl->ValueDecl.flags |= VarDeclFlag_using; + } + #else + decl->ValueDecl.flags |= VarDeclFlag_using; + #endif + return decl; + } + + syntax_error(token, "Illegal use of `using` statement"); + return ast_bad_stmt(f, token, f->curr_token); + } break; + +#if 1 + case Token_immutable: { + Token token = expect_token(f, Token_immutable); + AstNode *node = parse_stmt(f); + + if (node->kind == AstNode_ValueDecl) { + if (!node->ValueDecl.is_var) { + syntax_error(token, "`immutable` may not be applied to constant declarations"); + } else { + node->ValueDecl.flags |= VarDeclFlag_immutable; + } + return node; + } + syntax_error(token, "`immutable` may only be applied to a variable declaration"); + return ast_bad_stmt(f, token, f->curr_token); + } break; +#endif + + case Token_push_allocator: { + next_token(f); + isize prev_level = f->expr_level; + f->expr_level = -1; + AstNode *expr = parse_expr(f, false); + f->expr_level = prev_level; + + AstNode *body = parse_block_stmt(f, false); + return ast_push_allocator(f, token, expr, body); + } break; + + case Token_push_context: { + next_token(f); + isize prev_level = f->expr_level; + f->expr_level = -1; + AstNode *expr = parse_expr(f, false); + f->expr_level = prev_level; + + AstNode *body = parse_block_stmt(f, false); + return ast_push_context(f, token, expr, body); + } break; + + case Token_Hash: { + AstNode *s = NULL; + Token hash_token = expect_token(f, Token_Hash); + Token name = expect_token(f, Token_Ident); + String tag = name.string; + + if (str_eq(tag, str_lit("import"))) { + AstNode *cond = NULL; + Token import_name = {}; + + switch (f->curr_token.kind) { + case Token_Period: + import_name = f->curr_token; + import_name.kind = Token_Ident; + next_token(f); + break; + case Token_Ident: + import_name = f->curr_token; + next_token(f); + break; + default: + import_name.pos = f->curr_token.pos; + break; + } + + if (str_eq(import_name.string, str_lit("_"))) { + syntax_error(import_name, "Illegal #import name: `_`"); + } + + Token file_path = expect_token_after(f, Token_String, "#import"); + if (allow_token(f, Token_when)) { + cond = parse_expr(f, false); + } + + AstNode *decl = NULL; + if (f->curr_proc != NULL) { + syntax_error(import_name, "You cannot use `#import` within a procedure. This must be done at the file scope"); + decl = ast_bad_decl(f, import_name, file_path); + } else { + decl = ast_import_decl(f, hash_token, true, file_path, import_name, cond); + } + expect_semicolon(f, decl); + return decl; + } else if (str_eq(tag, str_lit("load"))) { + AstNode *cond = NULL; + Token file_path = expect_token_after(f, Token_String, "#load"); + Token import_name = file_path; + import_name.string = str_lit("."); + + if (allow_token(f, Token_when)) { + cond = parse_expr(f, false); + } + + AstNode *decl = NULL; + if (f->curr_proc != NULL) { + syntax_error(import_name, "You cannot use `#load` within a procedure. This must be done at the file scope"); + decl = ast_bad_decl(f, import_name, file_path); + } else { + decl = ast_import_decl(f, hash_token, false, file_path, import_name, cond); + } + expect_semicolon(f, decl); + return decl; + } else if (str_eq(tag, str_lit("shared_global_scope"))) { + if (f->curr_proc == NULL) { + f->is_global_scope = true; + s = ast_empty_stmt(f, f->curr_token); + } else { + syntax_error(token, "You cannot use #shared_global_scope within a procedure. This must be done at the file scope"); + s = ast_bad_decl(f, token, f->curr_token); + } + expect_semicolon(f, s); + return s; + } else if (str_eq(tag, str_lit("foreign_system_library"))) { + AstNode *cond = NULL; + Token lib_name = {}; + + switch (f->curr_token.kind) { + case Token_Ident: + lib_name = f->curr_token; + next_token(f); + break; + default: + lib_name.pos = f->curr_token.pos; + break; + } + + if (str_eq(lib_name.string, str_lit("_"))) { + syntax_error(lib_name, "Illegal #foreign_library name: `_`"); + } + Token file_path = expect_token(f, Token_String); + + if (allow_token(f, Token_when)) { + cond = parse_expr(f, false); + } + + if (f->curr_proc == NULL) { + s = ast_foreign_library(f, hash_token, file_path, lib_name, cond, true); + } else { + syntax_error(token, "You cannot use #foreign_system_library within a procedure. This must be done at the file scope"); + s = ast_bad_decl(f, token, file_path); + } + expect_semicolon(f, s); + return s; + } else if (str_eq(tag, str_lit("foreign_library"))) { + AstNode *cond = NULL; + Token lib_name = {}; + + switch (f->curr_token.kind) { + case Token_Ident: + lib_name = f->curr_token; + next_token(f); + break; + default: + lib_name.pos = f->curr_token.pos; + break; + } + + if (str_eq(lib_name.string, str_lit("_"))) { + syntax_error(lib_name, "Illegal #foreign_library name: `_`"); + } + Token file_path = expect_token(f, Token_String); + + if (allow_token(f, Token_when)) { + cond = parse_expr(f, false); + } + + if (f->curr_proc == NULL) { + s = ast_foreign_library(f, hash_token, file_path, lib_name, cond, false); + } else { + syntax_error(token, "You cannot use #foreign_library within a procedure. This must be done at the file scope"); + s = ast_bad_decl(f, token, file_path); + } + expect_semicolon(f, s); + return s; + } else if (str_eq(tag, str_lit("thread_local"))) { + AstNode *s = parse_stmt(f); + + if (s->kind == AstNode_ValueDecl) { + if (!s->ValueDecl.is_var) { + syntax_error(token, "`thread_local` may not be applied to constant declarations"); + } + if (f->curr_proc != NULL) { + syntax_error(token, "`thread_local` is only allowed at the file scope"); + } else { + s->ValueDecl.flags |= VarDeclFlag_thread_local; + } + return s; + } + syntax_error(token, "`thread_local` may only be applied to a variable declaration"); + return ast_bad_stmt(f, token, f->curr_token); + } else if (str_eq(tag, str_lit("bounds_check"))) { + s = parse_stmt(f); + s->stmt_state_flags |= StmtStateFlag_bounds_check; + if ((s->stmt_state_flags & StmtStateFlag_no_bounds_check) != 0) { + syntax_error(token, "#bounds_check and #no_bounds_check cannot be applied together"); + } + return s; + } else if (str_eq(tag, str_lit("no_bounds_check"))) { + s = parse_stmt(f); + s->stmt_state_flags |= StmtStateFlag_no_bounds_check; + if ((s->stmt_state_flags & StmtStateFlag_bounds_check) != 0) { + syntax_error(token, "#bounds_check and #no_bounds_check cannot be applied together"); + } + return s; + } + + if (str_eq(tag, str_lit("include"))) { + syntax_error(token, "#include is not a valid import declaration kind. Use #load instead"); + s = ast_bad_stmt(f, token, f->curr_token); + } else { + syntax_error(token, "Unknown tag directive used: `%.*s`", LIT(tag)); + s = ast_bad_stmt(f, token, f->curr_token); + } + + fix_advance_to_next_stmt(f); + + return s; + } break; + + case Token_OpenBrace: + return parse_block_stmt(f, false); + + case Token_Semicolon: + s = ast_empty_stmt(f, token); + next_token(f); + return s; + } + + syntax_error(token, + "Expected a statement, got `%.*s`", + LIT(token_strings[token.kind])); + fix_advance_to_next_stmt(f); + return ast_bad_stmt(f, token, f->curr_token); +} + +AstNodeArray parse_stmt_list(AstFile *f) { + AstNodeArray list = make_ast_node_array(f); + + while (f->curr_token.kind != Token_case && + f->curr_token.kind != Token_CloseBrace && + f->curr_token.kind != Token_EOF) { + AstNode *stmt = parse_stmt(f); + if (stmt && stmt->kind != AstNode_EmptyStmt) { + array_add(&list, stmt); + if (stmt->kind == AstNode_ExprStmt && + stmt->ExprStmt.expr != NULL && + stmt->ExprStmt.expr->kind == AstNode_ProcLit) { + syntax_error_node(stmt, "Procedure literal evaluated but not used"); + } + } + } + + return list; +} + + +ParseFileError init_ast_file(AstFile *f, String fullpath) { + fullpath = string_trim_whitespace(fullpath); // Just in case + if (!string_has_extension(fullpath, str_lit("odin"))) { + return ParseFile_WrongExtension; + } + TokenizerInitError err = init_tokenizer(&f->tokenizer, fullpath); + if (err == TokenizerInit_None) { + array_init(&f->tokens, heap_allocator()); + { + for (;;) { + Token token = tokenizer_get_token(&f->tokenizer); + if (token.kind == Token_Invalid) { + return ParseFile_InvalidToken; + } + array_add(&f->tokens, token); + + if (token.kind == Token_EOF) { + break; + } + } + } + + f->curr_token_index = 0; + f->prev_token = f->tokens.e[f->curr_token_index]; + f->curr_token = f->tokens.e[f->curr_token_index]; + + // NOTE(bill): Is this big enough or too small? + isize arena_size = gb_size_of(AstNode); + arena_size *= 2*f->tokens.count; + gb_arena_init_from_allocator(&f->arena, heap_allocator(), arena_size); + + f->curr_proc = NULL; + + return ParseFile_None; + } + + switch (err) { + case TokenizerInit_NotExists: + return ParseFile_NotFound; + case TokenizerInit_Permission: + return ParseFile_Permission; + case TokenizerInit_Empty: + return ParseFile_EmptyFile; + } + + return ParseFile_InvalidFile; +} + +void destroy_ast_file(AstFile *f) { + gb_arena_free(&f->arena); + array_free(&f->tokens); + gb_free(heap_allocator(), f->tokenizer.fullpath.text); + destroy_tokenizer(&f->tokenizer); +} + +bool init_parser(Parser *p) { + array_init(&p->files, heap_allocator()); + array_init(&p->imports, heap_allocator()); + gb_mutex_init(&p->mutex); + return true; +} + +void destroy_parser(Parser *p) { + // TODO(bill): Fix memory leak + for_array(i, p->files) { + destroy_ast_file(&p->files.e[i]); + } +#if 0 + for_array(i, p->imports) { + // gb_free(heap_allocator(), p->imports[i].text); + } +#endif + array_free(&p->files); + array_free(&p->imports); + gb_mutex_destroy(&p->mutex); +} + +// NOTE(bill): Returns true if it's added +bool try_add_import_path(Parser *p, String path, String rel_path, TokenPos pos) { + gb_mutex_lock(&p->mutex); + + path = string_trim_whitespace(path); + rel_path = string_trim_whitespace(rel_path); + + for_array(i, p->imports) { + String import = p->imports.e[i].path; + if (str_eq(import, path)) { + return false; + } + } + + ImportedFile item; + item.path = path; + item.rel_path = rel_path; + item.pos = pos; + array_add(&p->imports, item); + + gb_mutex_unlock(&p->mutex); + + return true; +} + +gb_global Rune illegal_import_runes[] = { + '"', '\'', '`', ' ', '\t', '\r', '\n', '\v', '\f', + '\\', // NOTE(bill): Disallow windows style filepaths + '!', '$', '%', '^', '&', '*', '(', ')', '=', '+', + '[', ']', '{', '}', + ';', ':', '#', + '|', ',', '<', '>', '?', +}; + +bool is_import_path_valid(String path) { + if (path.len > 0) { + u8 *start = path.text; + u8 *end = path.text + path.len; + u8 *curr = start; + while (curr < end) { + isize width = 1; + Rune r = curr[0]; + if (r >= 0x80) { + width = gb_utf8_decode(curr, end-curr, &r); + if (r == GB_RUNE_INVALID && width == 1) { + return false; + } + else if (r == GB_RUNE_BOM && curr-start > 0) { + return false; + } + } + + for (isize i = 0; i < gb_count_of(illegal_import_runes); i++) { + if (r == illegal_import_runes[i]) { + return false; + } + } + + curr += width; + } + + return true; + } + return false; +} + +void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, AstNodeArray decls) { + for_array(i, decls) { + AstNode *node = decls.e[i]; + if (!is_ast_node_decl(node) && + node->kind != AstNode_BadStmt && + node->kind != AstNode_EmptyStmt) { + // NOTE(bill): Sanity check + syntax_error_node(node, "Only declarations are allowed at file scope %.*s", LIT(ast_node_strings[node->kind])); + } else if (node->kind == AstNode_ImportDecl) { + ast_node(id, ImportDecl, node); + String collection_name = {}; + String oirignal_string = id->relpath.string; + String file_str = id->relpath.string; + gbAllocator allocator = heap_allocator(); // TODO(bill): Change this allocator + String import_file = {}; + + #if 0 + isize colon_pos = -1; + for (isize j = 0; j < file_str.len; j++) { + if (file_str.text[j] == ':') { + colon_pos = j; + break; + } + } + if (colon_pos > 0) { + collection_name = make_string(file_str.text, colon_pos); + file_str.text += colon_pos+1; + file_str.len -= colon_pos+1; + } + + if (collection_name.len == 0) { + syntax_error_node(node, "Missing import collection for path: `%.*s`", LIT(oirignal_string)); + decls.e[i] = ast_bad_decl(f, id->relpath, id->relpath); + continue; + } + + + if (str_eq(collection_name, str_lit("core"))) { + String abs_path = get_fullpath_core(allocator, file_str); + if (gb_file_exists(cast(char *)abs_path.text)) { // NOTE(bill): This should be null terminated + import_file = abs_path; + } + } else if (str_eq(collection_name, str_lit("local"))) { + String rel_path = get_fullpath_relative(allocator, base_dir, file_str); + if (gb_file_exists(cast(char *)rel_path.text)) { // NOTE(bill): This should be null terminated + import_file = rel_path; + } + } else { + syntax_error_node(node, "Unknown import collection: `%.*s`", LIT(collection_name)); + decls.e[i] = ast_bad_decl(f, id->relpath, id->relpath); + continue; + } + + if (!is_import_path_valid(file_str)) { + if (id->is_import) { + syntax_error_node(node, "Invalid import path: `%.*s`", LIT(file_str)); + } else { + syntax_error_node(node, "Invalid include path: `%.*s`", LIT(file_str)); + } + // NOTE(bill): It's a naughty name + decls.e[i] = ast_bad_decl(f, id->relpath, id->relpath); + continue; + } + + #else + if (!is_import_path_valid(file_str)) { + if (id->is_import) { + syntax_error_node(node, "Invalid import path: `%.*s`", LIT(file_str)); + } else { + syntax_error_node(node, "Invalid include path: `%.*s`", LIT(file_str)); + } + // NOTE(bill): It's a naughty name + decls.e[i] = ast_bad_decl(f, id->relpath, id->relpath); + continue; + } + + + String rel_path = get_fullpath_relative(allocator, base_dir, file_str); + import_file = rel_path; + if (!gb_file_exists(cast(char *)rel_path.text)) { // NOTE(bill): This should be null terminated + String abs_path = get_fullpath_core(allocator, file_str); + if (gb_file_exists(cast(char *)abs_path.text)) { + import_file = abs_path; + } + } + #endif + + id->fullpath = import_file; + try_add_import_path(p, import_file, file_str, ast_node_token(node).pos); + } else if (node->kind == AstNode_ForeignLibrary) { + AstNodeForeignLibrary *fl = &node->ForeignLibrary; + String file_str = fl->filepath.string; + + if (!is_import_path_valid(file_str)) { + if (fl->is_system) { + syntax_error_node(node, "Invalid `foreign_system_library` path"); + } else { + syntax_error_node(node, "Invalid `foreign_library` path"); + } + // NOTE(bill): It's a naughty name + f->decls.e[i] = ast_bad_decl(f, fl->token, fl->token); + continue; + } + + fl->base_dir = base_dir; + } + } +} + +void parse_file(Parser *p, AstFile *f) { + String filepath = f->tokenizer.fullpath; + String base_dir = filepath; + for (isize i = filepath.len-1; i >= 0; i--) { + if (base_dir.text[i] == '\\' || + base_dir.text[i] == '/') { + break; + } + base_dir.len--; + } + + while (f->curr_token.kind == Token_Comment) { + next_token(f); + } + + f->decls = parse_stmt_list(f); + parse_setup_file_decls(p, f, base_dir, f->decls); +} + + + +ParseFileError parse_files(Parser *p, char *init_filename) { + char *fullpath_str = gb_path_get_full_name(heap_allocator(), init_filename); + String init_fullpath = make_string_c(fullpath_str); + TokenPos init_pos = {}; + ImportedFile init_imported_file = {init_fullpath, init_fullpath, init_pos}; + + + { + String s = get_fullpath_core(heap_allocator(), str_lit("_preload.odin")); + ImportedFile runtime_file = {s, s, init_pos}; + array_add(&p->imports, runtime_file); + } + { + String s = get_fullpath_core(heap_allocator(), str_lit("_soft_numbers.odin")); + ImportedFile runtime_file = {s, s, init_pos}; + array_add(&p->imports, runtime_file); + } + + array_add(&p->imports, init_imported_file); + p->init_fullpath = init_fullpath; + + for_array(i, p->imports) { + ImportedFile imported_file = p->imports.e[i]; + String import_path = imported_file.path; + String import_rel_path = imported_file.rel_path; + TokenPos pos = imported_file.pos; + AstFile file = {}; + + ParseFileError err = init_ast_file(&file, import_path); + + if (err != ParseFile_None) { + if (err == ParseFile_EmptyFile) { + if (str_eq(import_path, init_fullpath)) { + gb_printf_err("Initial file is empty - %.*s\n", LIT(init_fullpath)); + gb_exit(1); + } + return ParseFile_None; + } + + if (pos.line != 0) { + gb_printf_err("%.*s(%td:%td) ", LIT(pos.file), pos.line, pos.column); + } + gb_printf_err("Failed to parse file: %.*s\n\t", LIT(import_rel_path)); + switch (err) { + case ParseFile_WrongExtension: + gb_printf_err("Invalid file extension: File must have the extension `.odin`"); + break; + case ParseFile_InvalidFile: + gb_printf_err("Invalid file or cannot be found"); + break; + case ParseFile_Permission: + gb_printf_err("File permissions problem"); + break; + case ParseFile_NotFound: + gb_printf_err("File cannot be found (`%.*s`)", LIT(import_path)); + break; + case ParseFile_InvalidToken: + gb_printf_err("Invalid token found in file"); + break; + } + gb_printf_err("\n"); + return err; + } + parse_file(p, &file); + + { + gb_mutex_lock(&p->mutex); + file.id = p->files.count; + array_add(&p->files, file); + p->total_line_count += file.tokenizer.line_count; + gb_mutex_unlock(&p->mutex); + } + } + + for_array(i, p->files) { + p->total_token_count += p->files.e[i].tokens.count; + } + + + return ParseFile_None; +} + + |