diff --git a/core_compiler_interface.hpp b/core_compiler_interface.hpp index 1704f8a..c77f420 100644 --- a/core_compiler_interface.hpp +++ b/core_compiler_interface.hpp @@ -366,7 +366,10 @@ enum { struct Ast { uint64_t di; // Debug id, shouldn't ever be used in the program Token *pos; + Ast_Kind kind; + uint32_t visit_id; + Ast_Scope *parent_scope; Ast_Flag flags; }; @@ -554,7 +557,6 @@ struct Ast_Scope : Ast { List decls; Array stmts; - uint32_t visit_id; uint32_t scope_id; Ast_Scope *file; // Self referential for file and module Ast_Module *module; diff --git a/core_polymorph.cpp b/core_polymorph.cpp index 6a3b817..21ee711 100644 --- a/core_polymorph.cpp +++ b/core_polymorph.cpp @@ -23,90 +23,195 @@ struct Ast_Iter { Array stack; Ast *ast; Ast_Kind kind; + uint32_t visit_id; }; +uint32_t Ast_Iter_VisitIDGen; Ast_Iter iterate_depth_first(Allocator *a, Ast *ast) { Ast_Iter result = {}; result.stack = {a}; - result.ast = ast; - result.kind = ast->kind; + result.stack.add(ast); + result.visit_id = ++Ast_Iter_VisitIDGen; return result; } void next(Ast_Iter *iter) { - Ast *ast = iter->ast; - switch (ast->kind) { - case AST_NAMESPACE: { - } break; - case AST_MODULE: { - } break; - case AST_FILE: { - } break; + if (iter->stack.len <= 0) { + iter->ast = 0; + iter->kind = AST_NONE; + return; + } + + Ast *ast = iter->stack.pop(); + assert(ast != 0); + iter->ast = ast; + iter->kind = ast->kind; + if (ast->visit_id == iter->visit_id) { + iter->kind = (Ast_Kind)((unsigned)iter->kind + 128); + } + ast->visit_id = iter->visit_id; + + switch (iter->kind) { case AST_SCOPE: { + Ast_Scope *node = (Ast_Scope *)ast; + For(node->decls) { + iter->stack.add(it); + } + For(node->stmts) { + iter->stack.add(it); + } + iter->stack.add(node); } break; + + case AST_MODULE: invalid_codepath; break; + case AST_FILE: invalid_codepath; break; + + case AST_IDENT: case AST_VALUE: { + Ast_Atom *node = (Ast_Atom *)ast; } break; - case AST_IDENT: { - } break; + case AST_INDEX: { + Ast_Index *node = (Ast_Index *)ast; + iter->stack.add(node->expr); + iter->stack.add(node->index); + iter->stack.add(node); } break; + case AST_UNARY: { + Ast_Unary *node = (Ast_Unary *)ast; + iter->stack.add(node->expr); + iter->stack.add(node); } break; + case AST_BINARY: { + Ast_Binary *node = (Ast_Binary *)ast; + iter->stack.add(node->left); + iter->stack.add(node->right); + iter->stack.add(node); } break; + case AST_CALL_ITEM: { + Ast_Call_Item *node = (Ast_Call_Item *)ast; + iter->stack.add(node->item); + if (node->call_flags & CALL_INDEX) { + iter->stack.add(node->index); + } + else if (node->call_flags & CALL_NAME) { + iter->stack.add(node->name); + } + iter->stack.add(node); } break; + + case AST_COMPOUND: case AST_CALL: { + Ast_Call *node = (Ast_Call *)ast; + iter->stack.add(node->name); + For(node->exprs) { + iter->stack.add(it); + } + iter->stack.add(node); } break; + + case AST_TYPE_OF: + case AST_LENGTH_OF: + case AST_ALIGN_OF: + case AST_SIZE_OF: + case AST_RUNTIME_ASSERT: case AST_CONSTANT_ASSERT: { + Ast_Builtin *node = (Ast_Builtin *)ast; + iter->stack.add(node->expr); + iter->stack.add(node); } break; - case AST_RUNTIME_ASSERT: { - } break; - case AST_SIZE_OF: { - } break; - case AST_LENGTH_OF: { - } break; - case AST_ALIGN_OF: { - } break; - case AST_TYPE_OF: { - } break; + case AST_SWITCH: { + Ast_Switch *node = (Ast_Switch *)ast; + iter->stack.add(node->value); + For(node->cases) iter->stack.add(it); + iter->stack.add(node->default_scope); + iter->stack.add(node); } break; + case AST_SWITCH_CASE: { + Ast_Switch_Case *node = (Ast_Switch_Case *)ast; + For(node->labels) iter->stack.add(it); + iter->stack.add(node->scope); + iter->stack.add(node); } break; + case AST_VAR_UNPACK: { + Ast_Var_Unpack *node = (Ast_Var_Unpack *)ast; + For(node->vars) iter->stack.add(it); + iter->stack.add(node->expr); + iter->stack.add(node); } break; + + case AST_PASS: case AST_BREAK: { + Ast *node = (Ast *)ast; } break; - case AST_COMPOUND: { - } break; - case AST_TYPE: { - } break; + + case AST_NAMESPACE: + case AST_STRUCT: + case AST_UNION: + case AST_ENUM: + case AST_LAMBDA: + case AST_TYPE: // @cleanup: what is this used for? + case AST_CONST: case AST_VAR: { + Ast_Decl *node = (Ast_Decl *)ast; + + iter->stack.add(node->typespec); + iter->stack.add(node->expr); + iter->stack.add(node->scope); + iter->stack.add(node); + + // omitting polymorphs + // omitting polymorph parameters } break; - case AST_CONST: { - } break; + case AST_ARRAY: { + Ast_Array *node = (Ast_Array *)ast; + iter->stack.add(node->expr); + iter->stack.add(node); + // dst->expr = (Ast_Expr *)ast_copy(node->expr, parent_scope); } break; + case AST_FOR: { + Ast_For *node = (Ast_For *)ast; + if (node->init) iter->stack.add(node->init); + if (node->cond) iter->stack.add(node->cond); + if (node->iter) iter->stack.add(node->iter); + iter->stack.add(node->scope); + iter->stack.add(node); } break; + case AST_IF: { + Ast_If *node = (Ast_If *)ast; + For(node->ifs) iter->stack.add(it); + iter->stack.add(node); } break; + case AST_IF_NODE: { + Ast_If_Node *node = (Ast_If_Node *)ast; + if (node->init) iter->stack.add(node->init); + iter->stack.add(node->expr); + iter->stack.add(node->scope); + iter->stack.add(node); } break; + case AST_RETURN: { + Ast_Return *node = (Ast_Return *)ast; + For(node->expr) iter->stack.add(it); + iter->stack.add(node); } break; - case AST_PASS: { - } break; - case AST_LAMBDA: { - } break; + case AST_LAMBDA_EXPR: { - } break; - case AST_ENUM: { - } break; - case AST_STRUCT: { - } break; - case AST_UNION: { + Ast_Lambda *node = (Ast_Lambda *)ast; + For(node->args) iter->stack.add(it); + For(node->ret) iter->stack.add(it); + iter->stack.add(node->scope); + iter->stack.add(node); } break; } } @@ -121,12 +226,6 @@ Ast *ast_copy(Ast *ast, Ast_Scope *parent_scope) { Ast_Scope *dst = push_struct_copy(pctx->perm, Ast_Scope, ast); dst->parent_scope = parent_scope; - dst->implicit_imports = {}; - For(src->implicit_imports) { - Ast_Scope *copy = (Ast_Scope *)ast_copy(it, dst); - add(pctx->perm, &dst->implicit_imports, copy); - } - dst->decls = {}; For(src->decls) { Ast_Decl *copy = (Ast_Decl *)ast_copy(it, dst);