463 lines
15 KiB
C++
463 lines
15 KiB
C++
|
|
|
|
Ast_Decl *get_or_instantiate_polymorph_type(Ast_Decl *poly, Array<Ast_Call_Item *> params) {
|
|
return 0;
|
|
}
|
|
|
|
/* @todo
|
|
for (Ast_Iter iter = iterate_depth_first(ast); iter.ast; next(&iter)) {
|
|
Ast *ast = iter.ast;
|
|
|
|
switch(ast->kind) {
|
|
case AST_CALL: {
|
|
|
|
} break;
|
|
case AST_CALL_END: {
|
|
|
|
} break;
|
|
}
|
|
}
|
|
*/
|
|
|
|
struct Ast_Iter {
|
|
Array<Ast *> stack;
|
|
Ast *ast;
|
|
Ast_Kind kind;
|
|
uint32_t visit_id;
|
|
uint32_t di;
|
|
};
|
|
|
|
uint32_t Ast_Iter_VisitIDGen;
|
|
Ast_Iter iterate_depth_first(Allocator *a, Ast *ast) {
|
|
Ast_Iter result = {};
|
|
result.stack = {a};
|
|
result.stack.add(ast);
|
|
result.visit_id = ++Ast_Iter_VisitIDGen;
|
|
void next(Ast_Iter * iter);
|
|
next(&result);
|
|
return result;
|
|
}
|
|
|
|
void next(Ast_Iter *iter) {
|
|
if (iter->stack.len <= 0) {
|
|
iter->ast = 0;
|
|
iter->kind = AST_NONE;
|
|
iter->stack.dealloc();
|
|
return;
|
|
}
|
|
|
|
Ast *ast = iter->stack.pop();
|
|
assert(ast != 0);
|
|
iter->di += 1;
|
|
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;
|
|
iter->stack.add(node);
|
|
For(node->stmts) iter->stack.add(it);
|
|
For(node->decls) iter->stack.add(it);
|
|
} 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_INDEX: {
|
|
Ast_Index *node = (Ast_Index *)ast;
|
|
iter->stack.add(node);
|
|
iter->stack.add(node->index);
|
|
iter->stack.add(node->expr);
|
|
} break;
|
|
|
|
case AST_UNARY: {
|
|
Ast_Unary *node = (Ast_Unary *)ast;
|
|
iter->stack.add(node);
|
|
iter->stack.add(node->expr);
|
|
} break;
|
|
|
|
case AST_BINARY: {
|
|
Ast_Binary *node = (Ast_Binary *)ast;
|
|
iter->stack.add(node);
|
|
iter->stack.add(node->right);
|
|
iter->stack.add(node->left);
|
|
} break;
|
|
|
|
case AST_CALL_ITEM: {
|
|
Ast_Call_Item *node = (Ast_Call_Item *)ast;
|
|
iter->stack.add(node);
|
|
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);
|
|
} break;
|
|
|
|
case AST_COMPOUND:
|
|
case AST_CALL: {
|
|
Ast_Call *node = (Ast_Call *)ast;
|
|
iter->stack.add(node);
|
|
For(node->exprs) iter->stack.add(it);
|
|
iter->stack.add(node->name);
|
|
} 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);
|
|
iter->stack.add(node->expr);
|
|
} break;
|
|
|
|
case AST_SWITCH: {
|
|
Ast_Switch *node = (Ast_Switch *)ast;
|
|
iter->stack.add(node);
|
|
iter->stack.add(node->default_scope);
|
|
For(node->cases) iter->stack.add(it);
|
|
iter->stack.add(node->value);
|
|
} break;
|
|
|
|
case AST_SWITCH_CASE: {
|
|
Ast_Switch_Case *node = (Ast_Switch_Case *)ast;
|
|
iter->stack.add(node);
|
|
iter->stack.add(node->scope);
|
|
For(node->labels) iter->stack.add(it);
|
|
} break;
|
|
|
|
case AST_VAR_UNPACK: {
|
|
Ast_Var_Unpack *node = (Ast_Var_Unpack *)ast;
|
|
iter->stack.add(node);
|
|
iter->stack.add(node->expr);
|
|
For(node->vars) iter->stack.add(it);
|
|
} break;
|
|
|
|
case AST_PASS:
|
|
case AST_BREAK: {
|
|
Ast *node = (Ast *)ast;
|
|
} 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);
|
|
if (node->scope) iter->stack.add(node->scope);
|
|
if (node->expr) iter->stack.add(node->expr);
|
|
if (node->typespec) iter->stack.add(node->typespec);
|
|
|
|
// omitting polymorphs
|
|
// omitting polymorph parameters
|
|
} break;
|
|
|
|
case AST_ARRAY: {
|
|
Ast_Array *node = (Ast_Array *)ast;
|
|
iter->stack.add(node);
|
|
iter->stack.add(node->expr);
|
|
} break;
|
|
|
|
case AST_FOR: {
|
|
Ast_For *node = (Ast_For *)ast;
|
|
iter->stack.add(node);
|
|
iter->stack.add(node->scope);
|
|
if (node->iter) iter->stack.add(node->iter);
|
|
if (node->cond) iter->stack.add(node->cond);
|
|
if (node->init) iter->stack.add(node->init);
|
|
} break;
|
|
|
|
case AST_IF: {
|
|
Ast_If *node = (Ast_If *)ast;
|
|
iter->stack.add(node);
|
|
For(node->ifs) iter->stack.add(it);
|
|
} break;
|
|
|
|
case AST_IF_NODE: {
|
|
Ast_If_Node *node = (Ast_If_Node *)ast;
|
|
iter->stack.add(node);
|
|
iter->stack.add(node->scope);
|
|
iter->stack.add(node->expr);
|
|
if (node->init) iter->stack.add(node->init);
|
|
} break;
|
|
|
|
case AST_RETURN: {
|
|
Ast_Return *node = (Ast_Return *)ast;
|
|
iter->stack.add(node);
|
|
For(node->expr) iter->stack.add(it);
|
|
} break;
|
|
|
|
case AST_LAMBDA_EXPR: {
|
|
Ast_Lambda *node = (Ast_Lambda *)ast;
|
|
iter->stack.add(node);
|
|
iter->stack.add(node->scope);
|
|
For(node->ret) iter->stack.add(it);
|
|
For(node->args) iter->stack.add(it);
|
|
} break;
|
|
}
|
|
}
|
|
|
|
// We are not copying module and file Ast's
|
|
// We are not copying resolved data
|
|
Ast *ast_copy(Ast *ast, Ast_Scope *parent_scope) {
|
|
if (!ast) return 0;
|
|
switch (ast->kind) {
|
|
case AST_SCOPE: {
|
|
Ast_Scope *src = (Ast_Scope *)ast;
|
|
Ast_Scope *dst = push_struct_copy(pctx->perm, Ast_Scope, ast);
|
|
dst->parent_scope = parent_scope;
|
|
|
|
dst->decls = {};
|
|
For(src->decls) {
|
|
Ast_Decl *copy = (Ast_Decl *)ast_copy(it, dst);
|
|
add(pctx->perm, &dst->decls, copy);
|
|
}
|
|
|
|
dst->stmts.init(pctx->perm, src->stmts.len);
|
|
For(src->stmts) {
|
|
Ast *copy = ast_copy(it, dst);
|
|
dst->stmts.add(copy);
|
|
}
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_MODULE: invalid_codepath; break;
|
|
case AST_FILE: invalid_codepath; break;
|
|
|
|
case AST_IDENT:
|
|
case AST_VALUE: {
|
|
Ast_Atom *src = (Ast_Atom *)ast;
|
|
Ast_Atom *dst = push_struct_copy(pctx->perm, Ast_Atom, ast);
|
|
dst->parent_scope = parent_scope;
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_INDEX: {
|
|
Ast_Index *src = (Ast_Index *)ast;
|
|
Ast_Index *dst = push_struct_copy(pctx->perm, Ast_Index, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->expr = (Ast_Expr *)ast_copy(src->expr, parent_scope);
|
|
dst->index = (Ast_Expr *)ast_copy(src->index, parent_scope);
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_UNARY: {
|
|
Ast_Unary *src = (Ast_Unary *)ast;
|
|
Ast_Unary *dst = push_struct_copy(pctx->perm, Ast_Unary, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->expr = (Ast_Expr *)ast_copy(src->expr, parent_scope);
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_BINARY: {
|
|
Ast_Binary *src = (Ast_Binary *)ast;
|
|
Ast_Binary *dst = push_struct_copy(pctx->perm, Ast_Binary, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->left = (Ast_Expr *)ast_copy(src->left, parent_scope);
|
|
dst->right = (Ast_Expr *)ast_copy(src->right, parent_scope);
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_CALL_ITEM: {
|
|
Ast_Call_Item *src = (Ast_Call_Item *)ast;
|
|
Ast_Call_Item *dst = push_struct_copy(pctx->perm, Ast_Call_Item, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->item = (Ast_Expr *)ast_copy(src->item, parent_scope);
|
|
if (src->call_flags & CALL_INDEX) {
|
|
dst->index = (Ast_Expr *)ast_copy(src->index, parent_scope);
|
|
}
|
|
else if (src->call_flags & CALL_NAME) {
|
|
dst->name = (Ast_Atom *)ast_copy(src->name, parent_scope);
|
|
}
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_COMPOUND:
|
|
case AST_CALL: {
|
|
Ast_Call *src = (Ast_Call *)ast;
|
|
Ast_Call *dst = push_struct_copy(pctx->perm, Ast_Call, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->name = (Ast_Expr *)ast_copy(src->name, parent_scope);
|
|
|
|
dst->exprs.init(pctx->perm, src->exprs.len);
|
|
For(dst->exprs) {
|
|
auto copy = (Ast_Call_Item *)ast_copy(it, parent_scope);
|
|
dst->exprs.add(copy);
|
|
}
|
|
return dst;
|
|
} 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 *src = (Ast_Builtin *)ast;
|
|
Ast_Builtin *dst = push_struct_copy(pctx->perm, Ast_Builtin, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->expr = (Ast_Expr *)ast_copy(src->expr, parent_scope);
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_SWITCH: {
|
|
Ast_Switch *src = (Ast_Switch *)ast;
|
|
Ast_Switch *dst = push_struct_copy(pctx->perm, Ast_Switch, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->value = (Ast_Expr *)ast_copy(src->value, parent_scope);
|
|
dst->default_scope = (Ast_Scope *)ast_copy(src->default_scope, parent_scope);
|
|
|
|
dst->cases.init(pctx->perm, src->cases.len);
|
|
For(src->cases) {
|
|
auto copy = (Ast_Switch_Case *)ast_copy(it, parent_scope);
|
|
assert(copy->kind == AST_SWITCH_CASE);
|
|
dst->cases.add(copy);
|
|
}
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_SWITCH_CASE: {
|
|
Ast_Switch_Case *src = (Ast_Switch_Case *)ast;
|
|
Ast_Switch_Case *dst = push_struct_copy(pctx->perm, Ast_Switch_Case, ast);
|
|
dst->parent_scope = parent_scope;
|
|
|
|
dst->scope = (Ast_Scope *)ast_copy(src->scope, parent_scope);
|
|
dst->labels.init(pctx->perm, src->labels.len);
|
|
For(src->labels) {
|
|
auto copy = (Ast_Expr *)ast_copy(it, parent_scope);
|
|
dst->labels.add(copy);
|
|
}
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_VAR_UNPACK: {
|
|
Ast_Var_Unpack *src = (Ast_Var_Unpack *)ast;
|
|
Ast_Var_Unpack *dst = push_struct_copy(pctx->perm, Ast_Var_Unpack, ast);
|
|
dst->parent_scope = parent_scope;
|
|
|
|
dst->expr = (Ast_Expr *)ast_copy(src->expr, parent_scope);
|
|
dst->vars.init(pctx->perm, src->vars.len);
|
|
For(src->vars) {
|
|
auto copy = (Ast_Decl *)ast_copy(it, parent_scope);
|
|
dst->vars.add(copy);
|
|
}
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_PASS:
|
|
case AST_BREAK: {
|
|
Ast *src = (Ast *)ast;
|
|
Ast *dst = push_struct_copy(pctx->perm, Ast, ast);
|
|
dst->parent_scope = parent_scope;
|
|
return dst;
|
|
} 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 *src = (Ast_Decl *)ast;
|
|
Ast_Decl *dst = push_struct_copy(pctx->perm, Ast_Decl, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->overload_op_info = push_struct_copy(pctx->perm, Ast_Operator_Info, src->overload_op_info);
|
|
// omitting polymorphs
|
|
// omitting polymorph parameters
|
|
dst->scope = (Ast_Scope *)ast_copy(src->scope, parent_scope);
|
|
dst->typespec = (Ast_Expr *)ast_copy(src->typespec, parent_scope);
|
|
dst->expr = (Ast_Expr *)ast_copy(src->expr, parent_scope);
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_ARRAY: {
|
|
Ast_Array *src = (Ast_Array *)ast;
|
|
Ast_Array *dst = push_struct_copy(pctx->perm, Ast_Array, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->expr = (Ast_Expr *)ast_copy(src->expr, parent_scope);
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_FOR: {
|
|
Ast_For *src = (Ast_For *)ast;
|
|
Ast_For *dst = push_struct_copy(pctx->perm, Ast_For, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->scope = (Ast_Scope *)ast_copy(src->scope, parent_scope);
|
|
dst->init = (Ast_Expr *)ast_copy(src->init, parent_scope);
|
|
dst->cond = (Ast_Expr *)ast_copy(src->cond, parent_scope);
|
|
dst->iter = (Ast_Expr *)ast_copy(src->iter, parent_scope);
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_IF: {
|
|
Ast_If *src = (Ast_If *)ast;
|
|
Ast_If *dst = push_struct_copy(pctx->perm, Ast_If, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->ifs.init(pctx->perm, src->ifs.len);
|
|
For(src->ifs) {
|
|
auto copy = (Ast_If_Node *)ast_copy(it, parent_scope);
|
|
assert(copy->kind == AST_IF_NODE);
|
|
dst->ifs.add(copy);
|
|
}
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_IF_NODE: {
|
|
Ast_If_Node *src = (Ast_If_Node *)ast;
|
|
Ast_If_Node *dst = push_struct_copy(pctx->perm, Ast_If_Node, ast);
|
|
dst->parent_scope = parent_scope;
|
|
dst->expr = (Ast_Expr *)ast_copy(src->expr, parent_scope);
|
|
dst->init = (Ast_Binary *)ast_copy(src->init, parent_scope);
|
|
dst->scope = (Ast_Scope *)ast_copy(src->scope, parent_scope);
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_RETURN: {
|
|
Ast_Return *src = (Ast_Return *)ast;
|
|
Ast_Return *dst = push_struct_copy(pctx->perm, Ast_Return, ast);
|
|
|
|
dst->expr.init(pctx->perm, src->expr.len);
|
|
For(src->expr) {
|
|
auto copy = (Ast_Expr *)ast_copy(it, parent_scope);
|
|
dst->expr.add(copy);
|
|
}
|
|
return dst;
|
|
} break;
|
|
|
|
case AST_LAMBDA_EXPR: {
|
|
Ast_Lambda *src = (Ast_Lambda *)ast;
|
|
Ast_Lambda *dst = push_struct_copy(pctx->perm, Ast_Lambda, ast);
|
|
dst->parent_scope = parent_scope;
|
|
|
|
dst->args.init(pctx->perm, src->args.len);
|
|
For(src->args) {
|
|
auto copy = (Ast_Decl *)ast_copy(it, parent_scope);
|
|
dst->args.add(copy);
|
|
}
|
|
|
|
dst->ret.init(pctx->perm, src->ret.len);
|
|
For(src->ret) {
|
|
auto copy = (Ast_Expr *)ast_copy(it, parent_scope);
|
|
dst->ret.add(copy);
|
|
}
|
|
dst->scope = (Ast_Scope *)ast_copy(src->scope, parent_scope);
|
|
return dst;
|
|
} break;
|
|
}
|
|
invalid_return;
|
|
} |