From d7107b3fc589a8050db19f1c1259655bfde89f55 Mon Sep 17 00:00:00 2001 From: Kyler Date: Sat, 29 Nov 2025 13:14:30 -0700 Subject: [PATCH] Reworked division, implemented modulus and exponential --- SLS_C/src/builtin.c | 210 +++++++++++++++++++++++--------------------- 1 file changed, 110 insertions(+), 100 deletions(-) diff --git a/SLS_C/src/builtin.c b/SLS_C/src/builtin.c index b84bcaa..084e1ed 100644 --- a/SLS_C/src/builtin.c +++ b/SLS_C/src/builtin.c @@ -4,6 +4,7 @@ // November 2025 #include +#include #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; - if (interpreter_state->stack == NULL) return FALSE; - if (interpreter_state->stack->next == NULL) return FALSE; + NUMERIC_TYPES; + (void)ai; + (void)bi; + (void)type; - switch (interpreter_state->stack->type) { - 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; + if (af == 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; - return FALSE; + 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; - return FALSE; + NUMERIC_TYPES; + (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) {