krzosa/corelang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

For from pointer to reference

Browse Source
This commit is contained in:
Krzosa Karol
2022-05-30 13:34:04 +02:00
parent 3a97e739a8
commit 55fd4ca40c
6 changed files with 86 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
ccodegen.cpp
View File

@@ -59,8 +59,8 @@ gen_simple_decl(Ast_Resolved_Type *ast, Intern_String name){
gen_simple_decl_prefix(ast->func.ret);
gen("(*%s)(", name.str);
For(ast->func.args){
gen_simple_decl_prefix(it[0]);
if(it != ast->func.args.end() - 1) gen(", ");
gen_simple_decl_prefix(it);
if(&it != ast->func.args.end() - 1) gen(", ");
}
gen(")");
}
@@ -143,7 +143,7 @@ gen_expr(Ast_Expr *ast){
gen("{");
For(node->exprs){
auto comp = it[0];
auto comp = it;
if(comp->name){
gen("[");
gen_expr(comp->name);
@@ -157,7 +157,7 @@ gen_expr(Ast_Expr *ast){
assert(comp->item);
gen_expr(comp->item);
if(!node->exprs.is_last(it)) gen(", ");
if(!node->exprs.is_last(&it)) gen(", ");
}
gen("}");
}
@@ -165,8 +165,8 @@ gen_expr(Ast_Expr *ast){
gen_expr(node->name);
gen("(");
For(node->exprs){
gen_expr(it[0]->item);
if(!node->exprs.is_last(it)) gen(", ");
gen_expr(it->item);
if(!node->exprs.is_last(&it)) gen(", ");
}
gen(")");
}
@@ -186,7 +186,7 @@ gen_block(Ast_Block *block){
global_indent++;
For(block->stmts) {
genln("");
gen_ast(it[0]);
gen_ast(it);
}
global_indent--;
genln("}");
@@ -199,7 +199,7 @@ gen_ast(Ast *ast){
CASE(PACKAGE, Package){
For(node->ordered) {
genln("");
gen_ast(*it);
gen_ast(it);
}
BREAK();
}
@@ -238,21 +238,21 @@ gen_ast(Ast *ast){
CASE(IF, If){
For(node->ifs){
if(it[0]->init) gen_ast(it[0]->init);
if(node->ifs.is_first(it)){
if(it->init) gen_ast(it->init);
if(node->ifs.is_first(&it)){
genln("if(");
gen_expr(it[0]->expr);
gen_expr(it->expr);
gen(")");
gen_block(it[0]->block);
gen_block(it->block);
}
else{
genln("else");
if(it[0]->expr){
if(it->expr){
gen(" if(");
gen_expr(it[0]->expr);
gen_expr(it->expr);
gen(")");
}
gen_block(it[0]->block);
gen_block(it->block);
}
}
BREAK();
@@ -269,10 +269,10 @@ gen_ast(Ast *ast){
gen_simple_decl(ret, node->name);
gen("(");
For(lambda->args){
assert(it[0]->kind == AST_LAMBDA_ARG);
Ast_Resolved_Type *type = resolved_type_get(it[0]->typespec);
gen_simple_decl(type, it[0]->name);
if(it != (lambda->args.end() - 1)) gen(", ");
assert(it->kind == AST_LAMBDA_ARG);
Ast_Resolved_Type *type = resolved_type_get(it->typespec);
gen_simple_decl(type, it->name);
if(&it != (lambda->args.end() - 1)) gen(", ");
}
gen(")");
@@ -302,7 +302,7 @@ gen_ast(Ast *ast){
global_indent++;
For(agg->members){
genln("");
gen_ast(it[0]);
gen_ast(it);
}
global_indent--;
genln("};");

2
main.cpp
View File

@@ -3,7 +3,7 @@
#include "new_lex.cpp"
#include "new_ast.cpp"
#include "new_parse.cpp"
#include "new_resolve.cpp"
#include "typechecking.cpp"
#include "ccodegen.cpp"
// 2022.05.28 - On lambda expressions

16
new_ast.cpp
View File

@@ -291,7 +291,7 @@ ast_call(Token *pos, Ast_Expr *name, Array<Ast_Call_Item *> exprs){
result->name = name;
result->exprs = exprs.tight_copy(pctx->perm);
if(result->name) result->name->parent = result;
For(result->exprs) it[0]->parent = result;
For(result->exprs) it->parent = result;
return result;
}
@@ -350,7 +350,7 @@ ast_lambda(Token *pos, Array<Ast_Lambda_Arg *> params, Ast_Expr *ret, Ast_Block
if(result->block) result->block->parent = result;
result->ret->parent = result;
For(result->args) it[0]->parent = result;
For(result->args) it->parent = result;
return result;
}
@@ -370,7 +370,7 @@ function Ast_Block *
ast_block(Token *pos, Array<Ast *> stmts){
AST_NEW(Block, BLOCK, pos, AST_STMT);
result->stmts = stmts.tight_copy(pctx->perm);
For(result->stmts) it[0]->parent = result;
For(result->stmts) it->parent = result;
return result;
}
@@ -378,7 +378,7 @@ function Ast_If *
ast_if(Token *pos, Array<Ast_If_Node *> ifs){
AST_NEW(If, IF, pos, AST_STMT);
result->ifs = ifs.tight_copy(pctx->perm);
For(result->ifs) it[0]->parent = result;
For(result->ifs) it->parent = result;
return result;
}
@@ -430,9 +430,9 @@ ast_struct(Token *pos, Array<Ast_Named *> members){
AST_NEW(Struct, STRUCT, pos, AST_AGGREGATE);
result->members = members.tight_copy(pctx->perm);
For(result->members) {
assert(is_flag_set(it[0]->flags, AST_BINDING));
assert(it[0]->kind == AST_VAR || it[0]->kind == AST_CONST);
it[0]->parent = result;
assert(is_flag_set(it->flags, AST_BINDING));
assert(it->kind == AST_VAR || it->kind == AST_CONST);
it->parent = result;
}
return result;
}
@@ -468,7 +468,7 @@ ast_package(Token *pos, String name, Array<Ast_Named *> decls){
result->decls = decls.tight_copy(pctx->perm);
result->ordered = array_make<Ast_Named *>(pctx->perm, decls.len);
result->name = intern_string(&pctx->interns, name);
For(result->decls) it[0]->parent = result;
For(result->decls) it->parent = result;
return result;
}

12
new_lex.cpp
View File

@@ -180,8 +180,8 @@ function void
lex_set_keywords(Lexer *lexer, Array<String> keywords){
Intern_String keyword = {};
For(keywords){
keyword = intern_string(&lexer->interns, *it);
if(it == keywords.begin())
keyword = intern_string(&lexer->interns, it);
if(&it == keywords.begin())
lexer->interns.first_keyword = keyword.str;
}
lexer->interns.last_keyword = keyword.str;
@@ -674,10 +674,10 @@ lex_test(){
int ui = 0;
S32 i = 0;
For(arr){
assert(it->kind == kind[i]);
assert(string_compare(it->string, strs[i]));
if(it->kind == TK_Integer){
assert(it->int_val == vals[ui++]);
assert(it.kind == kind[i]);
assert(string_compare(it.string, strs[i]));
if(it.kind == TK_Integer){
assert(it.int_val == vals[ui++]);
}
i++;
}

8
new_type.cpp
View File

@@ -132,7 +132,7 @@ type_array(Ast_Resolved_Type *base, SizeU size){
function Ast_Resolved_Type *
type_lambda(Ast *ast, Ast_Resolved_Type *ret, Array<Ast_Resolved_Type *> args){
U64 hash = hash_ptr(ret);
For(args) hash = hash_mix(hash, hash_ptr(*it));
For(args) hash = hash_mix(hash, hash_ptr(it));
Ast_Resolved_Type *result = (Ast_Resolved_Type *)map_get(&pctx->type_map, hash);
if(result){
@@ -175,9 +175,9 @@ type_complete(Ast_Resolved_Type *type){
Scratch scratch;
Array<Ast_Resolved_Member> members = {scratch};
For(node->members){
Operand op = resolve_binding(it[0]);
Intern_String name = ast_get_name(it[0]);
sym_new_resolved(SYM_VAR, name, op.type, {}, it[0]);
Operand op = resolve_binding(it);
Intern_String name = ast_get_name(it);
sym_new_resolved(SYM_VAR, name, op.type, {}, it);
members.add({op.type, name});
}
type->agg.members = members.tight_copy(pctx->perm);

88
new_resolve.cpp → typechecking.cpp
View File

@@ -42,6 +42,12 @@ enum{
AST_CAN_BE_NULL = 1
};
struct Typecheck_Ctx{
Ast_Resolved_Type *required_type;
Sym *const_sym;
B32 expr_can_be_null;
};
function Sym *resolve_name(Token *pos, Intern_String name);
function Operand resolve_expr(Ast_Expr *ast, Ast_Resolved_Type *compound_required_type = 0, Sym *const_sym = 0);
function Operand resolve_binding(Ast *ast, Sym *sym = 0);
@@ -225,11 +231,11 @@ resolve_stmt(Ast *ast, Ast_Resolved_Type *ret){
CASE(IF, If){
For(node->ifs){
if(it[0]->init) resolve_stmt(it[0]->init, ret);
if(it[0]->expr) resolve_expr(it[0]->expr);
if(it->init) resolve_stmt(it->init, ret);
if(it->expr) resolve_expr(it->expr);
S64 scope_index = scope_open();
For_It(it[0]->block->stmts, jt){
resolve_stmt(jt[0], ret);
For_It(it->block->stmts, jt){
resolve_stmt(jt, ret);
}
scope_close(scope_index);
}
@@ -302,10 +308,10 @@ resolve_expr(Ast_Expr *ast, Ast_Resolved_Type *expected_type, Sym *const_sym){
Ast_Resolved_Type *ret_type = resolve_typespec(node->ret);
Array<Ast_Resolved_Type *> args = {scratch};
For(node->args){
Operand type = resolve_expr(it[0]->typespec);
if(type.type != type_type) parsing_error(it[0]->pos, "Required expression of kind [type]");
Operand default_value = resolve_expr(it[0]->default_value, type.type_val);
if(default_value.type && default_value.type != type.type_val) parsing_error(it[0]->pos, "Default value type and type declaration differ");
Operand type = resolve_expr(it->typespec);
if(type.type != type_type) parsing_error(it->pos, "Required expression of kind [type]");
Operand default_value = resolve_expr(it->default_value, type.type_val);
if(default_value.type && default_value.type != type.type_val) parsing_error(it->pos, "Default value type and type declaration differ");
args.add(type.type_val);
}
lambda_type = type_lambda(node, ret_type, args);
@@ -327,14 +333,14 @@ resolve_expr(Ast_Expr *ast, Ast_Resolved_Type *expected_type, Sym *const_sym){
if(node->block){
S64 scope_index = scope_open();
For(node->args){
S64 i = node->args.get_index(it);
S64 i = node->args.get_index(&it);
Ast_Resolved_Type *type = args[i];
Sym *arg_sym = sym_new_resolved(SYM_VAR, it[0]->name, type, {}, it[0]);
Sym *arg_sym = sym_new_resolved(SYM_VAR, it->name, type, {}, it);
sym_insert(arg_sym);
}
For(node->block->stmts){
resolve_stmt(it[0], ret_type);
resolve_stmt(it, ret_type);
}
scope_close(scope_index);
result.type = lambda_type;
@@ -368,7 +374,7 @@ resolve_expr(Ast_Expr *ast, Ast_Resolved_Type *expected_type, Sym *const_sym){
Ast_Resolved_Type *item_type = type->arr.base;
For(node->exprs){
Ast_Call_Item *i = (Ast_Call_Item *)it[0];
Ast_Call_Item *i = (Ast_Call_Item *)it;
assert(i->kind == AST_CALL_ITEM);
if(i->name) parsing_error(i->pos, "Invalid indexing kind in a compound expression of type %s", type_names[type->kind]);
if(i->index){
@@ -386,18 +392,18 @@ resolve_expr(Ast_Expr *ast, Ast_Resolved_Type *expected_type, Sym *const_sym){
S64 default_iter = 0;
For_It(node->exprs, expr){
if(expr[0]->index) parsing_error(expr[0]->index->pos, "Function call indexing is illegal");
Ast_Atom *name = expr[0]->name;
S64 expr_index = node->exprs.get_index(expr);
if(expr->index) parsing_error(expr->index->pos, "Function call indexing is illegal");
Ast_Atom *name = expr->name;
S64 expr_index = node->exprs.get_index(&expr);
Ast_Named *found = 0;
Ast_Resolved_Member *found_type = 0;
if(name){
assert(name->kind == AST_IDENT);
For_It(agg->members, member){
if(member[0]->name.str == name->intern_val.str){
found = member[0];
found_type = &type->agg.members[agg->members.get_index(member)];
if(member->name.str == name->intern_val.str){
found = member;
found_type = &type->agg.members[agg->members.get_index(&member)];
break;
}
}
@@ -406,21 +412,21 @@ resolve_expr(Ast_Expr *ast, Ast_Resolved_Type *expected_type, Sym *const_sym){
S64 i = default_iter++;
found = agg->members[i];
found_type = &type->agg.members[i];
if(i >= agg->members.len) parsing_error(expr[0]->pos, "Too many arguments in compound constructor");
if(i >= agg->members.len) parsing_error(expr->pos, "Too many arguments in compound constructor");
}
else parsing_error(expr[0]->pos, "Positional argument after named or indexed argument");
else parsing_error(expr->pos, "Positional argument after named or indexed argument");
if(!found) parsing_error(expr[0]->pos, "Invalid argument in compound constructor");
if(!found) parsing_error(expr->pos, "Invalid argument in compound constructor");
if(is_flag_set(found->flags, AST_ITEM_INCLUDED)) parsing_error(found->pos, "Item included multiple times in compound constructor");
found->flags = set_flag(found->flags, AST_ITEM_INCLUDED);
Operand op = resolve_expr(expr[0]->item, found_type->type);
if(found_type->type != op.type) parsing_error(expr[0]->pos, "Invalid type of compound constructor item");
Operand op = resolve_expr(expr->item, found_type->type);
if(found_type->type != op.type) parsing_error(expr->pos, "Invalid type of compound constructor item");
}
// @note: cleanup, required?
For(agg->members){
it[0]->flags = unset_flag(it[0]->flags, AST_ITEM_INCLUDED);
it->flags = unset_flag(it->flags, AST_ITEM_INCLUDED);
}
}
else if(type->kind == TYPE_LAMBDA){
@@ -430,26 +436,26 @@ resolve_expr(Ast_Expr *ast, Ast_Resolved_Type *expected_type, Sym *const_sym){
S64 default_iter = 0;
auto lambda = (Ast_Lambda *)type->ast;
For(lambda->args){
S64 i = lambda->args.get_index(it);
S64 i = lambda->args.get_index(&it);
Ast_Resolved_Type *resolved = type->func.args[i];
Ast_Lambda_Arg *arg = it[0];
Ast_Lambda_Arg *arg = it;
// @note: match any in list of call items, if none matched then we have a problem
// there are three kinds of possible matches: indexed, named, default
Ast_Call_Item *item = 0;
For_It(node->exprs, expr){
if(expr[0]->index) parsing_error(expr[0]->index->pos, "Function call indexing is illegal");
Ast_Atom *name = expr[0]->name;
if(expr->index) parsing_error(expr->index->pos, "Function call indexing is illegal");
Ast_Atom *name = expr->name;
if(name){
assert(name->kind == AST_IDENT);
if(name->intern_val.str == arg->name.str) item = expr[0];
if(name->intern_val.str == arg->name.str) item = expr;
}
else if(node->exprs.get_index(expr) == default_iter){
else if(node->exprs.get_index(&expr) == default_iter){
default_iter++;
item = expr[0];
item = expr;
}
else if(node->exprs.get_index(expr) > default_iter) parsing_error(expr[0]->pos, "Positional argument after named argument");
else if(node->exprs.get_index(&expr) > default_iter) parsing_error(expr->pos, "Positional argument after named argument");
if(item) break;
}
@@ -472,8 +478,8 @@ resolve_expr(Ast_Expr *ast, Ast_Resolved_Type *expected_type, Sym *const_sym){
// @note: check if all arguments are included and cleanup
For(node->exprs){
if(!is_flag_set(it[0]->flags, AST_ITEM_INCLUDED)) parsing_error(it[0]->pos, "Invalid argument to function call");
else it[0]->flags = unset_flag(it[0]->flags, AST_ITEM_INCLUDED);
if(!is_flag_set(it->flags, AST_ITEM_INCLUDED)) parsing_error(it->pos, "Invalid argument to function call");
else it->flags = unset_flag(it->flags, AST_ITEM_INCLUDED);
}
node->exprs = items.tight_copy(pctx->perm);
@@ -567,15 +573,15 @@ resolve_expr(Ast_Expr *ast, Ast_Resolved_Type *expected_type, Sym *const_sym){
Scratch scratch;
Array<Ast_Resolved_Member> members = {scratch};
For(node->members){
Operand op = resolve_binding(it[0]);
Operand op = resolve_binding(it);
Intern_String name = {};
if(is_flag_set(it[0]->flags, AST_BINDING)){
Ast_Named *named = (Ast_Named *)it[0];
if(is_flag_set(it->flags, AST_BINDING)){
Ast_Named *named = (Ast_Named *)it;
name = named->name;
}
sym_new_resolved(SYM_VAR, name, op.type, {}, it[0]);
sym_new_resolved(SYM_VAR, name, op.type, {}, it);
members.add({op.type, name});
}
Ast_Resolved_Type *resolved = type_struct(node, members);
@@ -647,9 +653,9 @@ resolve_name(Token *pos, Intern_String name){
function void
resolve_package(Ast_Package *package){
For(package->decls){
resolve_name(it[0]->pos, it[0]->name);
if(ast_is_struct(it[0])){
type_complete(const_get_struct(it[0])->type);
resolve_name(it->pos, it->name);
if(ast_is_struct(it)){
type_complete(const_get_struct(it)->type);
}
}
}