From 5094e8b4abf16f816f6ffbd21fff16648bdc7aa7 Mon Sep 17 00:00:00 2001 From: Kyler Date: Mon, 1 Dec 2025 00:56:36 -0700 Subject: [PATCH] implemented for --- SLS_C/src/builtin.c | 191 +++++++++++++++++++++++--------------------- 1 file changed, 100 insertions(+), 91 deletions(-) diff --git a/SLS_C/src/builtin.c b/SLS_C/src/builtin.c index 98f222c..21eb41a 100644 --- a/SLS_C/src/builtin.c +++ b/SLS_C/src/builtin.c @@ -55,6 +55,7 @@ Boolean builtin_floor(InterpreterState *interpreter_state); // Boolean builtin_fn(InterpreterState *interpreter_state); // Boolean builtin_foldl(InterpreterState *interpreter_state); // Boolean builtin_foldr(InterpreterState *interpreter_state); +Boolean builtin_for(InterpreterState *interpreter_state); // Boolean builtin_format(InterpreterState *interpreter_state); // Boolean builtin_get(InterpreterState *interpreter_state); Boolean builtin_if(InterpreterState *interpreter_state); @@ -298,6 +299,12 @@ Boolean load_builtins(InterpreterState *interpreter_state) { if (!hash_table_put_funcs(interpreter_state->functions, SLS_STR("floor"), func)) return FALSE; + func = (FunctionItem *)malloc(sizeof(FunctionItem)); + if (func == NULL) return FALSE; + *func = (FunctionItem){ .type = FUNCTION_BUILTIN, .builtin = *builtin_for}; + if (!hash_table_put_funcs(interpreter_state->functions, SLS_STR("for"), func)) + return FALSE; + func = (FunctionItem *)malloc(sizeof(FunctionItem)); if (func == NULL) return FALSE; *func = (FunctionItem){ .type = FUNCTION_BUILTIN, .builtin = *builtin_if}; @@ -419,7 +426,6 @@ Boolean load_builtins(InterpreterState *interpreter_state) { "// SLS Defined Builtin Operators\n" "// November 2025\n" "\n" - "// { } lambda ::for const\n" "{ ln swap ln swap / } lambda ::logb const\n" "{ 1 pick 1 pick < { swap drop } { drop } if } lambda ::max const\n" "{ 1 pick 1 pick < { drop } { swap drop } if } lambda ::min const\n" @@ -815,6 +821,53 @@ Boolean load_builtins(InterpreterState *interpreter_state) { break; \ } \ +#define SCALAR(item, value) \ + switch (item->type) { \ + case STACK_IDENTIFIER: \ + return FALSE; \ + case STACK_I64: \ + if (item->i64 < 0) return FALSE; \ + value = item->i64; \ + break; \ + case STACK_I32: \ + if (item->i32 < 0) return FALSE; \ + value = item->i32; \ + break; \ + case STACK_I16: \ + if (item->i16 < 0) return FALSE; \ + value = item->i16; \ + break; \ + case STACK_I8: \ + if (item->i8 < 0) return FALSE; \ + value = item->i8; \ + break; \ + case STACK_U64: \ + value = item->u64; \ + break; \ + case STACK_U32: \ + value = item->u32; \ + break; \ + case STACK_U16: \ + value = item->u16; \ + break; \ + case STACK_U8: \ + value = item->u8; \ + break; \ + case STACK_FLOAT: \ + return FALSE; \ + case STACK_DOUBLE: \ + return FALSE; \ + case STACK_CHARACTER: \ + value = item->character; \ + break; \ + case STACK_BOOLEAN: \ + value = item->boolean; \ + break; \ + case STACK_TOKEN_STRING: \ + case STACK_CALLABLE: \ + return FALSE; \ + } \ + Boolean builtin_addition(InterpreterState *interpreter_state) { NUMERIC_TYPES; ARITHMETIC(+); @@ -1615,6 +1668,50 @@ Boolean builtin_floor(InterpreterState *interpreter_state) { FLOAT_FUNCTION(floor); } +Boolean builtin_for(InterpreterState *interpreter_state) { + if (interpreter_state->stack == NULL) return FALSE; + StackItem *for_block = interpreter_state->stack; + if (for_block->next == NULL) return FALSE; + StackItem *end_item = for_block->next; + if (end_item->next == NULL) return FALSE; + StackItem *start_item = end_item->next; + + if (!( + for_block->type == STACK_TOKEN_STRING || + for_block->type == STACK_CALLABLE || + for_block->type == STACK_IDENTIFIER + )) return FALSE; + + interpreter_state->stack = start_item->next; + start_item->next = NULL; + + size_t start_value; + SCALAR(start_item, start_value); + size_t end_value; + SCALAR(end_item, end_value); + + Boolean return_value = FALSE; + for (size_t i = start_value; i < end_value; i++) { + return_value = push_token(interpreter_state, (Token){ + .type = TOKEN_INTEGER, + .integer_literal = (IntegerLiteral){ + .type = INTEGER_I64, + .value = (uint64_t)i, + }, + }); + if (!return_value) break; + + if (for_block->type == STACK_TOKEN_STRING || for_block->type == STACK_CALLABLE) + return_value = execute_token_string(interpreter_state, for_block->token_string); + else if (for_block->type == STACK_IDENTIFIER) + return_value = execute_func(interpreter_state, for_block->identifier.name); + if (!return_value) break; + } + + clean_stack(for_block); + return return_value; +} + Boolean builtin_if(InterpreterState *interpreter_state) { if (interpreter_state->stack == NULL) return FALSE; StackItem *else_block = interpreter_state->stack; @@ -1809,98 +1906,10 @@ Boolean builtin_roll(InterpreterState *interpreter_state) { StackItem *count_item = times_item->next; size_t times; - switch (times_item->type) { - case STACK_IDENTIFIER: - return FALSE; - case STACK_I64: - if (times_item->i64 < 0) return FALSE; - times = times_item->i64; - break; - case STACK_I32: - if (times_item->i32 < 0) return FALSE; - times = times_item->i32; - break; - case STACK_I16: - if (times_item->i16 < 0) return FALSE; - times = times_item->i16; - break; - case STACK_I8: - if (times_item->i8 < 0) return FALSE; - times = times_item->i8; - break; - case STACK_U64: - times = times_item->u64; - break; - case STACK_U32: - times = times_item->u32; - break; - case STACK_U16: - times = times_item->u16; - break; - case STACK_U8: - times = times_item->u8; - break; - case STACK_FLOAT: - return FALSE; - case STACK_DOUBLE: - return FALSE; - case STACK_CHARACTER: - times = times_item->character; - break; - case STACK_BOOLEAN: - times = times_item->boolean; - break; - case STACK_TOKEN_STRING: - case STACK_CALLABLE: - return FALSE; - } + SCALAR(times_item, times); size_t count; - switch (count_item->type) { - case STACK_IDENTIFIER: - return FALSE; - case STACK_I64: - if (count_item->i64 < 0) return FALSE; - count = count_item->i64; - break; - case STACK_I32: - if (count_item->i32 < 0) return FALSE; - count = count_item->i32; - break; - case STACK_I16: - if (count_item->i16 < 0) return FALSE; - count = count_item->i16; - break; - case STACK_I8: - if (count_item->i8 < 0) return FALSE; - count = count_item->i8; - break; - case STACK_U64: - count = count_item->u64; - break; - case STACK_U32: - count = count_item->u32; - break; - case STACK_U16: - count = count_item->u16; - break; - case STACK_U8: - count = count_item->u8; - break; - case STACK_FLOAT: - return FALSE; - case STACK_DOUBLE: - return FALSE; - case STACK_CHARACTER: - count = count_item->character; - break; - case STACK_BOOLEAN: - count = count_item->boolean; - break; - case STACK_TOKEN_STRING: - case STACK_CALLABLE: - return FALSE; - } + SCALAR(count_item, count); StackItem *head = NULL, *tail = NULL, *prev = NULL; if (count > 0) {