wip

src/compiler.bbb

@@ -1487,6 +1487,8 @@ ValueId = enum
     function,
     constant_integer,
     global,
+    unary,
+    binary,
 }
 
 ValueConstantInteger = struct
@@ -1510,10 +1512,71 @@ ValueFunction = struct
     attributes: FunctionAttributes,
 }
 
+UnaryId = enum
+{
+    minus,
+    plus,
+    ampersand,
+    exclamation,
+    tilde,
+    enum_name,
+    extend,
+    truncate,
+    pointer_cast,
+    int_from_enum,
+    int_from_pointer,
+    va_end,
+    bitwise_not,
+    dereference,
+    pointer_from_int,
+    enum_from_int,
+}
+
+ValueUnary = struct
+{
+    value: &Value,
+    id: UnaryId,
+}
+
+BinaryId = enum
+{
+    add,
+    sub,
+    mul,
+    div,
+    rem,
+    bitwise_and,
+    bitwise_or,
+    bitwise_xor,
+    shift_left,
+    shift_right,
+    compare_equal,
+    compare_not_equal,
+    compare_greater,
+    compare_less,
+    compare_greater_equal,
+    compare_less_equal,
+    logical_and,
+    logical_or,
+    logical_and_shortcircuit,
+    logical_or_shortcircuit,
+    max,
+    min,
+}
+
+ValueBinary = struct
+{
+    left: &Value,
+    right: &Value,
+    id: BinaryId,
+}
+
 ValueContent = union
 {
     constant_integer: ValueConstantInteger,
     function: ValueFunction,
+    unary: ValueUnary,
+    binary: ValueBinary,
 }
 
 ValueKind = enum
@@ -2819,7 +2882,7 @@ tokenize = fn (module: &Module) Token
 
     >start_character = module.content[start_index];
     
-    >token: Token = undefined;
+    >token: Token = zero;
 
     switch (start_character)
     {
@@ -2940,7 +3003,45 @@ tokenize = fn (module: &Module) Token
         '!',
         =>
         {
-            #trap();
+            >next_ch = module.content[start_index + 1];
+            >id: TokenId = undefined;
+
+            if (next_ch == '=')
+            {
+                switch (start_character)
+                {
+                    '+' => { id = .assign_plus; },
+                    '-' => { id = .assign_dash; },
+                    '*' => { id = .assign_asterisk; },
+                    '/' => { id = .assign_forward_slash; },
+                    '%' => { id = .assign_percentage; },
+                    '&' => { id = .assign_ampersand; },
+                    '|' => { id = .assign_bar; },
+                    '^' => { id = .assign_caret; },
+                    '!' => { id = .compare_not_equal; },
+                    else => { unreachable; }
+                }
+            }
+            else
+            {
+                switch (start_character)
+                {
+                    '+' => { id = .plus; },
+                    '-' => { id = .dash; },
+                    '*' => { id = .asterisk; },
+                    '/' => { id = .forward_slash; },
+                    '%' => { id = .percentage; },
+                    '&' => { id = .ampersand; },
+                    '|' => { id = .bar; },
+                    '^' => { id = .caret; },
+                    '!' => { id = .exclamation; },
+                    else => { unreachable; }
+                }
+            }
+
+            token.id = id;
+
+            module.offset += #extend(next_ch == '=') + 1;
         },
         else =>
         {
@@ -2984,6 +3085,8 @@ ValueBuilder = struct
     allow_assignment_operators: u1,
 }
 
+parse_precedence = fn (module: &Module, scope: &Scope, builder: ValueBuilder) &Value;
+
 parse_left = fn (module: &Module, scope: &Scope, builder: ValueBuilder) &Value
 {
     >token = builder.token;
@@ -3007,6 +3110,72 @@ parse_left = fn (module: &Module, scope: &Scope, builder: ValueBuilder) &Value
                 zero,
             };
         },
+        .dash, .ampersand, .exclamation, .tilde =>
+        {
+            assert(!builder.left);
+            >id: UnaryId = undefined;
+
+            switch (token.id)
+            {
+                .dash => { id = .minus; },
+                .ampersand => { id = .ampersand; },
+                .exclamation => { id = .exclamation; },
+                .tilde => { id = .bitwise_not; },
+                else => { unreachable; },
+            }
+
+            >unary_builder = builder;
+            unary_builder.precedence = .prefix;
+            unary_builder.token = zero;
+            unary_builder.kind = #select(token.id == .ampersand, .left, builder.kind);
+            
+            >unary_value = parse_precedence(module, scope, unary_builder);
+
+            result = new_value(module);
+            result.& = {
+                .content = {
+                    .unary = {
+                        .value = unary_value,
+                        .id = id,
+                    },
+                },
+                .id = .unary,
+                .kind = .right,
+                zero,
+            };
+        },
+        .identifier =>
+        {
+            #trap();
+        },
+        .value_intrinsic =>
+        {
+            #trap();
+        },
+        .left_bracket =>
+        {
+            #trap();
+        },
+        .dot =>
+        {
+            #trap();
+        },
+        .left_parenthesis =>
+        {
+            #trap();
+        },
+        .string_literal =>
+        {
+            #trap();
+        },
+        .left_brace =>
+        {
+            #trap();
+        },
+        .value_keyword =>
+        {
+            #trap();
+        },
         else =>
         {
             report_error();
@@ -3102,7 +3271,109 @@ get_token_precedence = fn (token: Token) Precedence
 
 parse_right = fn (module: &Module, scope: &Scope, builder: ValueBuilder) &Value
 {
-    #trap();
+    >left = builder.left;
+    assert(left != zero);
+
+    >token = builder.token;
+
+    >result: &Value = zero;
+
+    switch (token.id)
+    {
+        .plus,
+        .dash,
+        .asterisk,
+        .forward_slash,
+        .percentage,
+        .ampersand,
+        .bar,
+        .caret,
+        .shift_left,
+        .shift_right,
+        .compare_equal,
+        .compare_not_equal,
+        .compare_less,
+        .compare_less_equal,
+        .compare_greater,
+        .compare_greater_equal,
+        .operator_keyword,
+        =>
+        {
+            >precedence = get_token_precedence(token);
+            assert(precedence != .assignment);
+
+            >id: BinaryId = undefined;
+
+            switch (token.id)
+            {
+                .operator_keyword =>
+                {
+                    #trap();
+                },
+                .plus => { id = .add; },
+                .dash => { id = .sub; },
+                .asterisk => { id = .mul; },
+                .forward_slash => { id = .div; },
+                .percentage => { id = .rem; },
+                .ampersand => { id = .bitwise_and; },
+                .bar => { id = .bitwise_or; },
+                .caret => { id = .bitwise_xor; },
+                .shift_left => { id = .shift_left; },
+                .shift_right => { id = .shift_right; },
+                .compare_equal => { id = .compare_equal; },
+                .compare_not_equal => { id = .compare_not_equal; },
+                .compare_less => { id = .compare_less; },
+                .compare_less_equal => { id = .compare_less_equal; },
+                .compare_greater => { id = .compare_greater; },
+                .compare_greater_equal => { id = .compare_greater_equal; },
+                else => { unreachable; },
+            }
+
+            >right_precedence: Precedence = #enum_from_int(#int_from_enum(precedence) + 1);
+            >right_builder = builder;
+            right_builder.precedence = right_precedence;
+            right_builder.token = zero;
+            right_builder.left = zero;
+            >right = parse_precedence(module, scope, right_builder);
+
+            result = new_value(module);
+            result.& = {
+                .content = {
+                    .binary = {
+                        .left = left,
+                        .right = right,
+                        .id = id,
+                    },
+                },
+                .id = .binary,
+                .kind = .right,
+                zero,
+            };
+        },
+        .pointer_dereference =>
+        {
+            #trap();
+        },
+        .left_parenthesis =>
+        {
+            #trap();
+        },
+        .left_bracket =>
+        {
+            #trap();
+        },
+        .dot =>
+        {
+            #trap();
+        },
+        else =>
+        {
+            report_error();
+        },
+    }
+
+    assert(result != zero);
+    return result;
 }
 
 parse_right_with_left = fn (module: &Module, scope: &Scope, builder: ValueBuilder) &Value
@@ -5738,6 +6009,18 @@ compile_file = fn (arena: &Arena, compile_options: CompileFile) []u8
 
 names: [_][]u8 = [
     "minimal",
+    "comments",
+    "constant_add",
+    "constant_and",
+    "constant_div",
+    "constant_mul",
+    "constant_rem",
+    "constant_or",
+    "constant_sub",
+    "constant_xor",
+    "constant_shift_left",
+    "constant_shift_right",
+
 ];
 
 [export] main = fn [cc(c)] (argument_count: u32, argv: &&u8, envp: &&u8) s32

src/emitter.cpp

@@ -5983,6 +5983,7 @@ fn LLVMValueRef emit_field_access(Module* module, Value* value, LLVMValueRef lef
                                             auto load = create_load(module, {
                                                 .type = field_access.type,
                                                 .pointer = gep,
+                                                .kind = type_kind,
                                             });
                                             return load;
                                         } break;
@@ -7704,6 +7705,7 @@ fn void emit_value(Module* module, Value* value, TypeKind type_kind, bool expect
                 auto condition = value->select.condition;
                 auto true_value = value->select.true_value;
                 auto false_value = value->select.false_value;
+
                 emit_value(module, condition, TypeKind::abi, must_be_constant);
                 LLVMValueRef llvm_condition = condition->llvm;
                 auto condition_type = condition->type;