start working on supporting operations

src/translator/bytecode_spec.md

@@ -98,7 +98,7 @@ initialises a call instance struct and arguments buffer.
 
 ## OP_CALL
 
-call a function with args
+call the function at the head of the call instance stack, then pops it off the stack.
 
 ## OP_SOURCE_LOCATION
 
@@ -125,12 +125,10 @@ loads a mpq_t number into memory
 1. the register to write to. (*)
 3. the size of the numerator in the constant buffer.
 4. the offset in the constant buffer of the numerator.
+5. is integer. (*)
 3. the size of the denominator in the constant buffer.
 4. the offset in the constant buffer of the denominator.
 
-## OP_SWAP_REGISTERS
+## OP_LOAD_ADDITION_FUNCTION
 
-swap the contents in two registers
-
-1. register a (*)
-2. register b (*)
+loads the addition function into register 1

src/translator/number/number.c

@@ -13,30 +13,27 @@
 
 size_t translate_parsed_number(Translated *translated, mpq_t *number,
                                size_t to_register) {
-  mpz_t num, den;
-  mpz_init(num);
-  mpz_init(den);
-  mpz_set(num, mpq_numref(*number));
-  mpz_set(den, mpq_denref(*number));
-  size_t num_size;
-  void *num_data = mpz_export(NULL, &num_size, 1, 1, 0, 0, num);
-  size_t numerator_pos = arena_push(&translated->constants, num_data, num_size);
-  free(num_data);
-  mpz_clear(num);
-  // Export denominator
-  size_t den_size;
-  void *den_data = mpz_export(NULL, &den_size, 1, 1, 0, 0, den);
-  size_t denominator_pos =
-      arena_push(&translated->constants, den_data, den_size);
-  free(den_data);
-  mpz_clear(den);
   set_registers(translated, to_register + 1);
-
   size_t start = push_instruction_byte(translated, OP_LOAD_NUMBER);
   push_instruction_byte(translated, to_register);
+  size_t num_size;
+  void *num_data = mpz_export(NULL, &num_size, 1, 1, 0, 0, mpq_numref(*number));
+  size_t numerator_pos = arena_push(&translated->constants, num_data, num_size);
+  free(num_data);
   push_instruction_code(translated, num_size);
   push_instruction_code(translated, numerator_pos);
-  push_instruction_code(translated, den_size);
-  push_instruction_code(translated, denominator_pos);
+  bool is_int = mpz_cmp_ui(mpq_denref(*number), 1) == 0;
+  push_instruction_byte(translated, is_int);
+  if (!is_int) {
+    // Export denominator
+    size_t den_size;
+    void *den_data =
+        mpz_export(NULL, &den_size, 1, 1, 0, 0, mpq_denref(*number));
+    size_t denominator_pos =
+        arena_push(&translated->constants, den_data, den_size);
+    free(den_data);
+    push_instruction_code(translated, den_size);
+    push_instruction_code(translated, denominator_pos);
+  }
   return start;
 }

src/translator/operation/operation.c

@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2025 William Bell
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include "operation.h"
+#include <stddef.h>
+
+size_t translate_operation(Translated *translated, ParsedOperation *operation,
+                        ArErr *err) {
+  set_registers(translated, 1);
+  uint64_t first = push_instruction_byte(translated, OP_LOAD_ADDITION_FUNCTION);
+  push_instruction_byte(translated, OP_INIT_CALL);
+  push_instruction_code(translated, operation->to_operate_on.size);
+
+  for (size_t i = 0; i < operation->to_operate_on.size; i++) {
+    translate_parsed(translated, darray_get(&operation->to_operate_on, i), err);
+    push_instruction_byte(translated, OP_INSERT_ARG);
+    push_instruction_code(translated, i);
+  }
+
+  push_instruction_byte(translated, OP_SOURCE_LOCATION);
+  push_instruction_code(translated, operation->line);
+  push_instruction_code(translated, operation->column);
+  push_instruction_code(translated, operation->length);
+  push_instruction_byte(translated, OP_CALL);
+  return first;
+}

src/translator/operation/operation.h

@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2025 William Bell
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#ifndef BYTECODE_OPERATION_H
+#define BYTECODE_OPERATION_H
+#include "../translator.h"
+#include "../../parser/operations/operations.h"
+
+size_t translate_operation(Translated *translated, ParsedOperation *operation,
+                        ArErr *err);
+
+#endif

src/translator/translator.c

@@ -6,16 +6,17 @@
 
 #include "translator.h"
 #include "../hash_data/hash_data.h"
-#include "declaration/declaration.h"
+#include "access/access.h"
 #include "call/call.h"
+#include "declaration/declaration.h"
 #include "dowrap/dowrap.h"
 #include "function/function.h"
 #include "identifier/identifier.h"
 #include "if/if.h"
 #include "number/number.h"
-#include "string/string.h"
+#include "operation/operation.h"
 #include "return/return.h"
-#include "access/access.h"
+#include "string/string.h"
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -79,11 +80,11 @@ size_t arena_push(ConstantArena *arena, const void *data, size_t length) {
   return offset;
 }
 
-Translated init_translator(char* path) {
+Translated init_translator(char *path) {
   Translated translated;
   translated.path = path;
   translated.registerCount = 1;
-  translated.return_jumps=NULL;
+  translated.return_jumps = NULL;
   darray_init(&translated.bytecode, sizeof(uint8_t));
   arena_init(&translated.constants);
   return translated;
@@ -118,7 +119,8 @@ void set_registers(Translated *translator, uint8_t count) {
     translator->registerCount = count;
 }
 
-size_t translate_parsed(Translated *translated, ParsedValue *parsedValue, ArErr*err) {
+size_t translate_parsed(Translated *translated, ParsedValue *parsedValue,
+                        ArErr *err) {
   switch (parsedValue->type) {
   case AST_STRING:
     return translate_parsed_string(translated,
@@ -127,7 +129,7 @@ size_t translate_parsed(Translated *translated, ParsedValue *parsedValue, ArErr*
     return translate_parsed_declaration(translated,
                                         *((DArray *)parsedValue->data), err);
   case AST_NUMBER:
-    return translate_parsed_number(translated, (mpq_t*)parsedValue->data, 0);
+    return translate_parsed_number(translated, (mpq_t *)parsedValue->data, 0);
   case AST_NULL:
     set_registers(translated, 1);
     size_t output = push_instruction_byte(translated, OP_LOAD_NULL);
@@ -142,13 +144,19 @@ size_t translate_parsed(Translated *translated, ParsedValue *parsedValue, ArErr*
   case AST_IF:
     return translate_parsed_if(translated, (DArray *)parsedValue->data, err);
   case AST_DOWRAP:
-    return translate_parsed_dowrap(translated, (DArray *)parsedValue->data, err);
+    return translate_parsed_dowrap(translated, (DArray *)parsedValue->data,
+                                   err);
   case AST_RETURN:
-    return translate_parsed_return(translated, (ParsedReturn *)parsedValue->data, err);
+    return translate_parsed_return(translated,
+                                   (ParsedReturn *)parsedValue->data, err);
   case AST_CALL:
-    return translate_parsed_call(translated, (ParsedCall*)parsedValue->data, err);
+    return translate_parsed_call(translated, (ParsedCall *)parsedValue->data,
+                                 err);
   case AST_ACCESS:
-    return translate_access(translated,(ParsedAccess*)parsedValue->data, err);
+    return translate_access(translated, (ParsedAccess *)parsedValue->data, err);
+  case AST_OPERATION:
+    return translate_operation(translated, (ParsedOperation *)parsedValue->data,
+                               err);
   }
   return 0;
 }

src/translator/translator.h

@@ -31,7 +31,8 @@ typedef enum {
   OP_SOURCE_LOCATION,
   OP_LOAD_ACCESS_FUNCTION,
   OP_LOAD_BOOL,
-  OP_LOAD_NUMBER
+  OP_LOAD_NUMBER,
+  OP_LOAD_ADDITION_FUNCTION
 } OperationType;
 
 void arena_resize(ConstantArena *arena, size_t new_size);