Implemented abs

SLS_C/src/builtin.c

@@ -435,6 +435,82 @@ Boolean load_builtins(InterpreterState *interpreter_state) {
     return TRUE;
 }
 
+#define NUMERIC_TYPE \
+    double af = 0; \
+    uint64_t ai = 0; \
+    uint64_t type = 0; \
+    if (interpreter_state->stack == NULL) return FALSE; \
+    if (interpreter_state->stack->next == NULL) return FALSE; \
+    \
+    switch (interpreter_state->stack->type) { \
+    case STACK_IDENTIFIER: \
+        return FALSE; \
+    case STACK_I64: \
+        ai = interpreter_state->stack->i64; \
+        af = interpreter_state->stack->i64; \
+        type |= NUMERIC_64; \
+        type |= NUMERIC_SIGNED; \
+        break; \
+    case STACK_I32: \
+        ai = interpreter_state->stack->i32; \
+        af = interpreter_state->stack->i32; \
+        type |= NUMERIC_32; \
+        type |= NUMERIC_SIGNED; \
+        break; \
+    case STACK_I16: \
+        ai = interpreter_state->stack->i16; \
+        af = interpreter_state->stack->i16; \
+        type |= NUMERIC_16; \
+        type |= NUMERIC_SIGNED; \
+        break; \
+    case STACK_I8: \
+        ai = interpreter_state->stack->i8; \
+        af = interpreter_state->stack->i8; \
+        type |= NUMERIC_8; \
+        type |= NUMERIC_SIGNED; \
+        break; \
+    case STACK_U64: \
+        ai = interpreter_state->stack->u64; \
+        af = interpreter_state->stack->u64; \
+        type |= NUMERIC_64; \
+        break; \
+    case STACK_U32: \
+        ai = interpreter_state->stack->u32; \
+        af = interpreter_state->stack->u32; \
+        type |= NUMERIC_32; \
+        break; \
+    case STACK_U16: \
+        ai = interpreter_state->stack->u16; \
+        af = interpreter_state->stack->u16; \
+        type |= NUMERIC_16; \
+        break; \
+    case STACK_U8: \
+        ai = interpreter_state->stack->u8; \
+        af = interpreter_state->stack->u8; \
+        type |= NUMERIC_8; \
+        break; \
+    case STACK_FLOAT: \
+        af = interpreter_state->stack->f32; \
+        type |= NUMERIC_32; \
+        type |= NUMERIC_FLOAT; \
+        break; \
+    case STACK_DOUBLE: \
+        af = interpreter_state->stack->f64; \
+        type |= NUMERIC_64; \
+        type |= NUMERIC_FLOAT; \
+        break; \
+    case STACK_CHARACTER: \
+        ai = interpreter_state->stack->character; \
+        af = interpreter_state->stack->character; \
+        break; \
+    case STACK_BOOLEAN: \
+        ai = interpreter_state->stack->boolean; \
+        af = interpreter_state->stack->boolean; \
+        break; \
+    case STACK_TOKEN_STRING: \
+        return FALSE; \
+    }
+
 #define NUMERIC_TYPES \
     double af = 0, bf = 0; \
     uint64_t ai = 0, bi = 0; \
@@ -660,7 +736,7 @@ Boolean load_builtins(InterpreterState *interpreter_state) {
                 .value = bi op ai, \
             }, \
         }); \
-    }
+    } \
 
 Boolean builtin_addition(InterpreterState *interpreter_state) {
     NUMERIC_TYPES;
@@ -827,8 +903,88 @@ Boolean builtin_not_equal_to(InterpreterState *interpreter_state) {
 }
 
 Boolean builtin_abs(InterpreterState *interpreter_state) {
-    (void)interpreter_state;
+    NUMERIC_TYPES;
-    return FALSE;
+
+    StackItem *node = interpreter_state->stack;
+    interpreter_state->stack = interpreter_state->stack->next;
+    node->next = NULL;
+    clean_stack(node);
+
+    if (type & NUMERIC_FLOAT && type & NUMERIC_64) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_DOUBLE,
+            .double_literal = fabs(af),
+        });
+    } else if (type & NUMERIC_FLOAT) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_FLOAT,
+            .float_literal = fabs(af),
+        });
+    } else if (type & NUMERIC_SIGNED && type & NUMERIC_64) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_I64,
+                .value = abs(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 = abs(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 = abs(ai),
+            },
+        });
+    } else if (type & NUMERIC_SIGNED) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_I8,
+                .value = abs(ai),
+            },
+        });
+    } else if (type & NUMERIC_64) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_U64,
+                .value = abs(ai),
+            },
+        });
+    } else if (type & NUMERIC_32) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_U32,
+                .value = abs(ai),
+            },
+        });
+    } else if (type & NUMERIC_16) {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_U16,
+                .value = abs(ai),
+            },
+        });
+    } else {
+        return push_token(interpreter_state, (Token){
+            .type = TOKEN_INTEGER,
+            .integer_literal = (IntegerLiteral){
+                .type = INTEGER_U8,
+                .value = abs(ai),
+            },
+        });
+    }
 }
 
 Boolean builtin_acos(InterpreterState *interpreter_state) {