diff --git a/ccodegen.cpp b/ccodegen.cpp index 9a8203d..9ed26d8 100644 --- a/ccodegen.cpp +++ b/ccodegen.cpp @@ -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(")"); } diff --git a/main.cpp b/main.cpp index 4a6f761..0dab845 100644 --- a/main.cpp +++ b/main.cpp @@ -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 diff --git a/new_lex.cpp b/new_lex.cpp index f8f9d6d..df0bff1 100644 --- a/new_lex.cpp +++ b/new_lex.cpp @@ -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 ""_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 ""; } } diff --git a/new_parse.cpp b/new_parse.cpp index 769afcb..3bd01a8 100644 --- a/new_parse.cpp +++ b/new_parse.cpp @@ -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; diff --git a/typecheck.cpp b/typecheck.cpp index c6c9d40..93b0bb1 100644 --- a/typecheck.cpp +++ b/typecheck.cpp @@ -128,12 +128,12 @@ value_get_float(Value value){ #include // 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);