Reworked division, implemented modulus and exponential

SLS_C/src/builtin.c

@@ -4,6 +4,7 @@
 // November 2025
 
 #include <stdlib.h>
+#include <math.h>
 
 #include "sls/bool.h"
 #include "sls/builtin.h"
@@ -655,7 +656,7 @@ Boolean load_builtins(InterpreterState *interpreter_state) {
     return TRUE;
 }
 
-#define arithmetic(op)  \
+#define NUMERIC_TYPES \
     double af = 0, bf = 0; \
     uint64_t ai = 0, bi = 0; \
     uint64_t type = 0; \
@@ -799,7 +800,8 @@ Boolean load_builtins(InterpreterState *interpreter_state) {
     case STACK_TOKEN_STRING: \
         return FALSE; \
     } \
-    \
+
+#define ARITHMETIC(op)  \
     StackItem *node = interpreter_state->stack; \
     interpreter_state->stack = interpreter_state->stack->next->next; \
     node->next->next = NULL; \
@@ -882,109 +884,27 @@ Boolean load_builtins(InterpreterState *interpreter_state) {
     }
 
 Boolean builtin_addition(InterpreterState *interpreter_state) {
-    arithmetic(+);
+    NUMERIC_TYPES;
+    ARITHMETIC(+);
 }
 
 Boolean builtin_subtraction(InterpreterState *interpreter_state) {
-    arithmetic(-);
+    NUMERIC_TYPES;
+    ARITHMETIC(-);
 }
 
 Boolean builtin_multiplication(InterpreterState *interpreter_state) {
-    arithmetic(*);
+    NUMERIC_TYPES;
+    ARITHMETIC(*);
 }
 
 Boolean builtin_division(InterpreterState *interpreter_state) {
-    double a, b;
+    NUMERIC_TYPES;
-    if (interpreter_state->stack == NULL) return FALSE;
+    (void)ai;
-    if (interpreter_state->stack->next == NULL) return FALSE;
+    (void)bi;
+    (void)type;
 
-    switch (interpreter_state->stack->type) {
+    if (af == 0) return FALSE;
-    case STACK_IDENTIFIER:
-        return FALSE;
-    case STACK_I64:
-        a = interpreter_state->stack->i64;
-        break;
-    case STACK_I32:
-        a = interpreter_state->stack->i32;
-        break;
-    case STACK_I16:
-        a = interpreter_state->stack->i16;
-        break;
-    case STACK_I8:
-        a = interpreter_state->stack->i8;
-        break;
-    case STACK_U64:
-        a = interpreter_state->stack->u64;
-        break;
-    case STACK_U32:
-        a = interpreter_state->stack->u32;
-        break;
-    case STACK_U16:
-        a = interpreter_state->stack->u16;
-        break;
-    case STACK_U8:
-        a = interpreter_state->stack->u8;
-        break;
-    case STACK_FLOAT:
-        a = interpreter_state->stack->f32;
-        break;
-    case STACK_DOUBLE:
-        a = interpreter_state->stack->f64;
-        break;
-    case STACK_CHARACTER:
-        a = interpreter_state->stack->character;
-        break;
-    case STACK_BOOLEAN:
-        a = interpreter_state->stack->boolean;
-        break;
-    case STACK_TOKEN_STRING:
-        return FALSE;
-    }
-
-    switch (interpreter_state->stack->next->type) {
-    case STACK_IDENTIFIER:
-        return FALSE;
-    case STACK_I64:
-        b = interpreter_state->stack->next->i64;
-        break;
-    case STACK_I32:
-        b = interpreter_state->stack->next->i32;
-        break;
-    case STACK_I16:
-        b = interpreter_state->stack->next->i16;
-        break;
-    case STACK_I8:
-        b = interpreter_state->stack->next->i8;
-        break;
-    case STACK_U64:
-        b = interpreter_state->stack->next->u64;
-        break;
-    case STACK_U32:
-        b = interpreter_state->stack->next->u32;
-        break;
-    case STACK_U16:
-        b = interpreter_state->stack->next->u16;
-        break;
-    case STACK_U8:
-        b = interpreter_state->stack->next->u8;
-        break;
-    case STACK_FLOAT:
-        b = interpreter_state->stack->next->f32;
-        break;
-    case STACK_DOUBLE:
-        b = interpreter_state->stack->next->f64;
-        break;
-    case STACK_CHARACTER:
-        b = interpreter_state->stack->next->character;
-        break;
-    case STACK_BOOLEAN:
-        b = interpreter_state->stack->next->boolean;
-        break;
-    case STACK_TOKEN_STRING:
-        return FALSE;
-    }
-
-    if (a == 0) return FALSE;
 
     StackItem *node = interpreter_state->stack;
     interpreter_state->stack = interpreter_state->stack->next->next;
@@ -993,18 +913,108 @@ Boolean builtin_division(InterpreterState *interpreter_state) {
 
     return push_token(interpreter_state, (Token){
         .type = TOKEN_DOUBLE,
-        .double_literal = (b/a),
+        .double_literal = bf / af,
     });
 }
 
 Boolean builtin_modulus(InterpreterState *interpreter_state) {
-    (void)interpreter_state;
+    NUMERIC_TYPES;
+    (void)af;
+    (void)bf;
+
+    if (type & NUMERIC_FLOAT) {
         return FALSE;
+    } else if (ai == 0) {
+        return FALSE;
+    }
+
+    StackItem *node = interpreter_state->stack;
+    interpreter_state->stack = interpreter_state->stack->next->next;
+    node->next->next = NULL;
+    clean_stack(node);
+
+    if (type & NUMERIC_SIGNED && type & NUMERIC_64) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_I64,
+                .value = bi % ai,
+            },
+        });
+    } else if (type & NUMERIC_SIGNED && type & NUMERIC_32) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_I32,
+                .value = bi % ai,
+            },
+        });
+    } else if (type & NUMERIC_SIGNED && type & NUMERIC_16) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_I16,
+                .value = bi % ai,
+            },
+        });
+    } else if (type & NUMERIC_SIGNED) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_I8,
+                .value = bi % ai,
+            },
+        });
+    } else if (type & NUMERIC_64) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_U64,
+                .value = bi % ai,
+            },
+        });
+    } else if (type & NUMERIC_32) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_U32,
+                .value = bi % ai,
+            },
+        });
+    } else if (type & NUMERIC_16) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_U16,
+                .value = bi % ai,
+            },
+        });
+    } else {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_U8,
+                .value = bi % ai,
+            },
+        });
+    }
 }
 
 Boolean builtin_exponential(InterpreterState *interpreter_state) {
-    (void)interpreter_state;
+    NUMERIC_TYPES;
-    return FALSE;
+    (void)ai;
+    (void)bi;
+    (void)type;
+
+    StackItem *node = interpreter_state->stack;
+    interpreter_state->stack = interpreter_state->stack->next->next;
+    node->next->next = NULL;
+    clean_stack(node);
+
+    return push_token(interpreter_state, (Token){
+        .type = TOKEN_DOUBLE,
+        .double_literal = pow(bf, af),
+    });
 }
 
 Boolean builtin_greater_than(InterpreterState *interpreter_state) {