From 15b3565ee9cfc4a4a9e7b3945219a1f33a380746 Mon Sep 17 00:00:00 2001 From: Kyler Date: Sun, 30 Nov 2025 20:50:32 -0700 Subject: [PATCH] implemented if --- SLS_C/include/sls/interpreter.h | 3 ++ SLS_C/src/builtin.c | 91 ++++++++++++++++++++++++++++++++- SLS_C/src/interpreter.c | 15 +++++- 3 files changed, 105 insertions(+), 4 deletions(-) diff --git a/SLS_C/include/sls/interpreter.h b/SLS_C/include/sls/interpreter.h index 5590259..a90fe14 100644 --- a/SLS_C/include/sls/interpreter.h +++ b/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); diff --git a/SLS_C/src/builtin.c b/SLS_C/src/builtin.c index 89ff5bd..22231fc 100644 --- a/SLS_C/src/builtin.c +++ b/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; - return FALSE; + if (interpreter_state->stack == NULL) 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; } diff --git a/SLS_C/src/interpreter.c b/SLS_C/src/interpreter.c index 5d8b4b7..550f207 100644 --- a/SLS_C/src/interpreter.c +++ b/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,14 +154,24 @@ 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 FALSE; + 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; }