implemented if

SLS_C/include/sls/interpreter.h

@@ -27,6 +27,7 @@ typedef enum {
     STACK_CHARACTER,
     STACK_BOOLEAN,
     STACK_TOKEN_STRING,
+    STACK_CODE_BLOCK,
 } StackType;
 
 extern const char *STACK_TYPES_NAMES[];
@@ -74,6 +75,8 @@ typedef struct {
 Boolean push_token(InterpreterState *interpreter_state, Token token);
 void clean_stack(StackItem *item);
 
+Boolean execute_func(InterpreterState *interpreter_state, SlsStr key);
+Boolean execute_token_string(InterpreterState *interpreter_state, TokenString token_string);
 Boolean execute(InterpreterState *interpreter_state, LexerTokenResult *token);
 InterpreterState *interpreter_create();
 void interpreter_delete(InterpreterState *interpreter_state);

SLS_C/src/builtin.c

@@ -514,6 +514,7 @@ Boolean load_builtins(InterpreterState *interpreter_state) {
         af = interpreter_state->stack->boolean; \
         break; \
     case STACK_TOKEN_STRING: \
+    case STACK_CODE_BLOCK: \
         return FALSE; \
     } \
 
@@ -590,6 +591,7 @@ Boolean load_builtins(InterpreterState *interpreter_state) {
         af = interpreter_state->stack->boolean; \
         break; \
     case STACK_TOKEN_STRING: \
+    case STACK_CODE_BLOCK: \
         return FALSE; \
     } \
     \
@@ -659,6 +661,7 @@ Boolean load_builtins(InterpreterState *interpreter_state) {
         bf = interpreter_state->stack->next->boolean; \
         break; \
     case STACK_TOKEN_STRING: \
+    case STACK_CODE_BLOCK: \
         return FALSE; \
     } \
 
@@ -1493,6 +1496,7 @@ Boolean builtin_dup(InterpreterState *interpreter_state) {
         item->boolean = interpreter_state->stack->boolean;
         break;
     case STACK_TOKEN_STRING:
+    case STACK_CODE_BLOCK:
         item->token_string = copy_token_string(interpreter_state->stack->token_string);
         break;
     }
@@ -1517,8 +1521,90 @@ Boolean builtin_for(InterpreterState *interpreter_state) {
 }
 
 Boolean builtin_if(InterpreterState *interpreter_state) {
-    (void)interpreter_state;
+    if (interpreter_state->stack == NULL) return FALSE;
-    return FALSE;
+    StackItem *else_block = interpreter_state->stack;
+    if (else_block->next == NULL) return FALSE;
+    StackItem *then_block = else_block->next;
+    if (then_block->next == NULL) return FALSE;
+    StackItem *conditional = then_block->next;
+
+    if (!(
+        else_block->type == STACK_TOKEN_STRING ||
+        else_block->type == STACK_CODE_BLOCK ||
+        else_block->type == STACK_IDENTIFIER
+    )) return FALSE;
+
+    if (!(
+        then_block->type == STACK_TOKEN_STRING ||
+        then_block->type == STACK_CODE_BLOCK ||
+        then_block->type == STACK_IDENTIFIER
+    )) return FALSE;
+
+    interpreter_state->stack = conditional->next;
+    conditional->next = NULL;
+
+    Boolean value = FALSE;
+    switch (conditional->type) {
+    case STACK_IDENTIFIER:
+        value = TRUE;
+        break;
+    case STACK_I64:
+        value = (conditional->i64) ? TRUE : FALSE;
+        break;
+    case STACK_I32:
+        value = (conditional->i32) ? TRUE : FALSE;
+        break;
+    case STACK_I16:
+        value = (conditional->i16) ? TRUE : FALSE;
+        break;
+    case STACK_I8:
+        value = (conditional->i8) ? TRUE : FALSE;
+        break;
+    case STACK_U64:
+        value = (conditional->u64) ? TRUE : FALSE;
+        break;
+    case STACK_U32:
+        value = (conditional->u32) ? TRUE : FALSE;
+        break;
+    case STACK_U16:
+        value = (conditional->u16) ? TRUE : FALSE;
+        break;
+    case STACK_U8:
+        value = (conditional->u8) ? TRUE : FALSE;
+        break;
+    case STACK_FLOAT:
+        value = (conditional->f32) ? TRUE : FALSE;
+        break;
+    case STACK_DOUBLE:
+        value = (conditional->f64) ? TRUE : FALSE;
+        break;
+    case STACK_CHARACTER:
+        value = (conditional->character) ? TRUE : FALSE;
+        break;
+    case STACK_BOOLEAN:
+        value = conditional->boolean;
+        break;
+    case STACK_TOKEN_STRING:
+    case STACK_CODE_BLOCK:
+        value = (conditional->token_string.length && conditional->token_string.tokens[0].type != TOKEN_EOF) ? TRUE : FALSE;
+        break;
+    }
+
+    Boolean return_value = FALSE;
+    if (value) {
+        if (then_block->type == STACK_TOKEN_STRING || then_block->type == STACK_CODE_BLOCK)
+            return_value = execute_token_string(interpreter_state, then_block->token_string);
+        else if (then_block->type == STACK_IDENTIFIER)
+            return_value = execute_func(interpreter_state, then_block->identifier.name);
+    } else {
+        if (else_block->type == STACK_TOKEN_STRING || else_block->type == STACK_CODE_BLOCK)
+            return_value = execute_token_string(interpreter_state, else_block->token_string);
+        else if (else_block->type == STACK_IDENTIFIER)
+            return_value = execute_func(interpreter_state, else_block->identifier.name);
+    }
+
+    clean_stack(else_block);
+    return return_value;
 }
 
 Boolean builtin_lambda(InterpreterState *interpreter_state) {
@@ -1667,6 +1753,7 @@ Boolean builtin_pick(InterpreterState *interpreter_state) {
         item->boolean = picked->boolean;
         break;
     case STACK_TOKEN_STRING:
+    case STACK_CODE_BLOCK:
         item->token_string = copy_token_string(picked->token_string);
         break;
     }

SLS_C/src/interpreter.c

@@ -146,6 +146,7 @@ Boolean push_token(InterpreterState *interpreter_state, Token token) {
         item->boolean = token.boolean_literal;
         break;
     case STACK_TOKEN_STRING:
+    case STACK_CODE_BLOCK:
         item->token_string = copy_token_string(token.token_string);
         break;
     }
@@ -153,15 +154,25 @@ Boolean push_token(InterpreterState *interpreter_state, Token token) {
     return TRUE;
 }
 
-static Boolean execute_func(InterpreterState *interpreter_state, SlsStr key) {
+Boolean execute_func(InterpreterState *interpreter_state, SlsStr key) {
     FunctionItem *func = hash_table_get_funcs(interpreter_state->functions, key, NULL);
     if (func == NULL) return FALSE;
     switch (func->type) {
     case FUNCTION_BUILTIN:
         return func->builtin(interpreter_state);
     case FUNCTION_TOKEN_STRING:
+        return execute_token_string(interpreter_state, func->token_string);
+    }
     return FALSE;
 }
+
+Boolean execute_token_string(InterpreterState *interpreter_state, TokenString token_string) {
+    for (size_t i = 0; i < token_string.length; i++) {
+        if (token_string.tokens[i].type == TOKEN_IDENTIFIER && !token_string.tokens[i].identifier.is_literal)
+        return execute_func(interpreter_state, token_string.tokens[i].identifier.name);
+    else
+        return push_token(interpreter_state, token_string.tokens[i]);
+    }
     return FALSE;
 }