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

Cleanup

Browse Source
This commit is contained in:
Krzosa Karol
2022-06-04 09:12:27 +02:00
parent 4910671ab9
commit c3f235bd44
5 changed files with 95 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ccodegen.cpp
View File

@@ -111,7 +111,7 @@ gen_expr(Ast_Expr *ast){
else{
gen("(");
gen_expr(node->left);
gen("%s", token_kind_string(node->op).str);
gen("%s", name(node->op));
gen_expr(node->right);
gen(")");
}

2
main.cpp
View File

@@ -32,6 +32,7 @@ For now I don't thing it should be overloadable.
-------------------------------------------------------------------------------
@todo
[ ] - Character literal
[ ] - Converting from U64 token to S64 Atom introduces unnanounced error (negates) - probably need big int
[ ] - Passing down program to compile through command line
[ ] - More for loop variations
@@ -42,6 +43,7 @@ For now I don't thing it should be overloadable.
[ ] - Array of inferred size
[ ] - Add single line lambda expressions
[ ] - Ternary operator
[ ] - Remodel compound from call to {}
[ ] - Field access rewrite
[ ] - Constants embeded in structs should be able to refer to other constants in that namespace without prefix

140
new_lex.cpp
View File

@@ -676,76 +676,76 @@ lex_stream(Allocator *token_string_arena, Allocator *map_allocator, String istre
//-----------------------------------------------------------------------------
// Token metadata
//-----------------------------------------------------------------------------
function String
token_kind_string(Token_Kind kind){
function const char *
name(Token_Kind kind){
switch(kind){
case TK_End: return "End of stream"_s;
case TK_Mul: return "*"_s;
case TK_Div: return "/"_s;
case TK_Add: return "+"_s;
case TK_Sub: return "-"_s;
case TK_Mod: return "%"_s;
case TK_BitAnd: return "&"_s;
case TK_BitOr: return "|"_s;
case TK_BitXor: return "^"_s;
case TK_Neg: return "~"_s;
case TK_Not: return "!"_s;
case TK_OpenParen: return "("_s;
case TK_CloseParen: return ")"_s;
case TK_OpenBrace: return "{"_s;
case TK_CloseBrace: return "}"_s;
case TK_OpenBracket: return "["_s;
case TK_CloseBracket: return "]"_s;
case TK_ColonAssign: return ":="_s;
case TK_Comma: return ","_s;
case TK_Pound: return "#"_s;
case TK_Question: return "?"_s;
case TK_ThreeDots: return "..."_s;
case TK_Semicolon: return ";"_s;
case TK_Dot: return "."_s;
case TK_LesserThen: return "<"_s;
case TK_GreaterThen: return ">"_s;
case TK_Colon: return ":"_s;
case TK_Assign: return "="_s;
case TK_DivAssign: return "/="_s;
case TK_MulAssign: return "*="_s;
case TK_ModAssign: return "%="_s;
case TK_SubAssign: return "-="_s;
case TK_AddAssign: return "+="_s;
case TK_AndAssign: return "&="_s;
case TK_OrAssign: return "|="_s;
case TK_XorAssign: return "^="_s;
case TK_LeftShiftAssign: return "<<="_s;
case TK_RightShiftAssign: return ">>="_s;
case TK_DoubleColon: return "::"_s;
case TK_At: return "@"_s;
case TK_Decrement: return "--"_s;
case TK_Increment: return "++"_s;
case TK_PostDecrement: return "--"_s;
case TK_PostIncrement: return "++"_s;
case TK_LesserThenOrEqual: return "<="_s;
case TK_GreaterThenOrEqual: return ">="_s;
case TK_Equals: return "=="_s;
case TK_And: return "&&"_s;
case TK_Or: return "||"_s;
case TK_NotEquals: return "!="_s;
case TK_LeftShift: return "<<"_s;
case TK_RightShift: return ">>"_s;
case TK_Arrow: return "->"_s;
case TK_NewLine: return "New_Line"_s;
case TK_ExprSizeof: return "sizeof"_s;
case TK_DocComment: return "Doc_Comment"_s;
case TK_Comment: return "Comment"_s;
case TK_Identifier: return "Identifier"_s;
case TK_StringLit: return "String_Lit"_s;
case TK_Character: return "Character"_s;
case TK_Error: return "Error"_s;
case TK_Float: return "Float"_s;
case TK_Integer: return "int"_s;
case TK_Keyword: return "Keyword"_s;
case CLOSE_SCOPE: return "Close_Scope"_s;
case OPEN_SCOPE: return "Open_Scope"_s;
case SAME_SCOPE: return "Same_Scope"_s;
default: invalid_codepath; return "<Undefined>"_s;
case TK_End: return "End of stream";
case TK_Mul: return "*";
case TK_Div: return "/";
case TK_Add: return "+";
case TK_Sub: return "-";
case TK_Mod: return "%";
case TK_BitAnd: return "&";
case TK_BitOr: return "|";
case TK_BitXor: return "^";
case TK_Neg: return "~";
case TK_Not: return "!";
case TK_OpenParen: return "(";
case TK_CloseParen: return ")";
case TK_OpenBrace: return "{";
case TK_CloseBrace: return "}";
case TK_OpenBracket: return "[";
case TK_CloseBracket: return "]";
case TK_ColonAssign: return ":=";
case TK_Comma: return ",";
case TK_Pound: return "#";
case TK_Question: return "?";
case TK_ThreeDots: return "...";
case TK_Semicolon: return ";";
case TK_Dot: return ".";
case TK_LesserThen: return "<";
case TK_GreaterThen: return ">";
case TK_Colon: return ":";
case TK_Assign: return "=";
case TK_DivAssign: return "/=";
case TK_MulAssign: return "*=";
case TK_ModAssign: return "%=";
case TK_SubAssign: return "-=";
case TK_AddAssign: return "+=";
case TK_AndAssign: return "&=";
case TK_OrAssign: return "|=";
case TK_XorAssign: return "^=";
case TK_LeftShiftAssign: return "<<=";
case TK_RightShiftAssign: return ">>=";
case TK_DoubleColon: return "::";
case TK_At: return "@";
case TK_Decrement: return "--";
case TK_Increment: return "++";
case TK_PostDecrement: return "--";
case TK_PostIncrement: return "++";
case TK_LesserThenOrEqual: return "<=";
case TK_GreaterThenOrEqual: return ">=";
case TK_Equals: return "==";
case TK_And: return "&&";
case TK_Or: return "||";
case TK_NotEquals: return "!=";
case TK_LeftShift: return "<<";
case TK_RightShift: return ">>";
case TK_Arrow: return "->";
case TK_NewLine: return "New_Line";
case TK_ExprSizeof: return "sizeof";
case TK_DocComment: return "Doc_Comment";
case TK_Comment: return "Comment";
case TK_Identifier: return "Identifier";
case TK_StringLit: return "String_Lit";
case TK_Character: return "Character";
case TK_Error: return "Error";
case TK_Float: return "Float";
case TK_Integer: return "int";
case TK_Keyword: return "Keyword";
case CLOSE_SCOPE: return "Close_Scope";
case OPEN_SCOPE: return "Open_Scope";
case SAME_SCOPE: return "Same_Scope";
default: invalid_codepath; return "<Undefined>";
}
}

22
new_parse.cpp
View File

@@ -106,7 +106,7 @@ function Token *
token_expect(Token_Kind kind){
Token *token = token_get();
if(token->kind == kind) return token_next();
parsing_error(token, "Expected token of kind: [%s], got instead token of kind: [%s]", token_kind_string(kind).str, token_kind_string(token->kind).str);
parsing_error(token, "Expected token of kind: [%s], got instead token of kind: [%s]", name(kind), name(token->kind));
return 0;
}
@@ -257,7 +257,7 @@ parse_block(){
}
if(result) stmts.add(result);
else parsing_error(token, "Unexpected token [%s] while parsing statement", token_kind_string(token->kind).str);
else parsing_error(token, "Unexpected token [%s] while parsing statement", name(token->kind));
}
} while(token_match(SAME_SCOPE));
@@ -409,7 +409,7 @@ parse_expr(S64 min_bp){
token_expect(TK_CloseParen);
}
}break;
default: parsing_error(token, "Unexpected token of kind: [%s] in expression", token_kind_string(token->kind).str); return 0;
default: parsing_error(token, "Unexpected token of kind: [%s] in expression", name(token->kind)); return 0;
}
for(;;){
@@ -525,38 +525,38 @@ parse_named(B32 is_global){
}
}
Token *name = token_get();
Token *tname = token_get();
if(token_match(TK_Identifier, TK_DoubleColon)){
// @note parse struct binding
Token *struct_pos = token_get();
if(token_match_keyword(keyword_struct)){
Ast_Struct *struct_val = parse_struct(struct_pos);
result = ast_const(name, name->intern_val, (Ast_Expr *)struct_val);
result = ast_const(tname, tname->intern_val, (Ast_Expr *)struct_val);
}
else if(token_match_keyword(keyword_enum)){
Ast_Enum *enum_val = parse_enum(struct_pos);
result = ast_const(name, name->intern_val, (Ast_Expr *)enum_val);
result = ast_const(tname, tname->intern_val, (Ast_Expr *)enum_val);
}
// @note parse constant expression
else{
Ast_Expr *expr = parse_expr();
result = ast_const(name, name->intern_val, expr);
result = ast_const(tname, tname->intern_val, expr);
}
}
else if(token_match(TK_Identifier, TK_Colon)){
Ast_Expr *typespec = typespec = parse_expr();
Ast_Expr *expr = parse_assign_expr();
result = ast_var(name, typespec, name->intern_val, expr);
result = ast_var(tname, typespec, tname->intern_val, expr);
}
else if(token_match(TK_Identifier, TK_ColonAssign)){
Ast_Expr *expr = parse_expr();
result = ast_var(name, 0, name->intern_val, expr);
result = ast_var(tname, 0, tname->intern_val, expr);
}
else if(is_global && name->kind != TK_End){
parsing_error(name, "Unexpected token: [%s] when parsing a declaration", token_kind_string(name->kind).str);
else if(is_global && tname->kind != TK_End){
parsing_error(tname, "Unexpected token: [%s] when parsing a declaration", name(tname->kind));
}
return result;

22
typecheck.cpp
View File

@@ -128,12 +128,12 @@ value_get_float(Value value){
#include <math.h> // fmod
function Value
eval_binary(Token *pos, Token_Kind op, Value a, Value b){
if(!(is_numeric(a.type) && is_numeric(b.type))) parsing_error(pos, "Constant application of binary %s on values of type %s and %s is not allowed", token_kind_string(op).str, docname(a.type), docname(a.type));
if(!(is_numeric(a.type) && is_numeric(b.type))) parsing_error(pos, "Constant application of binary %s on values of type %s and %s is not allowed", name(op), docname(a.type), docname(a.type));
// @warning: this bool path returns early, always should return untyped bool
if(is_bool(a.type) || is_bool(b.type)){
if(!is_bool(a.type)) parsing_error(pos, "Type mismatch in binary operation %s - left: %s right: %s", token_kind_string(op).str, docname(a.type), docname(b.type));
if(!is_bool(b.type)) parsing_error(pos, "Type mismatch in binary operation %s - left: %s right: %s", token_kind_string(op).str, docname(a.type), docname(b.type));
if(!is_bool(a.type)) parsing_error(pos, "Type mismatch in binary operation %s - left: %s right: %s", name(op), docname(a.type), docname(b.type));
if(!is_bool(b.type)) parsing_error(pos, "Type mismatch in binary operation %s - left: %s right: %s", name(op), docname(a.type), docname(b.type));
Value result;
result.type = untyped_bool;
@@ -163,7 +163,7 @@ eval_binary(Token *pos, Token_Kind op, Value a, Value b){
}
if(is_typed(a.type) && is_typed(b.type)){
if(a.type != b.type) parsing_error(pos, "Type mismatch in binary operation %s - left: %s right: %s", token_kind_string(op).str, docname(a.type), docname(b.type));
if(a.type != b.type) parsing_error(pos, "Type mismatch in binary operation %s - left: %s right: %s", name(op), docname(a.type), docname(b.type));
else final_type = a.type;
}
@@ -249,18 +249,18 @@ eval_binary(Token *pos, Token_Kind op, Value a, Value b){
// @WARNING: When introducing big ints & | ^ will be problematic
case TK_BitAnd: {
left_int = left_int & right_int;
if(before_conversion.type == untyped_float) parsing_error(pos, "%s cant be performed on [Untyped_Float]", token_kind_string(op).str);
if(before_conversion.type == untyped_float) parsing_error(pos, "%s cant be performed on [Untyped_Float]", name(op));
} break;
case TK_BitOr: {
left_int = left_int | right_int;
if(before_conversion.type == untyped_float) parsing_error(pos, "%s cant be performed on [Untyped_Float]", token_kind_string(op).str);
if(before_conversion.type == untyped_float) parsing_error(pos, "%s cant be performed on [Untyped_Float]", name(op));
} break;
case TK_BitXor: {
left_int = left_int ^ right_int;
if(before_conversion.type == untyped_float) parsing_error(pos, "%s cant be performed on [Untyped_Float]", token_kind_string(op).str);
if(before_conversion.type == untyped_float) parsing_error(pos, "%s cant be performed on [Untyped_Float]", name(op));
} break;
default: parsing_error(pos, "Binary operation %s is not allowed on types: left: %s right: %s", token_kind_string(op).str, docname(a.type), docname(b.type));
default: parsing_error(pos, "Binary operation %s is not allowed on types: left: %s right: %s", name(op), docname(a.type), docname(b.type));
}
if(before_conversion.type == untyped_float){
@@ -288,7 +288,7 @@ try_untyping(Operand *op){
function Value
eval_unary(Token *pos, Token_Kind op, Value a){
if(!is_numeric(a.type)) parsing_error(pos, "Constant application of binary %s on values of type %s is not allowed", token_kind_string(op).str, docname(a.type));
if(!is_numeric(a.type)) parsing_error(pos, "Constant application of binary %s on values of type %s is not allowed", name(op), docname(a.type));
S64 left_int = value_get_int(a);
F64 left_float = value_get_float(a);
@@ -710,7 +710,7 @@ resolve_expr(Ast_Expr *ast, Ast_Resolved_Type *expected_type, Sym *lambda_to_res
case TK_Dereference:{return operand_lvalue(type_pointer(value.type));}break;
case TK_Neg:case TK_Not:case TK_Add:case TK_Sub:{
Operand op = resolve_expr(node->expr);
if(!is_numeric(op.type)) parsing_error(node->pos, "Unary [%s] cant be applied to value of type %s", token_kind_string(node->op).str, docname(op.type));
if(!is_numeric(op.type)) parsing_error(node->pos, "Unary [%s] cant be applied to value of type %s", name(node->op), docname(op.type));
if(op.is_const){
Value value = eval_unary(node->pos, node->op, op.value);
rewrite_into_const(node, Ast_Unary, value);
@@ -858,7 +858,7 @@ resolve_expr(Ast_Expr *ast, Ast_Resolved_Type *expected_type, Sym *lambda_to_res
if(left.type != right.type){
parsing_error(node->pos, "Type mismatch in binary operation %s - left: %s right: %s", token_kind_string(node->op).str, docname(left.type), docname(right.type));
parsing_error(node->pos, "Type mismatch in binary operation %s - left: %s right: %s", name(node->op), docname(left.type), docname(right.type));
}
else{
result = operand_rvalue(left.type);