KylerOlsen/YREA-SLS
KylerOlsen
/
YREA-SLS
1
0
Fork 0
Code Releases 3 Wiki Activity

Fixed memory errors

This commit is contained in:
Kyler Olsen 2025-11-27 00:24:11 -07:00
parent a080dbc2fb
commit 2a03107e94
4 changed files with 51 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
SLS_C/include/sls/lexer.h
View File

@ -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;

36
SLS_C/src/lexer.c
View File

@ -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;

12
SLS_C/src/string.c
View File

@ -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;

21
SLS_C/tests/lexer_test_helpers.c
View File

@ -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);