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

Tests are compiling and running again

This commit is contained in:
Kyler Olsen 2025-11-23 21:26:38 -07:00
parent ad26c41463
commit 1566c7bf60
5 changed files with 235 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
SLS_C/include/tests/lexer_test_helpers.h
View File

@ -124,6 +124,6 @@ Boolean test_array_boolean_value(LexerTest *test, LexerResult result, size_t i,
Boolean test_array_struct_inline_value(LexerTest *test, LexerResult result, size_t i, TestArrayStructInlineValue *values); Boolean test_array_struct_inline_value(LexerTest *test, LexerResult result, size_t i, TestArrayStructInlineValue *values);
Boolean test_token_string_value(LexerTest *test, LexerResult result, size_t i, TestTokenStringValue *values); Boolean test_token_string_value(LexerTest *test, LexerResult result, size_t i, TestTokenStringValue *values);
Boolean test_type_tuple_value(LexerTest *test, LexerResult result, size_t i, TestTypeTupleValue *values); Boolean test_type_tuple_value(LexerTest *test, LexerResult result, size_t i, TestTypeTupleValue *values);
Boolean test_for_error(LexerTest *test, LexerResult result, size_t i, SlsStr error); Boolean test_for_error(LexerTest *test, LexerResult result, size_t i, SlsStr *error);
#endif // SLS_LEXER_TEST_HELPERS_H #endif // SLS_LEXER_TEST_HELPERS_H

8
SLS_C/tests/lexer_test_helpers.c
View File

@ -551,13 +551,13 @@ Boolean test_type_tuple_value(LexerTest *test, LexerResult result, size_t i, Tes
return FALSE; return FALSE;
} }
Boolean test_for_error(LexerTest *test, LexerResult result, size_t i, SlsStr error) { Boolean test_for_error(LexerTest *test, LexerResult result, size_t i, SlsStr *error) {
LexerTokenResult *head = get_token(result.result, i); LexerTokenResult *head = get_token(result.result, i);
if (head->type != SLS_ERROR) { if (head->type != SLS_ERROR) {
logic_fail_test(test, result, token_should_be_error(i + 1, error, head->result.type)); logic_fail_test(test, result, token_should_be_error(i + 1, *error, head->result.type));
return TRUE; return TRUE;
} if (sls_str_cmp(head->error.message, error) != 0) { } if (sls_str_cmp(head->error.message, *error) != 0) {
logic_fail_test(test, result, error_should_be(i + 1, error, head->error)); logic_fail_test(test, result, error_should_be(i + 1, *error, head->error));
return TRUE; return TRUE;
} }
return FALSE; return FALSE;

194
SLS_C/tests/lexer_tests.c
View File

@ -232,7 +232,7 @@ static TestResult test_Integer_Default_Decimal_with_Commas_Invalid() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid decimal literal: unexpected ',' in decimal integer."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid decimal literal: unexpected ',' in decimal integer."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -241,7 +241,7 @@ static TestResult test_Integer_Default_Invalid_Characters() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -250,7 +250,7 @@ static TestResult test_Integer_Default_Invalid_Prefix() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid binary literal: unexpected '2' in binary integer."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid binary literal: unexpected '2' in binary integer."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -339,7 +339,7 @@ static TestResult test_Integer_i8_Overflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for i8."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i8."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -348,7 +348,7 @@ static TestResult test_Integer_i8_Underflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for i8."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i8."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -477,7 +477,7 @@ static TestResult test_Integer_i16_Overflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for i16."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i16."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -486,7 +486,7 @@ static TestResult test_Integer_i16_Underflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for i16."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i16."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -605,7 +605,7 @@ static TestResult test_Integer_i32_Overflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for i32."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i32."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -614,7 +614,7 @@ static TestResult test_Integer_i32_Underflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for i32."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i32."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -733,7 +733,7 @@ static TestResult test_Integer_i64_Overflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for i64."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i64."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -742,7 +742,7 @@ static TestResult test_Integer_i64_Underflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for i64."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for i64."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -871,7 +871,7 @@ static TestResult test_Integer_u8_Overflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for u8."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u8."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -880,7 +880,7 @@ static TestResult test_Integer_u8_Underflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for u8."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u8."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -989,7 +989,7 @@ static TestResult test_Integer_u16_Overflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for u16."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u16."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -998,7 +998,7 @@ static TestResult test_Integer_u16_Underflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for u16."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u16."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -1117,7 +1117,7 @@ static TestResult test_Integer_u32_Overflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for u32."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u32."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -1126,7 +1126,7 @@ static TestResult test_Integer_u32_Underflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for u32."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u32."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -1255,7 +1255,7 @@ static TestResult test_Integer_u64_Overflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for u64."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u64."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -1264,7 +1264,7 @@ static TestResult test_Integer_u64_Underflow() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Integer overflow: value exceeds range for u64."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Integer overflow: value exceeds range for u64."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -1623,7 +1623,7 @@ static TestResult test_Float_Invalid_Multiple_Decimal_Points() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: unexpected '.' in float."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid float literal: unexpected '.' in float."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -1632,7 +1632,7 @@ static TestResult test_Float_Invalid_Characters() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: unexpected 'a' in float."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid float literal: unexpected 'a' in float."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -1641,7 +1641,7 @@ static TestResult test_Float_Invalid_Type_Annotation() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid float type: must be of type 'f64' or 'f32'."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid float type: must be of type 'f64' or 'f32'."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -1650,7 +1650,7 @@ static TestResult test_Float_Invalid_Type_Name() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid float type: must be of type 'f64' or 'f32'."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid float type: must be of type 'f64' or 'f32'."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -1659,7 +1659,7 @@ static TestResult test_Float_Invalid_Comma_Separator() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid float literal: unexpected ',' in float."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid float literal: unexpected ',' in float."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2073,16 +2073,6 @@ static TestResult test_Char_Right_Brace() {
return pass_test(&test, result); return pass_test(&test, result);
} }
static TestResult test_Char_Escape_Tab() {
LexerTest test = start_up_test(SLS_STR("Char Escape Tab"), SLS_STR("'\\t'"));
LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0;
if (test_character_value(&test, result, i++, &(uint8_t){9})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result);
}
static TestResult test_Char_Escape_Null_character() { static TestResult test_Char_Escape_Null_character() {
LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\\0'")); LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\\0'"));
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
@ -2113,6 +2103,16 @@ static TestResult test_Char_Escape_Newline() {
return pass_test(&test, result); return pass_test(&test, result);
} }
static TestResult test_Char_Escape_Single_quote() {
LexerTest test = start_up_test(SLS_STR("Char Escape Single quote"), SLS_STR("'\\''"));
LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0;
if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result);
}
static TestResult test_Char_Escape_Backslash() { static TestResult test_Char_Escape_Backslash() {
LexerTest test = start_up_test(SLS_STR("Char Escape Backslash"), SLS_STR("'\\\\'")); LexerTest test = start_up_test(SLS_STR("Char Escape Backslash"), SLS_STR("'\\\\'"));
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
@ -2123,12 +2123,12 @@ static TestResult test_Char_Escape_Backslash() {
return pass_test(&test, result); return pass_test(&test, result);
} }
static TestResult test_Char_Escape_Single_quote() { static TestResult test_Char_Escape_Tab() {
LexerTest test = start_up_test(SLS_STR("Char Escape Single quote"), SLS_STR("'\\''")); LexerTest test = start_up_test(SLS_STR("Char Escape Tab"), SLS_STR("'\\t'"));
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_character_value(&test, result, i++, &(uint8_t){39})) return test.result; if (test_character_value(&test, result, i++, &(uint8_t){9})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2248,7 +2248,7 @@ static TestResult test_Char_Empty_Literal() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: empty character literal."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: empty character literal."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2257,7 +2257,7 @@ static TestResult test_Char_Multiple_Characters() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: unexpected 'B' in character."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: unexpected 'B' in character."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2266,7 +2266,7 @@ static TestResult test_Char_Unclosed_Quote() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: unclosed character literal."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: unclosed character literal."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2275,7 +2275,7 @@ static TestResult test_Char_Unescaped_Newline() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: unclosed character literal."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: unclosed character literal."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2284,7 +2284,7 @@ static TestResult test_Char_Invalid_Escape() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: unknown escape sequence '\\q'."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: unknown escape sequence '\\q'."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2293,7 +2293,7 @@ static TestResult test_Char_Hex_Escape_Too_Short() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2302,7 +2302,7 @@ static TestResult test_Char_Hex_Escape_Too_Long() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: hexadecimal escape must have exactly 2 digits."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2311,7 +2311,7 @@ static TestResult test_Char_Hex_Invalid_Digit() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid character literal: invalid hexadecimal digit 'G'."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid character literal: invalid hexadecimal digit 'G'."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2840,7 +2840,7 @@ static TestResult test_Identifier_Starting_With_Number() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2859,7 +2859,7 @@ static TestResult test_Identifier_With_Colon() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: ':' is not allowed in identifiers."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid identifier: ':' is not allowed in identifiers."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2868,7 +2868,7 @@ static TestResult test_Identifier_Double_Colon_Inside() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Invalid identifier: ':' is not allowed in identifiers."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Invalid identifier: ':' is not allowed in identifiers."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -2887,7 +2887,7 @@ static TestResult test_Identifier_Literal_Empty() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Unexpected character: unexpected ':' during parsing."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Unexpected character: unexpected ':' during parsing."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3430,7 +3430,7 @@ static TestResult test_TokenString_Empty() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){0, NULL})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){0, NULL})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3440,7 +3440,7 @@ static TestResult test_TokenString_Single_Integer() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 42}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 42}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3450,7 +3450,7 @@ static TestResult test_TokenString_Single_Identifier() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3460,7 +3460,7 @@ static TestResult test_TokenString_Two_Integers() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3470,7 +3470,7 @@ static TestResult test_TokenString_Simple_Expression() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3480,7 +3480,7 @@ static TestResult test_TokenString_Stack_Ops() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3490,7 +3490,7 @@ static TestResult test_TokenString_Integer_Literals() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){4, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 0}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 42}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, -10}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 1000}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){4, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 0}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 42}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, -10}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 1000}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3500,7 +3500,7 @@ static TestResult test_TokenString_Float_Literals() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_double_value, .value = &(double){3.14}}, {.token_handler = test_double_value, .value = &(double){-2.5}}, {.token_handler = test_double_value, .value = &(double){0.0}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_double_value, &(double){3.14}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_double_value, &(double){-2.5}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_double_value, &(double){0.0}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3510,7 +3510,7 @@ static TestResult test_TokenString_Char_Literal() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_character_value, .value = &(uint8_t){65}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_character_value, &(uint8_t){65}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3520,7 +3520,7 @@ static TestResult test_TokenString_Boolean_Literals() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_boolean_value, .value = &(Boolean){TRUE}}, {.token_handler = test_boolean_value, .value = &(Boolean){FALSE}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_boolean_value, &(Boolean){TRUE}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_boolean_value, &(Boolean){FALSE}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3530,7 +3530,7 @@ static TestResult test_TokenString_Multiple_Identifiers() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("swap")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("over")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("swap")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("over")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3540,7 +3540,7 @@ static TestResult test_TokenString_Identifier_Literals() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){TRUE, SLS_STR("x")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){TRUE, SLS_STR("y")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){TRUE, SLS_STR("x")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){TRUE, SLS_STR("y")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3550,7 +3550,7 @@ static TestResult test_TokenString_Mixed_Identifiers() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){4, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){TRUE, SLS_STR("Point")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("get")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("swap")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){4, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){TRUE, SLS_STR("Point")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("get")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("swap")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3560,7 +3560,7 @@ static TestResult test_TokenString_Nested_Single() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3570,7 +3570,7 @@ static TestResult test_TokenString_Nested_With_Others() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3580,7 +3580,7 @@ static TestResult test_TokenString_Multiple_Nested() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 4}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 5}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 4}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 5}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3590,7 +3590,7 @@ static TestResult test_TokenString_Double_Nested() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_token_string_value, .value = &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_token_string_value, .value = &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 42}}}}}}}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 42}}}}}}}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3600,7 +3600,7 @@ static TestResult test_TokenString_Complex_Nesting() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 1}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}}}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 4}}}}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 5}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 1}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 4}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 5}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3610,7 +3610,7 @@ static TestResult test_TokenString_No_Whitespace() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3620,7 +3620,7 @@ static TestResult test_TokenString_Extra_Whitespace() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3630,7 +3630,7 @@ static TestResult test_TokenString_Leading_Whitespace_Outside() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3640,7 +3640,7 @@ static TestResult test_TokenString_Trailing_Whitespace_Outside() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3650,7 +3650,7 @@ static TestResult test_TokenString_With_Tabs() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3660,7 +3660,7 @@ static TestResult test_TokenString_Multiline_Simple() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3670,7 +3670,7 @@ static TestResult test_TokenString_Multiline_Multiple() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){4, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){4, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3680,7 +3680,7 @@ static TestResult test_TokenString_Mixed_Line_Breaks() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){6, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 1}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 4}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 5}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 6}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){6, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 1}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 4}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 5}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 6}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3690,7 +3690,7 @@ static TestResult test_TokenString_Indented_Multiline() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){6, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 0}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR(">")}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){0, NULL}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 0}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("swap")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("-")}}}}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("if")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){6, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 0}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR(">")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){0, NULL}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 0}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("swap")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("-")}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("if")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3700,7 +3700,7 @@ static TestResult test_TokenString_Comment_End_Of_Line() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3710,7 +3710,7 @@ static TestResult test_TokenString_Multiple_Comments() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3720,7 +3720,7 @@ static TestResult test_TokenString_Comment_Own_Line() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3730,7 +3730,7 @@ static TestResult test_TokenString_Comment_At_Start() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3740,7 +3740,7 @@ static TestResult test_TokenString_Multiple_Comment_Lines() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3750,7 +3750,7 @@ static TestResult test_TokenString_Comments_Nested() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_token_string_value, .value = &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3760,7 +3760,7 @@ static TestResult test_TokenString_Unclosed() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Unclosed token string: missing closing brace '}'."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Unclosed token string: missing closing brace '}'."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3769,7 +3769,7 @@ static TestResult test_TokenString_Unclosed_Nested() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Unclosed token string: missing closing brace '}'."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Unclosed token string: missing closing brace '}'."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3778,8 +3778,8 @@ static TestResult test_TokenString_Extra_Closing_Brace() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 3}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 3}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_for_error(&test, result, i++, SLS_STR("Unexpected closing brace '}' without matching opening brace."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Unexpected closing brace '}' without matching opening brace."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3788,7 +3788,7 @@ static TestResult test_TokenString_Only_Closing_Brace() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_for_error(&test, result, i++, SLS_STR("Unexpected closing brace '}' without matching opening brace."))) return test.result; if (test_for_error(&test, result, i++, &SLS_STR("Unexpected closing brace '}' without matching opening brace."))) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3797,7 +3797,7 @@ static TestResult test_TokenString_Error_Inside() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){3, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_for_error, .value = SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer.")}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){3, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_for_error, &SLS_STR("Invalid decimal literal: unexpected 'a' in decimal integer.")}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3807,7 +3807,7 @@ static TestResult test_TokenString_Unclosed_String_Inside() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){1, (TestTokenValue[]){{.token_handler = test_for_error, .value = SLS_STR("Invalid string literal: unclosed string literal.")}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){1, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_for_error, &SLS_STR("Invalid string literal: unclosed string literal.")}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3817,7 +3817,7 @@ static TestResult test_TokenString_Function_Body() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3827,7 +3827,7 @@ static TestResult test_TokenString_Loop_Body() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){4, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("print")}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 1}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){4, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("print")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 1}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("+")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3837,7 +3837,7 @@ static TestResult test_TokenString_Struct_Fields() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){4, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR(":")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("y")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR(":")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){4, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("x")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR(":")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("y")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR(":")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3847,7 +3847,7 @@ static TestResult test_TokenString_Lambda() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 2}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 2}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3857,7 +3857,7 @@ static TestResult test_TokenString_Array_Map() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -3867,7 +3867,7 @@ static TestResult test_TokenString_Conditional_Complex() {
LexerResult result = lexical_analysis(&test.lexer_info); LexerResult result = lexical_analysis(&test.lexer_info);
if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error); if (result.type == SLS_ERROR) return error_fail_test(&test, result, result.error);
size_t i = 0; size_t i = 0;
if (test_token_string_value(&test, result, i, &(TestTokenStringValue){6, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 0}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR(">")}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}, {.token_handler = test_token_string_value, .value = &(TestTokenStringValue){2, (TestTokenValue[]){{.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("drop")}}, {.token_handler = test_integer_value, .value = &(TestIntegerValue){INTEGER_I64, 0}}}}}, {.token_handler = test_identifier_value, .value = &(TestIdentifierValue){FALSE, SLS_STR("if")}}}})) return test.result; if (test_token_string_value(&test, result, i++, &(TestTokenStringValue){6, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 0}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR(">")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("dup")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("*")}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_token_string_value, &(TestTokenStringValue){2, (TestTokenStringToken[]){{(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("drop")}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_integer_value, &(TestIntegerValue){INTEGER_I64, 0}}}}}, {(Boolean (*)(LexerTest *, LexerResult, size_t, void *))test_identifier_value, &(TestIdentifierValue){FALSE, SLS_STR("if")}}}})) return test.result;
if (test_eof_value(&test, result, i++, 0)) return test.result; if (test_eof_value(&test, result, i++, 0)) return test.result;
return pass_test(&test, result); return pass_test(&test, result);
} }
@ -4089,12 +4089,12 @@ TestsReport run_lexer_tests() {
test_report.tests[i++] = test_Char_Right_Bracket(); test_report.tests[i++] = test_Char_Right_Bracket();
test_report.tests[i++] = test_Char_Left_Brace(); test_report.tests[i++] = test_Char_Left_Brace();
test_report.tests[i++] = test_Char_Right_Brace(); test_report.tests[i++] = test_Char_Right_Brace();
test_report.tests[i++] = test_Char_Escape_Tab();
test_report.tests[i++] = test_Char_Escape_Null_character(); test_report.tests[i++] = test_Char_Escape_Null_character();
test_report.tests[i++] = test_Char_Escape_Carriage_return(); test_report.tests[i++] = test_Char_Escape_Carriage_return();
test_report.tests[i++] = test_Char_Escape_Newline(); test_report.tests[i++] = test_Char_Escape_Newline();
test_report.tests[i++] = test_Char_Escape_Backslash();
test_report.tests[i++] = test_Char_Escape_Single_quote(); test_report.tests[i++] = test_Char_Escape_Single_quote();
test_report.tests[i++] = test_Char_Escape_Backslash();
test_report.tests[i++] = test_Char_Escape_Tab();
test_report.tests[i++] = test_Char_Hex_Lowercase_A(); test_report.tests[i++] = test_Char_Hex_Lowercase_A();
test_report.tests[i++] = test_Char_Hex_Uppercase_A(); test_report.tests[i++] = test_Char_Hex_Uppercase_A();
test_report.tests[i++] = test_Char_Hex_Space(); test_report.tests[i++] = test_Char_Hex_Space();

48
SLS_Tests/cases.yaml
View File

@ -2317,18 +2317,6 @@
stack_final: stack_final:
- type: char - type: char
value: '}' value: '}'
- name: Char Escape Tab
code: '''\\t'''
tokens:
- type: char
value: "\t"
operations:
- function: push
type: char
value: "\t"
stack_final:
- type: char
value: "\t"
- name: Char Escape Null character - name: Char Escape Null character
code: '''\\0''' code: '''\\0'''
tokens: tokens:
@ -2371,18 +2359,6 @@
value: ' value: '
' '
- name: Char Escape Backslash
code: '''\\\\'''
tokens:
- type: char
value: \
operations:
- function: push
type: char
value: \
stack_final:
- type: char
value: \
- name: Char Escape Single quote - name: Char Escape Single quote
code: '''\\''''' code: '''\\'''''
tokens: tokens:
@ -2395,6 +2371,30 @@
stack_final: stack_final:
- type: char - type: char
value: '''' value: ''''
- name: Char Escape Backslash
code: '''\\\\'''
tokens:
- type: char
value: \
operations:
- function: push
type: char
value: \
stack_final:
- type: char
value: \
- name: Char Escape Tab
code: '''\\t'''
tokens:
- type: char
value: "\t"
operations:
- function: push
type: char
value: "\t"
stack_final:
- type: char
value: "\t"
- name: Char Hex Lowercase A - name: Char Hex Lowercase A
code: '''\\x61''' code: '''\\x61'''
tokens: tokens:

231
SLS_Tests/yaml_to_c_tests.py
View File

@ -83,162 +83,149 @@ def _token_to_c_call(token: dict, idx_var="i") -> str:
elif ttype == "bool": elif ttype == "bool":
return f'test_boolean_value(&test, result, {idx_var}++, &(Boolean){{{"TRUE" if value else "FALSE"}}})' # type: ignore return f'test_boolean_value(&test, result, {idx_var}++, &(Boolean){{{"TRUE" if value else "FALSE"}}})' # type: ignore
elif ttype == "error": elif ttype == "error":
return f'test_for_error(&test, result, i++, SLS_STR("{c_string_literal(value)}"))' # type: ignore return f'test_for_error(&test, result, i++, &SLS_STR("{c_string_literal(value)}"))' # type: ignore
elif ttype == "token_string": elif ttype == "token_string":
return _token_string_c_call(token, idx_var, value) # type: ignore return _token_string_c_call(idx_var, value) # type: ignore
else: else:
raise ValueError(f' Unhandled token type: {ttype}') raise ValueError(f' Unhandled token type: {ttype}')
def _token_string_c_call(token: dict, idx_var: str, value: list[dict]) -> str: def _token_string_c_call(idx_var: str, value: list[dict]) -> str:
"""Generate C code for testing a token string value.""" """Generate C code for testing a token string value."""
# Build the array of TestTokenValue structures if not value: # Empty token string
token_values = [] return (
f'test_token_string_value(&test, result, {idx_var}++, '
f'&(TestTokenStringValue){{0, NULL}})'
)
# Generate token handler calls for each token in the string
token_handlers = []
for i, inner_token in enumerate(value):
inner_type = inner_token.get("type")
inner_value = inner_token.get("value")
# Determine the handler function and value initialization
if inner_type == "i64":
handler = "test_integer_value"
val_init = f'&(TestIntegerValue){{INTEGER_I64, {inner_value}}}'
elif inner_type == "i32":
handler = "test_integer_value"
val_init = f'&(TestIntegerValue){{INTEGER_I32, {inner_value}}}'
elif inner_type == "i16":
handler = "test_integer_value"
val_init = f'&(TestIntegerValue){{INTEGER_I16, {inner_value}}}'
elif inner_type == "i8":
handler = "test_integer_value"
val_init = f'&(TestIntegerValue){{INTEGER_I8, {inner_value}}}'
elif inner_type == "u64":
handler = "test_integer_value"
val_init = f'&(TestIntegerValue){{INTEGER_U64, {inner_value}}}'
elif inner_type == "u32":
handler = "test_integer_value"
val_init = f'&(TestIntegerValue){{INTEGER_U32, {inner_value}}}'
elif inner_type == "u16":
handler = "test_integer_value"
val_init = f'&(TestIntegerValue){{INTEGER_U16, {inner_value}}}'
elif inner_type == "u8":
handler = "test_integer_value"
val_init = f'&(TestIntegerValue){{INTEGER_U8, {inner_value}}}'
elif inner_type == "f64":
handler = "test_double_value"
val_init = f'&(double){{{inner_value}}}'
elif inner_type == "f32":
handler = "test_float_value"
val_init = f'&(float){{{inner_value}}}'
elif inner_type == "char":
handler = "test_character_value"
val_init = f'&(uint8_t){{{ord(inner_value)}}}' # type: ignore
elif inner_type == "string":
handler = "test_string_value"
val_init = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
elif inner_type == "identifier":
handler = "test_identifier_value"
val_init = f'&(TestIdentifierValue){{FALSE, SLS_STR("{inner_value}")}}'
elif inner_type == "identifier_literal":
handler = "test_identifier_value"
val_init = f'&(TestIdentifierValue){{TRUE, SLS_STR("{inner_value}")}}'
elif inner_type == "bool":
handler = "test_boolean_value"
val_init = f'&(Boolean){{{"TRUE" if inner_value else "FALSE"}}}'
elif inner_type == "error":
handler = "test_for_error"
val_init = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
elif inner_type == "token_string":
# Nested token string - recursive call
handler = "test_token_string_value"
val_init = _token_string_value_init(inner_token.get("value", []))
else:
raise ValueError(f'Unhandled token type in token string: {inner_type}')
token_handlers.append(
f'{{(Boolean (*)(LexerTest *, LexerResult, size_t, void *)){handler}, '
f'{val_init}}}'
)
# Generate the array initialization
tokens_array = f'(TestTokenStringToken[]){{{", ".join(token_handlers)}}}'
return (
f'test_token_string_value(&test, result, {idx_var}++, '
f'&(TestTokenStringValue){{{len(value)}, {tokens_array}}})'
)
def _token_string_value_init(value: list[dict]) -> str:
"""Generate initialization code for a TestTokenStringValue (for nested token strings)."""
if not value:
return '&(TestTokenStringValue){0, NULL}'
token_handlers = []
for inner_token in value: for inner_token in value:
inner_type = inner_token.get("type") inner_type = inner_token.get("type")
inner_value = inner_token.get("value") inner_value = inner_token.get("value")
# Map token types to their C test handler and value structure
if inner_type == "i64": if inner_type == "i64":
handler = "test_integer_value" handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_I64, {inner_value}}}" val_init = f'&(TestIntegerValue){{INTEGER_I64, {inner_value}}}'
elif inner_type == "i32": elif inner_type == "i32":
handler = "test_integer_value" handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_I32, {inner_value}}}" val_init = f'&(TestIntegerValue){{INTEGER_I32, {inner_value}}}'
elif inner_type == "i16":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_I16, {inner_value}}}"
elif inner_type == "i8":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_I8, {inner_value}}}"
elif inner_type == "u64":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_U64, {inner_value}}}"
elif inner_type == "u32":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_U32, {inner_value}}}"
elif inner_type == "u16":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_U16, {inner_value}}}"
elif inner_type == "u8":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_U8, {inner_value}}}"
elif inner_type == "f64": elif inner_type == "f64":
handler = "test_double_value" handler = "test_double_value"
value_struct = f"&(double){{{inner_value}}}" val_init = f'&(double){{{inner_value}}}'
elif inner_type == "f32": elif inner_type == "f32":
handler = "test_float_value" handler = "test_float_value"
value_struct = f"&(float){{{inner_value}}}" val_init = f'&(float){{{inner_value}}}'
elif inner_type == "char": elif inner_type == "char":
handler = "test_character_value" handler = "test_character_value"
value_struct = f"&(uint8_t){{{ord(inner_value)}}}" # type: ignore val_init = f'&(uint8_t){{{ord(inner_value)}}}' # type: ignore
elif inner_type == "string": elif inner_type == "string":
handler = "test_string_value" handler = "test_string_value"
value_struct = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore val_init = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
elif inner_type == "identifier": elif inner_type == "identifier":
handler = "test_identifier_value" handler = "test_identifier_value"
value_struct = f'&(TestIdentifierValue){{FALSE, SLS_STR("{inner_value}")}}' val_init = f'&(TestIdentifierValue){{FALSE, SLS_STR("{inner_value}")}}'
elif inner_type == "identifier_literal": elif inner_type == "identifier_literal":
handler = "test_identifier_value" handler = "test_identifier_value"
value_struct = f'&(TestIdentifierValue){{TRUE, SLS_STR("{inner_value}")}}' val_init = f'&(TestIdentifierValue){{TRUE, SLS_STR("{inner_value}")}}'
elif inner_type == "bool": elif inner_type == "bool":
handler = "test_boolean_value" handler = "test_boolean_value"
bool_str = "TRUE" if inner_value else "FALSE" val_init = f'&(Boolean){{{"TRUE" if inner_value else "FALSE"}}}'
value_struct = f"&(Boolean){{{bool_str}}}"
elif inner_type == "error": elif inner_type == "error":
handler = "test_for_error" handler = "test_for_error"
value_struct = f'SLS_STR("{c_string_literal(inner_value)}")' # type: ignore val_init = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
elif inner_type == "token_string": elif inner_type == "token_string":
# Recursive case: nested token string
handler = "test_token_string_value" handler = "test_token_string_value"
nested_tokens = inner_value if isinstance(inner_value, list) else [] val_init = _token_string_value_init(inner_token.get("value", []))
value_struct = _build_token_string_value_struct(nested_tokens) # Add other types as needed
else: else:
raise ValueError(f'Unhandled inner token type in token_string: {inner_type}') raise ValueError(f'Unhandled token type in nested token string: {inner_type}')
token_values.append(f"{{.token_handler = {handler}, .value = {value_struct}}}") token_handlers.append(
f'{{(Boolean (*)(LexerTest *, LexerResult, size_t, void *)){handler}, '
f'{val_init}}}'
)
# Generate the TestTokenStringValue initialization tokens_array = f'(TestTokenStringToken[]){{{", ".join(token_handlers)}}}'
num_tokens = len(value) return f'&(TestTokenStringValue){{{len(value)}, {tokens_array}}}'
if num_tokens == 0:
# Empty token string
return f'test_token_string_value(&test, result, {idx_var}, &(TestTokenStringValue){{0, NULL}})'
else:
# Token string with values
values_array = f"(TestTokenValue[]){{{', '.join(token_values)}}}"
return f'test_token_string_value(&test, result, {idx_var}, &(TestTokenStringValue){{{num_tokens}, {values_array}}})'
def _build_token_string_value_struct(nested_tokens: list[dict]) -> str:
"""Helper to build a TestTokenStringValue structure for nested token strings."""
if not nested_tokens:
return "&(TestTokenStringValue){0, NULL}"
token_values = []
for inner_token in nested_tokens:
inner_type = inner_token.get("type")
inner_value = inner_token.get("value")
if inner_type == "i64":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_I64, {inner_value}}}"
elif inner_type == "i32":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_I32, {inner_value}}}"
elif inner_type == "i16":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_I16, {inner_value}}}"
elif inner_type == "i8":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_I8, {inner_value}}}"
elif inner_type == "u64":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_U64, {inner_value}}}"
elif inner_type == "u32":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_U32, {inner_value}}}"
elif inner_type == "u16":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_U16, {inner_value}}}"
elif inner_type == "u8":
handler = "test_integer_value"
value_struct = f"&(TestIntegerValue){{INTEGER_U8, {inner_value}}}"
elif inner_type == "f64":
handler = "test_double_value"
value_struct = f"&(double){{{inner_value}}}"
elif inner_type == "f32":
handler = "test_float_value"
value_struct = f"&(float){{{inner_value}}}"
elif inner_type == "char":
handler = "test_character_value"
value_struct = f"&(uint8_t){{{ord(inner_value)}}}" # type: ignore
elif inner_type == "string":
handler = "test_string_value"
value_struct = f'&SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
elif inner_type == "identifier":
handler = "test_identifier_value"
value_struct = f'&(TestIdentifierValue){{FALSE, SLS_STR("{inner_value}")}}'
elif inner_type == "identifier_literal":
handler = "test_identifier_value"
value_struct = f'&(TestIdentifierValue){{TRUE, SLS_STR("{inner_value}")}}'
elif inner_type == "bool":
handler = "test_boolean_value"
bool_str = "TRUE" if inner_value else "FALSE"
value_struct = f"&(Boolean){{{bool_str}}}"
elif inner_type == "error":
handler = "test_for_error"
value_struct = f'SLS_STR("{c_string_literal(inner_value)}")' # type: ignore
elif inner_type == "token_string":
# Recursive case
handler = "test_token_string_value"
value_struct = _build_token_string_value_struct(inner_value if isinstance(inner_value, list) else [])
else:
raise ValueError(f'Unhandled nested token type in token_string: {inner_type}')
token_values.append(f"{{.token_handler = {handler}, .value = {value_struct}}}")
num_tokens = len(nested_tokens)
values_array = f"(TestTokenValue[]){{{', '.join(token_values)}}}"
return f"&(TestTokenStringValue){{{num_tokens}, {values_array}}}"
def token_to_c_call(token: dict, idx_var="i") -> str: def token_to_c_call(token: dict, idx_var="i") -> str:
"""Generate a C 'test_*_value' call based on token type.""" """Generate a C 'test_*_value' call based on token type."""