1 files changed, 74 insertions, 8 deletions

diff --git a/src/ir.c b/src/ir.c
index 4c85792..4eeb07b 100644
--- a/src/ir.c
+++ b/src/ir.c
@@ -47,23 +47,24 @@ typedef enum OperandType {
     OP_TYPE_LABEL,
 } OperandType;
 
+static size_t reg_gen_id = 0;
+
+#define NEW_REG()  (Operand){ .type = OP_TYPE_REG, .id = reg_gen_id++ }
+#define NEW_S64(C) (Operand){ .type = OP_TYPE_CONST, .constant.sval = (C) }
+
 typedef struct Operand {
     OperandType type;
     union {
-        struct {
-            size_t num;
-        } reg;
-
-        struct {
-            size_t num;
-        } label;
+        // REG/LABEL
+        size_t id;
 
+        // s64 constant;
         struct {
             union {
                 u64 uval;
                 s64 sval;
             };
-        } const;
+        } constant;
     };
 } Operand;
 
@@ -83,3 +84,68 @@ typedef struct ProgramBASM {
     Instruction *inst;
     LineInfo *lines;
 } ProgramBASM;
+
+Operand
+emit_basm(ProgramBASM *program, Node *node) {
+    switch (node->type) {
+        case NODE_NUMBER: {
+            // TODO: ldX depending on type of number.
+            Instruction inst = (Instruction){
+                .op = OP_LD64,
+                .dst = NEW_REG(),
+                .src_a = NEW_S64(node->number.integral),
+            };
+            LineInfo line = (LineInfo){.line = node->line, .col = node->col};
+            array_push(program->inst, inst);
+            array_push(program->lines, line);
+            return inst.dst;
+        } break;
+        case NODE_BUILTIN: {
+            Operator op;
+            switch (node->builtin.type) {
+                case TOKEN_ADD: { op = OP_ADD; } break;
+                case TOKEN_SUB: { op = OP_SUB; } break;
+                case TOKEN_MUL: { op = OP_MUL; } break;
+                case TOKEN_DIV: { op = OP_DIV; } break;
+                case TOKEN_MOD: { op = OP_MOD; } break;
+                default: break;
+            }
+            Operand reg_a = emit_basm(program, node->builtin.args[0]);
+            Operand reg_b;
+            for (size_t i = 1; i < array_size(node->builtin.args); ++i) {
+                Node *arg = node->builtin.args[i];
+                reg_b = emit_basm(program, arg);
+                Instruction inst = (Instruction){
+                    .op = op,
+                    .dst = NEW_REG(),
+                    .src_a = reg_a,
+                    .src_b = reg_b,
+                };
+                reg_a = inst.dst;
+                LineInfo line = (LineInfo){
+                    .line = node->line,
+                    .col = node->col,
+                };
+                array_push(program->inst, inst);
+                array_push(program->lines, line);
+            }
+            return reg_a;
+        } break;
+        default: {
+            printf("UNIMPLEMENTED\n");
+            return (Operand){0};
+        } break;
+    }
+}
+
+ProgramBASM *
+generate_basm(ParseTree *parse_tree) {
+    ProgramBASM *program = malloc(sizeof(ProgramBASM));
+    array_init(program->inst, 0);
+    array_init(program->lines, 0);
+    for (size_t i = 0; i < array_size(parse_tree->roots); ++i) {
+        Node *root = parse_tree->roots[i];
+        emit_basm(program, root);
+    }
+    return program;
+}