diff --git a/SLS_C/include/tests/lexer_test_helpers.h b/SLS_C/include/tests/lexer_test_helpers.h index f58e2c0..79e3997 100644 --- a/SLS_C/include/tests/lexer_test_helpers.h +++ b/SLS_C/include/tests/lexer_test_helpers.h @@ -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_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_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 diff --git a/SLS_C/tests/lexer_test_helpers.c b/SLS_C/tests/lexer_test_helpers.c index b8ffbc3..46e75b1 100644 --- a/SLS_C/tests/lexer_test_helpers.c +++ b/SLS_C/tests/lexer_test_helpers.c @@ -551,13 +551,13 @@ Boolean test_type_tuple_value(LexerTest *test, LexerResult result, size_t i, Tes 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); 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; - } if (sls_str_cmp(head->error.message, error) != 0) { - logic_fail_test(test, result, error_should_be(i + 1, error, head->error)); + } if (sls_str_cmp(head->error.message, *error) != 0) { + logic_fail_test(test, result, error_should_be(i + 1, *error, head->error)); return TRUE; } return FALSE; diff --git a/SLS_C/tests/lexer_tests.c b/SLS_C/tests/lexer_tests.c index decf5b4..52be2d1 100644 --- a/SLS_C/tests/lexer_tests.c +++ b/SLS_C/tests/lexer_tests.c @@ -232,7 +232,7 @@ static TestResult test_Integer_Default_Decimal_with_Commas_Invalid() { 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_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); } @@ -241,7 +241,7 @@ static TestResult test_Integer_Default_Invalid_Characters() { 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_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); } @@ -250,7 +250,7 @@ static TestResult test_Integer_Default_Invalid_Prefix() { 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_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); } @@ -339,7 +339,7 @@ static TestResult test_Integer_i8_Overflow() { 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_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); } @@ -348,7 +348,7 @@ static TestResult test_Integer_i8_Underflow() { 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_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); } @@ -477,7 +477,7 @@ static TestResult test_Integer_i16_Overflow() { 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_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); } @@ -486,7 +486,7 @@ static TestResult test_Integer_i16_Underflow() { 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_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); } @@ -605,7 +605,7 @@ static TestResult test_Integer_i32_Overflow() { 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_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); } @@ -614,7 +614,7 @@ static TestResult test_Integer_i32_Underflow() { 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_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); } @@ -733,7 +733,7 @@ static TestResult test_Integer_i64_Overflow() { 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_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); } @@ -742,7 +742,7 @@ static TestResult test_Integer_i64_Underflow() { 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_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); } @@ -871,7 +871,7 @@ static TestResult test_Integer_u8_Overflow() { 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_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); } @@ -880,7 +880,7 @@ static TestResult test_Integer_u8_Underflow() { 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_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); } @@ -989,7 +989,7 @@ static TestResult test_Integer_u16_Overflow() { 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_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); } @@ -998,7 +998,7 @@ static TestResult test_Integer_u16_Underflow() { 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_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); } @@ -1117,7 +1117,7 @@ static TestResult test_Integer_u32_Overflow() { 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_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); } @@ -1126,7 +1126,7 @@ static TestResult test_Integer_u32_Underflow() { 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_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); } @@ -1255,7 +1255,7 @@ static TestResult test_Integer_u64_Overflow() { 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_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); } @@ -1264,7 +1264,7 @@ static TestResult test_Integer_u64_Underflow() { 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_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); } @@ -1623,7 +1623,7 @@ static TestResult test_Float_Invalid_Multiple_Decimal_Points() { 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_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); } @@ -1632,7 +1632,7 @@ static TestResult test_Float_Invalid_Characters() { 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_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); } @@ -1641,7 +1641,7 @@ static TestResult test_Float_Invalid_Type_Annotation() { 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_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); } @@ -1650,7 +1650,7 @@ static TestResult test_Float_Invalid_Type_Name() { 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_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); } @@ -1659,7 +1659,7 @@ static TestResult test_Float_Invalid_Comma_Separator() { 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_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); } @@ -2073,16 +2073,6 @@ static TestResult test_Char_Right_Brace() { 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() { LexerTest test = start_up_test(SLS_STR("Char Escape Null character"), SLS_STR("'\\0'")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -2113,6 +2103,16 @@ static TestResult test_Char_Escape_Newline() { 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() { LexerTest test = start_up_test(SLS_STR("Char Escape Backslash"), SLS_STR("'\\\\'")); LexerResult result = lexical_analysis(&test.lexer_info); @@ -2123,12 +2123,12 @@ static TestResult test_Char_Escape_Backslash() { 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("'\\''")); +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){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; return pass_test(&test, result); } @@ -2248,7 +2248,7 @@ static TestResult test_Char_Empty_Literal() { 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_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); } @@ -2257,7 +2257,7 @@ static TestResult test_Char_Multiple_Characters() { 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_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); } @@ -2266,7 +2266,7 @@ static TestResult test_Char_Unclosed_Quote() { 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_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); } @@ -2275,7 +2275,7 @@ static TestResult test_Char_Unescaped_Newline() { 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_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); } @@ -2284,7 +2284,7 @@ static TestResult test_Char_Invalid_Escape() { 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_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); } @@ -2293,7 +2293,7 @@ static TestResult test_Char_Hex_Escape_Too_Short() { 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_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); } @@ -2302,7 +2302,7 @@ static TestResult test_Char_Hex_Escape_Too_Long() { 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_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); } @@ -2311,7 +2311,7 @@ static TestResult test_Char_Hex_Invalid_Digit() { 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_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); } @@ -2840,7 +2840,7 @@ static TestResult test_Identifier_Starting_With_Number() { 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_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); } @@ -2859,7 +2859,7 @@ static TestResult test_Identifier_With_Colon() { 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_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); } @@ -2868,7 +2868,7 @@ static TestResult test_Identifier_Double_Colon_Inside() { 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_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); } @@ -2887,7 +2887,7 @@ static TestResult test_Identifier_Literal_Empty() { 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_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); } @@ -3430,7 +3430,7 @@ static TestResult test_TokenString_Empty() { 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_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; return pass_test(&test, result); } @@ -3440,7 +3440,7 @@ static TestResult test_TokenString_Single_Integer() { 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_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; return pass_test(&test, result); } @@ -3450,7 +3450,7 @@ static TestResult test_TokenString_Single_Identifier() { 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_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; return pass_test(&test, result); } @@ -3460,7 +3460,7 @@ static TestResult test_TokenString_Two_Integers() { 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_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; return pass_test(&test, result); } @@ -3470,7 +3470,7 @@ static TestResult test_TokenString_Simple_Expression() { 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_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; return pass_test(&test, result); } @@ -3480,7 +3480,7 @@ static TestResult test_TokenString_Stack_Ops() { 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_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; return pass_test(&test, result); } @@ -3490,7 +3490,7 @@ static TestResult test_TokenString_Integer_Literals() { 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_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; return pass_test(&test, result); } @@ -3500,7 +3500,7 @@ static TestResult test_TokenString_Float_Literals() { 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_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; return pass_test(&test, result); } @@ -3510,7 +3510,7 @@ static TestResult test_TokenString_Char_Literal() { 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_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; return pass_test(&test, result); } @@ -3520,7 +3520,7 @@ static TestResult test_TokenString_Boolean_Literals() { 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_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; return pass_test(&test, result); } @@ -3530,7 +3530,7 @@ static TestResult test_TokenString_Multiple_Identifiers() { 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_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; return pass_test(&test, result); } @@ -3540,7 +3540,7 @@ static TestResult test_TokenString_Identifier_Literals() { 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_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; return pass_test(&test, result); } @@ -3550,7 +3550,7 @@ static TestResult test_TokenString_Mixed_Identifiers() { 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_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; return pass_test(&test, result); } @@ -3560,7 +3560,7 @@ static TestResult test_TokenString_Nested_Single() { 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_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; return pass_test(&test, result); } @@ -3570,7 +3570,7 @@ static TestResult test_TokenString_Nested_With_Others() { 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_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; return pass_test(&test, result); } @@ -3580,7 +3580,7 @@ static TestResult test_TokenString_Multiple_Nested() { 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_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; return pass_test(&test, result); } @@ -3590,7 +3590,7 @@ static TestResult test_TokenString_Double_Nested() { 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_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; return pass_test(&test, result); } @@ -3600,7 +3600,7 @@ static TestResult test_TokenString_Complex_Nesting() { 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_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; return pass_test(&test, result); } @@ -3610,7 +3610,7 @@ static TestResult test_TokenString_No_Whitespace() { 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_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; return pass_test(&test, result); } @@ -3620,7 +3620,7 @@ static TestResult test_TokenString_Extra_Whitespace() { 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_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; return pass_test(&test, result); } @@ -3630,7 +3630,7 @@ static TestResult test_TokenString_Leading_Whitespace_Outside() { 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_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; return pass_test(&test, result); } @@ -3640,7 +3640,7 @@ static TestResult test_TokenString_Trailing_Whitespace_Outside() { 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_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; return pass_test(&test, result); } @@ -3650,7 +3650,7 @@ static TestResult test_TokenString_With_Tabs() { 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_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; return pass_test(&test, result); } @@ -3660,7 +3660,7 @@ static TestResult test_TokenString_Multiline_Simple() { 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_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; return pass_test(&test, result); } @@ -3670,7 +3670,7 @@ static TestResult test_TokenString_Multiline_Multiple() { 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_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; return pass_test(&test, result); } @@ -3680,7 +3680,7 @@ static TestResult test_TokenString_Mixed_Line_Breaks() { 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_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; return pass_test(&test, result); } @@ -3690,7 +3690,7 @@ static TestResult test_TokenString_Indented_Multiline() { 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_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; return pass_test(&test, result); } @@ -3700,7 +3700,7 @@ static TestResult test_TokenString_Comment_End_Of_Line() { 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_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; return pass_test(&test, result); } @@ -3710,7 +3710,7 @@ static TestResult test_TokenString_Multiple_Comments() { 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_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; return pass_test(&test, result); } @@ -3720,7 +3720,7 @@ static TestResult test_TokenString_Comment_Own_Line() { 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_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; return pass_test(&test, result); } @@ -3730,7 +3730,7 @@ static TestResult test_TokenString_Comment_At_Start() { 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_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; return pass_test(&test, result); } @@ -3740,7 +3740,7 @@ static TestResult test_TokenString_Multiple_Comment_Lines() { 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_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; return pass_test(&test, result); } @@ -3750,7 +3750,7 @@ static TestResult test_TokenString_Comments_Nested() { 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_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; return pass_test(&test, result); } @@ -3760,7 +3760,7 @@ static TestResult test_TokenString_Unclosed() { 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_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); } @@ -3769,7 +3769,7 @@ static TestResult test_TokenString_Unclosed_Nested() { 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_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); } @@ -3778,8 +3778,8 @@ static TestResult test_TokenString_Extra_Closing_Brace() { 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_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_for_error(&test, result, i++, SLS_STR("Unexpected closing brace '}' without matching opening brace."))) 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; return pass_test(&test, result); } @@ -3788,7 +3788,7 @@ static TestResult test_TokenString_Only_Closing_Brace() { 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_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); } @@ -3797,7 +3797,7 @@ static TestResult test_TokenString_Error_Inside() { 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_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; return pass_test(&test, result); } @@ -3807,7 +3807,7 @@ static TestResult test_TokenString_Unclosed_String_Inside() { 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_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; return pass_test(&test, result); } @@ -3817,7 +3817,7 @@ static TestResult test_TokenString_Function_Body() { 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_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; return pass_test(&test, result); } @@ -3827,7 +3827,7 @@ static TestResult test_TokenString_Loop_Body() { 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_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; return pass_test(&test, result); } @@ -3837,7 +3837,7 @@ static TestResult test_TokenString_Struct_Fields() { 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_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; return pass_test(&test, result); } @@ -3847,7 +3847,7 @@ static TestResult test_TokenString_Lambda() { 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_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; return pass_test(&test, result); } @@ -3857,7 +3857,7 @@ static TestResult test_TokenString_Array_Map() { 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_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; return pass_test(&test, result); } @@ -3867,7 +3867,7 @@ static TestResult test_TokenString_Conditional_Complex() { 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_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; 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_Left_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_Carriage_return(); 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_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_Uppercase_A(); test_report.tests[i++] = test_Char_Hex_Space(); diff --git a/SLS_Tests/cases.yaml b/SLS_Tests/cases.yaml index 10ca9bb..ce33736 100644 --- a/SLS_Tests/cases.yaml +++ b/SLS_Tests/cases.yaml @@ -2317,18 +2317,6 @@ 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 Escape Null character code: '''\\0''' tokens: @@ -2371,18 +2359,6 @@ 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 code: '''\\''''' tokens: @@ -2395,6 +2371,30 @@ stack_final: - type: char 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 code: '''\\x61''' tokens: diff --git a/SLS_Tests/yaml_to_c_tests.py b/SLS_Tests/yaml_to_c_tests.py index 58d2cac..3c4887d 100644 --- a/SLS_Tests/yaml_to_c_tests.py +++ b/SLS_Tests/yaml_to_c_tests.py @@ -83,162 +83,149 @@ def _token_to_c_call(token: dict, idx_var="i") -> str: elif ttype == "bool": return f'test_boolean_value(&test, result, {idx_var}++, &(Boolean){{{"TRUE" if value else "FALSE"}}})' # type: ignore 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": - return _token_string_c_call(token, idx_var, value) # type: ignore + return _token_string_c_call(idx_var, value) # type: ignore else: 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.""" - # Build the array of TestTokenValue structures - token_values = [] + if not value: # Empty token string + 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: inner_type = inner_token.get("type") inner_value = inner_token.get("value") - # Map token types to their C test handler and value structure if inner_type == "i64": handler = "test_integer_value" - value_struct = f"&(TestIntegerValue){{INTEGER_I64, {inner_value}}}" + val_init = 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}}}" + val_init = f'&(TestIntegerValue){{INTEGER_I32, {inner_value}}}' elif inner_type == "f64": handler = "test_double_value" - value_struct = f"&(double){{{inner_value}}}" + val_init = f'&(double){{{inner_value}}}' elif inner_type == "f32": handler = "test_float_value" - value_struct = f"&(float){{{inner_value}}}" + val_init = f'&(float){{{inner_value}}}' elif inner_type == "char": 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": 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": 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": 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": handler = "test_boolean_value" - bool_str = "TRUE" if inner_value else "FALSE" - value_struct = f"&(Boolean){{{bool_str}}}" + val_init = f'&(Boolean){{{"TRUE" if inner_value else "FALSE"}}}' elif inner_type == "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": - # Recursive case: nested token string handler = "test_token_string_value" - nested_tokens = inner_value if isinstance(inner_value, list) else [] - value_struct = _build_token_string_value_struct(nested_tokens) + val_init = _token_string_value_init(inner_token.get("value", [])) + # Add other types as needed 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 - num_tokens = len(value) - 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}}}" + tokens_array = f'(TestTokenStringToken[]){{{", ".join(token_handlers)}}}' + return f'&(TestTokenStringValue){{{len(value)}, {tokens_array}}}' def token_to_c_call(token: dict, idx_var="i") -> str: """Generate a C 'test_*_value' call based on token type."""