KylerOlsen/YREA-SLS
KylerOlsen
/
YREA-SLS
1
0
Fork 0
Code Releases 3 Wiki Activity

Reworked division, implemented modulus and exponential

This commit is contained in:
Kyler Olsen 2025-11-29 13:14:30 -07:00
parent 3d419f071c
commit d7107b3fc5
1 changed files with 110 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

210
SLS_C/src/builtin.c
View File

@ -4,6 +4,7 @@
// November 2025 // November 2025
#include <stdlib.h> #include <stdlib.h>
#include <math.h>
#include "sls/bool.h" #include "sls/bool.h"
#include "sls/builtin.h" #include "sls/builtin.h"
@ -655,7 +656,7 @@ Boolean load_builtins(InterpreterState *interpreter_state) {
return TRUE; return TRUE;
} }
#define arithmetic(op) \ #define NUMERIC_TYPES \
double af = 0, bf = 0; \ double af = 0, bf = 0; \
uint64_t ai = 0, bi = 0; \ uint64_t ai = 0, bi = 0; \
uint64_t type = 0; \ uint64_t type = 0; \
@ -799,7 +800,8 @@ Boolean load_builtins(InterpreterState *interpreter_state) {
case STACK_TOKEN_STRING: \ case STACK_TOKEN_STRING: \
return FALSE; \ return FALSE; \
} \ } \
\
#define ARITHMETIC(op) \
StackItem *node = interpreter_state->stack; \ StackItem *node = interpreter_state->stack; \
interpreter_state->stack = interpreter_state->stack->next->next; \ interpreter_state->stack = interpreter_state->stack->next->next; \
node->next->next = NULL; \ node->next->next = NULL; \
@ -882,109 +884,27 @@ Boolean load_builtins(InterpreterState *interpreter_state) {
} }
Boolean builtin_addition(InterpreterState *interpreter_state) { Boolean builtin_addition(InterpreterState *interpreter_state) {
arithmetic(+); NUMERIC_TYPES;
ARITHMETIC(+);
} }
Boolean builtin_subtraction(InterpreterState *interpreter_state) { Boolean builtin_subtraction(InterpreterState *interpreter_state) {
arithmetic(-); NUMERIC_TYPES;
ARITHMETIC(-);
} }
Boolean builtin_multiplication(InterpreterState *interpreter_state) { Boolean builtin_multiplication(InterpreterState *interpreter_state) {
arithmetic(*); NUMERIC_TYPES;
ARITHMETIC(*);
} }
Boolean builtin_division(InterpreterState *interpreter_state) { 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; StackItem *node = interpreter_state->stack;
interpreter_state->stack = interpreter_state->stack->next->next; interpreter_state->stack = interpreter_state->stack->next->next;
@ -993,18 +913,108 @@ Boolean builtin_division(InterpreterState *interpreter_state) {
return push_token(interpreter_state, (Token){ return push_token(interpreter_state, (Token){
.type = TOKEN_DOUBLE, .type = TOKEN_DOUBLE,
.double_literal = (b/a), .double_literal = bf / af,
}); });
} }
Boolean builtin_modulus(InterpreterState *interpreter_state) { Boolean builtin_modulus(InterpreterState *interpreter_state) {
(void)interpreter_state; NUMERIC_TYPES;
return FALSE; (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) { 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) { Boolean builtin_greater_than(InterpreterState *interpreter_state) {