Fixed memory errors

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;

SLS_C/src/lexer.c

@@ -32,6 +32,8 @@ 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",
@@ -50,6 +52,8 @@ const char *ARRAY_TYPES_NAMES[] = {
         "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;

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;

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) {
+    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) {
+    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,6 +163,9 @@ static SlsStr boolean_should_be(size_t i, Boolean value) {
 }
 
 static SlsStr array_type_should_be(size_t i, ArrayType should, ArrayType 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);
 }
 
@@ -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);