Merge pull request #47 from quark-programming/dev

ephf · web-flow · commit d75652c0972b · 2026-01-14T12:38:44.000-05:00
0.3.1d untested
diff --git a/src/compiler/compiler.c b/src/compiler/compiler.c
@@ -35,6 +35,7 @@ void compile(void* void_node, String* line, Compiler* compiler) {
         [NodeControlStatement] = &comp_ControlStatement,
         [NodeStructType] = &comp_StructType,
         [NodeStructLiteral] = &comp_StructLiteral,
+        [NodeCast] = &comp_Cast,
     };
 
     Node* const node = void_node;
diff --git a/src/compiler/literal/literals.c b/src/compiler/literal/literals.c
@@ -38,3 +38,12 @@ void comp_StructLiteral(void* void_self, String* line, Compiler* compiler) {
     }
     strf(line, " }");
 }
+
+void comp_Cast(void* void_self, String* line, Compiler* compiler) {
+    Cast* const self = void_self;
+
+    strf(line, "(");
+    compile(self->type, line, compiler);
+    strf(line, ") ");
+    compile(self->value, line, compiler);
+}
diff --git a/src/compiler/literal/literals.h b/src/compiler/literal/literals.h
@@ -11,4 +11,6 @@ void comp_External(void* void_self, String* line, Compiler* compiler);
 
 void comp_StructLiteral(void* void_self, String* line, Compiler* compiler);
 
+void comp_Cast(void* void_self, String* line, Compiler* compiler);
+
 #endif
diff --git a/src/compiler/literal/wrapper.c b/src/compiler/literal/wrapper.c
@@ -10,12 +10,16 @@ void comp_Variable(void* void_self, String* line, Compiler* compiler) {
     Node* const const_value = self->Variable.declaration->const_value;
     if(const_value && const_value->flags & fConstExpr) {
         if(!(self->flags & fType)) {
-            strf(line, "(");
+            strf(line, "((");
             compile(self->type, line, compiler);
             strf(line, ") ");
         }
 
         compile(const_value, line, compiler);
+
+        if(!(self->flags & fType)) {
+            strf(line, ")");
+        }
     } else {
         compile_identifier(self->Variable.declaration->identifier, line);
     }
diff --git a/src/compiler/righthand/declaration/identifier.c b/src/compiler/righthand/declaration/identifier.c
@@ -20,6 +20,8 @@ void populate_global_c_keywords() {
     }
 }
 
+DeclarationHashMap global_function_identifiers = 0;
+
 void compile_identifier_base(const String base, String* line) {
     strf(line, "%.*s", PRINT(base));
 
@@ -29,27 +31,53 @@ void compile_identifier_base(const String base, String* line) {
 }
 
 void compile_identifier(const Identifier identifier, String* line) {
+    String result = { 0 };
+
     if(!identifier.is_external) {
         if(identifier.parent_scope && identifier.parent_scope->id == NodeFunctionDeclaration) {
             const Identifier parent_ident = identifier.parent_scope->FunctionDeclaration.identifier;
-            compile_identifier(parent_ident, line);
-            strf(line, "__");
+            compile_identifier(parent_ident, &result);
+            strf(&result, "__");
         }
 
         if(identifier.parent_scope && identifier.parent_scope->id == NodeStructType
            && !(identifier.parent_declaration->id == NodeVariableDeclaration
                 && !(identifier.parent_declaration->type->flags & fType))) {
             const Identifier parent_ident = ((StructType*) (void*) identifier.parent_scope)->parent->identifier;
-            compile_identifier(parent_ident, line);
-            strf(line, "__");
+            compile_identifier(parent_ident, &result);
+            strf(&result, "__");
         }
     }
 
     // TODO: change `PRINT` macro to `FMT` or `STRFMT`
-    compile_identifier_base(identifier.base, line);
+    compile_identifier_base(identifier.base, &result);
 
     if(identifier.parent_declaration->generics.type_arguments_stack.size && !identifier.is_external) {
-        stringify_generics(line, last(identifier.parent_declaration->generics.type_arguments_stack),
+        stringify_generics(&result, last(identifier.parent_declaration->generics.type_arguments_stack),
                            StringifyAlphaNumeric);
     }
+
+    if(identifier.function_declaration_counter) strf(&result, "%u", identifier.function_declaration_counter);
+
+    if(!identifier.function_declaration_counter && identifier.parent_declaration->id == NodeFunctionDeclaration) {
+        const size_t initial_size = result.size;
+        unsigned counter = 0;
+        Declaration** existing_declaration;
+
+        while(((existing_declaration = get(global_function_identifiers, result)))
+              && *existing_declaration != identifier.parent_declaration) {
+            result.size = initial_size;
+            strf(&result, "%u", ++counter);
+        }
+
+        if(counter) {
+            identifier.parent_declaration->identifier.function_declaration_counter = counter;
+        }
+
+        if(!existing_declaration) {
+            put(&global_function_identifiers, result, identifier.parent_declaration);
+        }
+    }
+
+    strf(line, "%.*s", PRINT(result));
 }
diff --git a/src/compiler/righthand/declaration/identifier.h b/src/compiler/righthand/declaration/identifier.h
@@ -3,15 +3,16 @@
 
 #include "../../compiler.h"
 
-
 typedef HashMap(UsableVoid) StringHashSet;
+typedef HashMap(Declaration*) DeclarationHashMap;
 
 extern StringHashSet global_c_keywords;
+extern DeclarationHashMap global_function_identifiers;
 
 void compile_identifier_base(String base, String* line);
 
 void compile_identifier(Identifier identifier, String* line);
 
 void populate_global_c_keywords();
 
-#endif
+#endif
diff --git a/src/main.c b/src/main.c
@@ -9,7 +9,7 @@
 #include "parser/keywords.h"
 #include "compiler/righthand/declaration/identifier.h"
 
-#define QUARK_VERSION "0.3.1b"
+#define QUARK_VERSION "0.3.1d"
 #define QUARK_STABILITY "untested"
 
 typedef Vector(char*) CStringVector;
diff --git a/src/parser/lefthand/lefthand.c b/src/parser/lefthand/lefthand.c
@@ -11,6 +11,19 @@
 #include "../statement/structure.h"
 #include "../literal/number.h"
 #include "../keywords.h"
+#include "parser/type/clash_types.h"
+
+Type* boolean_type() {
+    static Type boolean_type = {
+        .External = {
+            .id = NodeExternal,
+            .type = &boolean_type,
+            .flags = fType | fNumeric,
+            .data = String("bool"),
+        },
+    };
+    return &boolean_type;
+}
 
 Node* lefthand_expression(Parser* parser) {
     Token token = next(parser->tokenizer);
@@ -53,6 +66,7 @@ Node* lefthand_expression(Parser* parser) {
             // TODO: wrap in surround and remove parenthesis in compiler to remove redundant parenthesis
             Node* expr = expression(parser);
             expect(parser->tokenizer, ')');
+
             return new_node((Node) {
                 .Wrapper = {
                     .id = WrapperSurround,
@@ -79,6 +93,18 @@ Node* lefthand_expression(Parser* parser) {
 
         case '[': return parse_array_literal(token.trace, parser);
 
+        case '!': {
+            Node* expr = righthand_expression(lefthand_expression(parser), parser, 2);
+            return new_node((Node) {
+                .Wrapper = {
+                    .id = WrapperSurround,
+                    .type = boolean_type(),
+                    .trace = expr->trace,
+                    .Surround = { expr, String("!") },
+                },
+            });
+        }
+
         default:
             push(parser->tokenizer->messages, REPORT_ERR(token.trace,
                      strf(0, "expected a \33[35mliteral\33[0m, but got '\33[35m%.*s\33[0m'",
diff --git a/src/parser/nodes/lefthand/cast.h b/src/parser/nodes/lefthand/cast.h
@@ -0,0 +1,11 @@
+#ifndef NODE_CAST_H
+#define NODE_CAST_H
+
+#include "../fields.h"
+
+typedef struct Cast {
+    NODE_FIELDS;
+    Node* value;
+} Cast;
+
+#endif
diff --git a/src/parser/nodes/nodes.h b/src/parser/nodes/nodes.h
@@ -20,6 +20,8 @@ typedef enum : uint32_t {
     NodeGenericReference,
     NodeStructType,
 
+    NodeCast,
+
     NodeNumericLiteral,
     NodeStructLiteral,
     NodeMissing,
@@ -54,6 +56,8 @@ enum {
 #include "type/pointer_type.h"
 #include "type/struct_type.h"
 
+#include "lefthand/cast.h"
+
 #include "literal/wrapper.h"
 #include "literal/numeric_literal.h"
 #include "literal/struct_literal.h"
@@ -98,6 +102,7 @@ union Node {
     StructType StructType;
 
     Wrapper Wrapper;
+    Cast Cast;
     NumericLiteral NumericLiteral;
     StructLiteral StructLiteral;
     Missing Missing;
diff --git a/src/parser/nodes/righthand/declaration/identifier.h b/src/parser/nodes/righthand/declaration/identifier.h
@@ -7,6 +7,7 @@ typedef struct Identifier {
     String base;
     Declaration* parent_scope;
     Declaration* parent_declaration;
+    unsigned function_declaration_counter;
     bool is_external : 1;
 } Identifier;
 
diff --git a/src/parser/righthand/declaration/function.c b/src/parser/righthand/declaration/function.c
@@ -64,7 +64,6 @@ Node* parse_function_declaration(Type* return_type, IdentifierInfo info, Parser*
     FunctionDeclaration* declaration = (void*) new_node((Node) {
         .FunctionDeclaration = {
             .id = NodeFunctionDeclaration,
-            .flags = info.identifier.is_external,
             .trace = trace_start,
             .type = (void*) function_type,
             .identifier = info.identifier,
diff --git a/src/parser/righthand/field_access.c b/src/parser/righthand/field_access.c
@@ -10,15 +10,34 @@
 #include "declaration/variable.h"
 
 Node* parse_field_access(Node* lefthand, Parser* parser) {
+    const String operator_token = next(parser->tokenizer).trace.source;
+
+    if(*operator_token.data == '.' && try(parser->tokenizer, '(', NULL)) {
+        Type* cast = (void*) expression(parser);
+
+        if(!(cast->flags & fType)) {
+            push(parser->tokenizer->messages, REPORT_ERR(cast->trace, String("cast is not a type")));
+            cast = cast->type;
+        }
+
+        return new_node((Node) {
+            .Cast = {
+                .id = NodeCast,
+                .type = cast,
+                .trace = stretch(lefthand->trace, expect(parser->tokenizer, ')').trace),
+                .value = lefthand,
+            },
+        });
+    }
+
     Type* type = lefthand->type;
-    if(parser->tokenizer->current.type == TokenRightArrow) {
+    if(*operator_token.data == '-') {
         type = (void*) dereference((void*) type, lefthand->trace, parser->tokenizer->messages);
     }
 
     const OpenedType opened = open_type(type, 0);
     StructType* const struct_type = (void*) opened.type;
 
-    const String operator_token = next(parser->tokenizer).trace.source;
     const Token field_token = expect(parser->tokenizer, TokenIdentifier);
 
     if(struct_type->id != NodeStructType) {

Original file line number	Diff line number	Diff line change
`@@ -38,3 +38,12 @@ void comp_StructLiteral(void* void_self, String* line, Compiler* compiler) {`
`38`	`38`	`}`
`39`	`39`	`strf(line, " }");`
`40`	`40`	`}`
	`41`	`+`
	`42`	`+void comp_Cast(void* void_self, String* line, Compiler* compiler) {`
	`43`	`+ Cast* const self = void_self;`
	`44`	`+`
	`45`	`+ strf(line, "(");`
	`46`	`+ compile(self->type, line, compiler);`
	`47`	`+ strf(line, ") ");`
	`48`	`+ compile(self->value, line, compiler);`
	`49`	`+}`