From 2a03107e94d3fb750176900ee7a3a2aa1cfb887d Mon Sep 17 00:00:00 2001 From: Kyler Date: Thu, 27 Nov 2025 00:24:11 -0700 Subject: [PATCH] Fixed memory errors --- SLS_C/include/sls/lexer.h | 3 +++ SLS_C/src/lexer.c | 36 +++++++++++++++++++------------- SLS_C/src/string.c | 12 +++++++++++ SLS_C/tests/lexer_test_helpers.c | 21 +++++++++++++------ 4 files changed, 51 insertions(+), 21 deletions(-) diff --git a/SLS_C/include/sls/lexer.h b/SLS_C/include/sls/lexer.h index f921045..b53f068 100644 --- a/SLS_C/include/sls/lexer.h +++ b/SLS_C/include/sls/lexer.h @@ -36,6 +36,7 @@ typedef enum { } TokenType; extern const char *TOKEN_TYPES_NAMES[]; +extern const size_t TOKEN_TYPE_COUNT; typedef enum { ARRAY_IDENTIFIER, @@ -56,6 +57,7 @@ typedef enum { } ArrayType; extern const char *ARRAY_TYPES_NAMES[]; +extern const size_t ARRAY_TYPE_COUNT; typedef struct { SlsStr name; @@ -74,6 +76,7 @@ typedef enum { } IntegerBuiltInType; extern const char *INTEGER_TYPES_NAMES[]; +extern const size_t INTEGER_TYPE_COUNT; typedef struct { uint64_t value; diff --git a/SLS_C/src/lexer.c b/SLS_C/src/lexer.c index 9cb1414..c963395 100644 --- a/SLS_C/src/lexer.c +++ b/SLS_C/src/lexer.c @@ -32,24 +32,28 @@ const char *TOKEN_TYPES_NAMES[] = { "Type Tuple", }; +const size_t TOKEN_TYPE_COUNT = sizeof(TOKEN_TYPES_NAMES) / sizeof(*TOKEN_TYPES_NAMES); + const char *ARRAY_TYPES_NAMES[] = { - "Identifier", - "i64", - "i32", - "i16", - "i8", - "u64", - "u32", - "u16", - "u8", - "Float", - "Double", - "Character", - "String", - "Boolean", - "Inline Struct", + "Identifier", + "i64", + "i32", + "i16", + "i8", + "u64", + "u32", + "u16", + "u8", + "Float", + "Double", + "Character", + "String", + "Boolean", + "Inline Struct", }; +const size_t ARRAY_TYPE_COUNT = sizeof(ARRAY_TYPES_NAMES) / sizeof(*ARRAY_TYPES_NAMES); + const char *INTEGER_TYPES_NAMES[] = { "i64", "i32", @@ -61,6 +65,8 @@ const char *INTEGER_TYPES_NAMES[] = { "u8", }; +const size_t INTEGER_TYPE_COUNT = sizeof(INTEGER_TYPES_NAMES) / sizeof(*INTEGER_TYPES_NAMES); + void init_lexer(LexerInfo *lexer_info, SlsStr filename, SlsStr source_code) { // Initializes a LexerInfo struct with file info and source code lexer_info->filename = filename; diff --git a/SLS_C/src/string.c b/SLS_C/src/string.c index aba5760..f60c16f 100644 --- a/SLS_C/src/string.c +++ b/SLS_C/src/string.c @@ -204,18 +204,30 @@ SlsStr sls_format(const SlsStr s, ...) { case 't': items[i].type = FORMAT_SLS_TOKEN_TYPE; items[i].token_type = va_arg(args, TokenType); + if (items[i].token_type >= TOKEN_TYPE_COUNT) { + free(items); + return SLS_STR_NULL; + } length += items[i].self_length = sls_str_nlen(TOKEN_TYPES_NAMES[items[i].token_type], TYPE_NAMES_SAFE_LENGTH); length -= 2; break; case 'a': items[i].type = FORMAT_SLS_ARRAY_TYPE; items[i].array_type = va_arg(args, ArrayType); + if (items[i].array_type >= ARRAY_TYPE_COUNT) { + free(items); + return SLS_STR_NULL; + } length += items[i].self_length = sls_str_nlen(ARRAY_TYPES_NAMES[items[i].array_type], TYPE_NAMES_SAFE_LENGTH); length -= 2; break; case 'i': items[i].type = FORMAT_SLS_BUILTIN_INTEGER; items[i].builtin_integer = va_arg(args, IntegerBuiltInType); + if (items[i].builtin_integer >= INTEGER_TYPE_COUNT) { + free(items); + return SLS_STR_NULL; + } length += items[i].self_length = sls_str_nlen(INTEGER_TYPES_NAMES[items[i].builtin_integer], TYPE_NAMES_SAFE_LENGTH); length -= 2; break; diff --git a/SLS_C/tests/lexer_test_helpers.c b/SLS_C/tests/lexer_test_helpers.c index b22fc14..180c310 100644 --- a/SLS_C/tests/lexer_test_helpers.c +++ b/SLS_C/tests/lexer_test_helpers.c @@ -116,20 +116,25 @@ static SlsStr expected_end_of_token_stream(size_t i) { } static SlsStr token_should_be(size_t i, TokenType should, TokenType found) { - return sls_format(SLS_STR("Token #%z should be a %t, but found a %t"), i, should, found); + if (found >= TOKEN_TYPE_COUNT) + return sls_format(SLS_STR("Token #%z should be a %t, but found invalid enum %u"), i, should, (uint64_t)found); + else + return sls_format(SLS_STR("Token #%z should be a %t, but found a %t"), i, should, found); } static SlsStr integer_type_should_be(size_t i, IntegerBuiltInType should, IntegerBuiltInType found) { - return sls_format(SLS_STR("Token #%z integer type should be a %i, but found a %i"), i, should, found); + if (found >= INTEGER_TYPE_COUNT) + return sls_format(SLS_STR("Token #%z integer type should be a %i, but found invalid enum %u"), i, should, (uint64_t)found); + else + return sls_format(SLS_STR("Token #%z integer type should be a %i, but found a %i"), i, should, found); } static SlsStr integer_value_should_be(size_t i, uint64_t should, uint64_t found) { - return sls_format(SLS_STR("Token #%z integer value should be %i, but found %i"), i, should, found); + return sls_format(SLS_STR("Token #%z integer value should be %u, but found %u"), i, should, found); } static SlsStr character_value_should_be(size_t i, uint8_t should, uint8_t found) { return sls_format(SLS_STR("Token #%z integer value should be %i, but found %i"), i, should, found); - // return sls_format(SLS_STR("Token #%z character value should be '', but found ''"), i, should[0], found[0]); } static SlsStr float_value_should_be(size_t i, double should, double found) { @@ -158,7 +163,10 @@ static SlsStr boolean_should_be(size_t i, Boolean value) { } static SlsStr array_type_should_be(size_t i, ArrayType should, ArrayType found) { - return sls_format(SLS_STR("Token #%z should be a %a, but found a %a"), i, should, found); + if (found >= ARRAY_TYPE_COUNT) + return sls_format(SLS_STR("Token #%z should be a %a, but found invalid enum %u"), i, should, (uint64_t)found); + else + return sls_format(SLS_STR("Token #%z should be a %a, but found a %a"), i, should, found); } static SlsStr array_dimensions_should_be(size_t i, size_t should, size_t found) { @@ -506,7 +514,8 @@ Boolean test_token_string_value(LexerTest *test, LexerResult result, size_t i, T for (size_t j = 0; j < values->tokens; j++) { LexerResult token_string_result = token_string_to_lexer_result(head->result.token_string, head->file_info); if (values->values[j].token_handler(test, token_string_result, j, values->values[j].value)) { - clean_token_result(token_string_result.result); + // We do not clean up here because if token_handler fails the test, it cleans up for us. + // clean_token_result(token_string_result.result); return TRUE; } clean_token_result(token_string_result.result);