.

lib/expr.c

@@ -0,0 +1,35 @@
+#include "priv.h"
+
+#include <stdbool.h>
+
+static bool was_init = false;
+
+typedef TYC_RESULT(*BIN_EXPR_FN)(VALUE, VALUE, VALUE*);
+static BIN_EXPR_FN bin_expr_fn[TX_COUNT__][TT_COUNT__][TT_COUNT__];
+
+static TYC_RESULT default_bin_op(VALUE a, VALUE b, VALUE* r) { (void) a; (void) b, (void) r; return T_ERR_EXPR_INCORRECT_TYPES; }
+
+#define BIN_OP(name) static TYC_RESULT name(VALUE a, VALUE b, VALUE* r)
+BIN_OP(sum_int) { *r = create_value_integer(value_integer(a) + value_integer(b)); return T_OK; }
+BIN_OP(sub_int) { *r = create_value_integer(value_integer(a) - value_integer(b)); return T_OK; }
+
+void expr_init(void)
+{
+    if (was_init)
+        return;
+
+    for (size_t i = 0; i < TX_COUNT__; ++i)
+        for (size_t j = 0; j < TT_COUNT__; ++j)
+            for (size_t k = 0; k < TT_COUNT__; ++k)
+                bin_expr_fn[i][j][k] = default_bin_op;
+
+    bin_expr_fn[TX_SUM][TT_INTEGER][TT_INTEGER] = sum_int;
+    bin_expr_fn[TX_SUBTRACT][TT_INTEGER][TT_INTEGER] = sub_int;
+
+    was_init = true;
+}
+
+TYC_RESULT binary_expr(TYC_EXPR op, VALUE a, VALUE b, VALUE* result)
+{
+    return bin_expr_fn[op][value_type(a)][value_type(b)](a, b, result);
+}

lib/priv.h

@@ -225,4 +225,11 @@ const char*    code_const_string(Code const* code, size_t n);
 uint32_t       code_n_functions(Code const* code);
 Instruction    code_next_instruction(Code const* code, uint32_t function_id, uint32_t pc);
 
+//
+// EXPRESSIONS
+//
+
+void       expr_init(void);
+TYC_RESULT binary_expr(TYC_EXPR op, VALUE a, VALUE b, VALUE* result);
+
 #endif //TYCHE_PRIV_H

lib/table.c

@@ -59,6 +59,7 @@ static TABLE_HASH value_hash(VALUE v)
         case TT_NATIVE_PTR:
             return (TABLE_HASH) value_idx(v) | ((TABLE_HASH) 1 << 37);
         case TT_STRING:
+        case TT_COUNT__:
         default:
             __builtin_unreachable();
     }

lib/tyche.h

@@ -6,6 +6,7 @@
 
 typedef enum {
     TT_NIL, TT_INTEGER, TT_REAL, TT_STRING, TT_STRING_CONST, TT_ARRAY, TT_TABLE, TT_FUNCTION, TT_NATIVE_PTR,
+    TT_COUNT__
 } TYC_TYPE;
 
 typedef enum {
@@ -15,11 +16,12 @@ typedef enum {
     T_ERR_TABLE_KEY_NOT_FOUND = -20,
     T_ERR_ASSEMBLER_SYNTAX_ERROR = -30,
     T_ERR_BYTECODE_TOO_SMALL = -40, T_ERR_BYTECODE_INVALID_MAGIC = -41,
-    T_ERR_TYPE_UNEXPECTED = -50, T_ERR_INVALID_OPCODE = -51,
+    T_ERR_TYPE_UNEXPECTED = -50, T_ERR_INVALID_OPCODE = -51, T_ERR_EXPR_INCORRECT_TYPES = -52,
 } TYC_RESULT;
 
 typedef enum {
-    TX_SUM,
+    TX_SUM, TX_SUBTRACT,
+    TX_COUNT__
 } TYC_EXPR;
 
 #define T_REAL float

lib/vm.c

@@ -39,6 +39,9 @@ TycheVM* tyc_new(void)
         .cap = 4,
         .sz = 0,
     };
+
+    expr_init();
+
     return t;
 }
 
@@ -177,13 +180,16 @@ TYC_RESULT tyc_tointeger(TycheVM* T, int idx, int32_t* value)
     return r;
 }
 
-TYC_RESULT tyc_expr(TycheVM* T, TYC_EXPR expr)
+TYC_RESULT tyc_expr(TycheVM* T, TYC_EXPR op)
 {
-    // TODO
-    VALUE v1, v2;
+    TYC_RESULT r;
+    VALUE v1, v2, result;
+
     stack_pop(T->stack, &v2);
     stack_pop(T->stack, &v1);
-    stack_push(T->stack, create_value_integer(value_integer(v1) + value_integer(v2)));
+    TRY(binary_expr(op, v1, v2, &result))
+    stack_push(T->stack, result);
+
     return T_OK;
 }
 
@@ -203,13 +209,24 @@ static TYC_RESULT step(TycheVM* T)
 
     switch (inst.operator) {
 
+        //
+        // stack manipulation
+        //
+
         case TO_PUSHI:
             tyc_pushinteger(T, inst.operand);
             break;
 
-        case TO_SUM:
-            TRY(tyc_expr(T, TX_SUM))
-            break;
+        //
+        // expressions
+        //
+
+        case TO_SUM: TRY(tyc_expr(T, TX_SUM)); break;
+        case TO_SUB: TRY(tyc_expr(T, TX_SUBTRACT)); break;
+
+        //
+        // function calls
+        //
 
         case TO_RET:
             TRY(stack_pop(T->stack, &a))