From 329a71ca2454b75ddc34d8263eead9fd6ed50be5 Mon Sep 17 00:00:00 2001 From: Kyler Date: Thu, 6 Nov 2025 22:07:04 -0700 Subject: [PATCH] Worked on numeric literal parsing --- SLS_C/src/lexer.c | 115 ++++++++++++++++++++++++++++++------ SLS_C/tests/lexer_tests.c | 32 +++++----- SLS_Tests/cases.yaml | 32 +++++----- SLS_Tests/generate_tests.py | 4 +- 4 files changed, 130 insertions(+), 53 deletions(-) diff --git a/SLS_C/src/lexer.c b/SLS_C/src/lexer.c index b9e4ee2..a748296 100644 --- a/SLS_C/src/lexer.c +++ b/SLS_C/src/lexer.c @@ -9,6 +9,7 @@ #include #include #include +#include #include "sls/sls_errors.h" #include "sls/lexer.h" @@ -92,6 +93,11 @@ static char far_peek(LexerInfo *lexer_info, size_t index) { return lexer_info->source_code[lexer_info->pos + index]; } +static char seek(LexerInfo *lexer_info, size_t index) { + // Returns the character from the given index from the source code + return lexer_info->source_code[index]; +} + static char advance(LexerInfo *lexer_info) { // Advances lexer_info to the next character if (lexer_info->source_code[lexer_info->pos] == '\n') { @@ -212,7 +218,8 @@ static uint64_t create_binary_integer(LexerInfo *lexer_info, size_t start) { case '1': value += 1; break; } } - return value * (negative ? -1 : 1); + if (negative) value = (~value) + 1; + return value; } static uint64_t create_octal_integer(LexerInfo *lexer_info, size_t start) { @@ -238,7 +245,8 @@ static uint64_t create_octal_integer(LexerInfo *lexer_info, size_t start) { case '7': value += 7; break; } } - return value * (negative ? -1 : 1); + if (negative) value = (~value) + 1; + return value; } static uint64_t create_decimal_integer(LexerInfo *lexer_info, size_t start) { @@ -266,7 +274,8 @@ static uint64_t create_decimal_integer(LexerInfo *lexer_info, size_t start) { case '9': value += 9; break; } } - return value * (negative ? -1 : 1); + if (negative) value = (~value) + 1; + return value; } static uint64_t create_hexadecimal_integer(LexerInfo *lexer_info, size_t start) { @@ -306,7 +315,68 @@ static uint64_t create_hexadecimal_integer(LexerInfo *lexer_info, size_t start) case 'f': value += 15; break; } } - return value * (negative ? -1 : 1); + if (negative) value = (~value) + 1; + return value; +} + +static LexerResult create_integer_token(LexerInfo *lexer_info, IntegerBuiltInType type, uint64_t value, size_t start, size_t start_line) { + switch (type) { + case INTEGER_I32: + if (value > (uint64_t)UINT32_MAX) { + char *error_message = (char *)malloc(sizeof(char) * 47); + strncpy(error_message, "Integer overflow: value exceeds range for i32.", 47); + return lexer_error(lexer_info, error_message, start, start_line); + } + break; + case INTEGER_I16: + if (value > (uint64_t)UINT16_MAX) { + char *error_message = (char *)malloc(sizeof(char) * 47); + strncpy(error_message, "Integer overflow: value exceeds range for i16.", 47); + return lexer_error(lexer_info, error_message, start, start_line); + } + break; + case INTEGER_I8: + if (value > (uint64_t)UINT8_MAX) { + char *error_message = (char *)malloc(sizeof(char) * 46); + strncpy(error_message, "Integer overflow: value exceeds range for i8.", 46); + return lexer_error(lexer_info, error_message, start, start_line); + } + break; + case INTEGER_U32: + if (seek(lexer_info, start) == '-') { + char *error_message = (char *)malloc(sizeof(char) * 48); + strncpy(error_message, "Integer overflow: value exceeds range for u32.", 48); + return lexer_error(lexer_info, error_message, start, start_line); + } if (value > (uint64_t)UINT32_MAX) { + char *error_message = (char *)malloc(sizeof(char) * 47); + strncpy(error_message, "Integer overflow: value exceeds range for u32.", 47); + return lexer_error(lexer_info, error_message, start, start_line); + } + break; + case INTEGER_U16: + if (seek(lexer_info, start) == '-') { + char *error_message = (char *)malloc(sizeof(char) * 48); + strncpy(error_message, "Integer overflow: value exceeds range for u16.", 48); + return lexer_error(lexer_info, error_message, start, start_line); + } if (value > (uint64_t)UINT16_MAX) { + char *error_message = (char *)malloc(sizeof(char) * 47); + strncpy(error_message, "Integer overflow: value exceeds range for u16.", 47); + return lexer_error(lexer_info, error_message, start, start_line); + } + break; + case INTEGER_U8: + if (seek(lexer_info, start) == '-') { + char *error_message = (char *)malloc(sizeof(char) * 47); + strncpy(error_message, "Integer overflow: value exceeds range for u8.", 47); + return lexer_error(lexer_info, error_message, start, start_line); + } if (value > (uint64_t)UINT8_MAX) { + char *error_message = (char *)malloc(sizeof(char) * 46); + strncpy(error_message, "Integer overflow: value exceeds range for u8.", 46); + return lexer_error(lexer_info, error_message, start, start_line); + } + break; + } + return lexer_result(lexer_info, (Token){TOKEN_INTEGER, .integer_literal = (IntegerLiteral){.type = type, .value = value}}, start, start_line); } typedef enum { @@ -391,19 +461,19 @@ static LexerResult parse_numeric_type(LexerInfo *lexer_info, char c, size_t star case NUMERIC_BINARY: if (integer_type.type == SLS_ERROR) return (LexerResult){SLS_ERROR, .error = integer_type.error}; value = create_binary_integer(lexer_info, start); - return lexer_result(lexer_info, (Token){TOKEN_INTEGER, .integer_literal = (IntegerLiteral){.type = integer_type.integer_type, .value = value}}, start, start_line); + return create_integer_token(lexer_info, integer_type.integer_type, value, start, start_line); case NUMERIC_OCTAL: if (integer_type.type == SLS_ERROR) return (LexerResult){SLS_ERROR, .error = integer_type.error}; value = create_octal_integer(lexer_info, start); - return lexer_result(lexer_info, (Token){TOKEN_INTEGER, .integer_literal = (IntegerLiteral){.type = integer_type.integer_type, .value = value}}, start, start_line); + return create_integer_token(lexer_info, integer_type.integer_type, value, start, start_line); case NUMERIC_DECIMAL: if (integer_type.type == SLS_ERROR) return (LexerResult){SLS_ERROR, .error = integer_type.error}; value = create_decimal_integer(lexer_info, start); - return lexer_result(lexer_info, (Token){TOKEN_INTEGER, .integer_literal = (IntegerLiteral){.type = integer_type.integer_type, .value = value}}, start, start_line); + return create_integer_token(lexer_info, integer_type.integer_type, value, start, start_line); case NUMERIC_HEXADECIMAL: if (integer_type.type == SLS_ERROR) return (LexerResult){SLS_ERROR, .error = integer_type.error}; value = create_hexadecimal_integer(lexer_info, start); - return lexer_result(lexer_info, (Token){TOKEN_INTEGER, .integer_literal = (IntegerLiteral){.type = integer_type.integer_type, .value = value}}, start, start_line); + return create_integer_token(lexer_info, integer_type.integer_type, value, start, start_line); case NUMERIC_FLOAT: break; case NUMERIC_EXPONENTIAL: @@ -417,11 +487,11 @@ static LexerResult parse_numeric_type(LexerInfo *lexer_info, char c, size_t star } static LexerResult parse_binary_integer(LexerInfo *lexer_info, char c, size_t start, size_t start_line) { - do {c = advance(lexer_info);} while (c == '0' || c == '1' || c == '_'); + while (c == '0' || c == '1' || c == '_') c = advance(lexer_info); if (c == ':') return parse_numeric_type(lexer_info, c, start, start_line, NUMERIC_BINARY); if (isspace(c) || c == '/' || c == '\0') { uint64_t value = create_binary_integer(lexer_info, start); - return lexer_result(lexer_info, (Token){TOKEN_INTEGER, .integer_literal = (IntegerLiteral){.type = INTEGER_I64, .value = value}}, start, start_line); + return create_integer_token(lexer_info, INTEGER_I64, value, start, start_line); } char *error_message = (char *)malloc(sizeof(char) * 58); snprintf(error_message, 58, "Invalid binary literal: unexpected '%c' in binary integer.", c); @@ -429,11 +499,11 @@ static LexerResult parse_binary_integer(LexerInfo *lexer_info, char c, size_t st } static LexerResult parse_octal_integer(LexerInfo *lexer_info, char c, size_t start, size_t start_line) { - do {c = advance(lexer_info);} while ((isdigit(c) || c == '_') && !(c == '8' || c == '9')); + while ((isdigit(c) || c == '_') && !(c == '8' || c == '9')) c = advance(lexer_info); if (c == ':') return parse_numeric_type(lexer_info, c, start, start_line, NUMERIC_OCTAL); if (isspace(c) || c == '/' || c == '\0') { uint64_t value = create_octal_integer(lexer_info, start); - return lexer_result(lexer_info, (Token){TOKEN_INTEGER, .integer_literal = (IntegerLiteral){.type = INTEGER_I64, .value = value}}, start, start_line); + return create_integer_token(lexer_info, INTEGER_I64, value, start, start_line); } char *error_message = (char *)malloc(sizeof(char) * 56); snprintf(error_message, 56, "Invalid octal literal: unexpected '%c' in octal integer.", c); @@ -451,13 +521,13 @@ static LexerResult parse_float(LexerInfo *lexer_info, char c, size_t start, size } static LexerResult parse_decimal_integer(LexerInfo *lexer_info, char c, size_t start, size_t start_line) { - do {c = advance(lexer_info);} while (isdigit(c) || c == '_'); + while (isdigit(c) || c == '_') c = advance(lexer_info); if (c == '.') return parse_float(lexer_info, c, start, start_line); if (c == 'e' || c == 'E') return parse_exponential(lexer_info, c, start, start_line); if (c == ':') return parse_numeric_type(lexer_info, c, start, start_line, NUMERIC_DECIMAL); if (isspace(c) || c == '/' || c == '\0') { uint64_t value = create_decimal_integer(lexer_info, start); - return lexer_result(lexer_info, (Token){TOKEN_INTEGER, .integer_literal = (IntegerLiteral){.type = INTEGER_I64, .value = value}}, start, start_line); + return create_integer_token(lexer_info, INTEGER_I64, value, start, start_line); } char *error_message = (char *)malloc(sizeof(char) * 60); snprintf(error_message, 60, "Invalid decimal literal: unexpected '%c' in decimal integer.", c); @@ -465,11 +535,11 @@ static LexerResult parse_decimal_integer(LexerInfo *lexer_info, char c, size_t s } static LexerResult parse_hexadecimal_integer(LexerInfo *lexer_info, char c, size_t start, size_t start_line) { - do {c = advance(lexer_info);} while (isxdigit(c) || c == '_'); + while (isxdigit(c) || c == '_') c = advance(lexer_info); if (c == ':') return parse_numeric_type(lexer_info, c, start, start_line, NUMERIC_HEXADECIMAL); if (isspace(c) || c == '/' || c == '\0') { uint64_t value = create_hexadecimal_integer(lexer_info, start); - return lexer_result(lexer_info, (Token){TOKEN_INTEGER, .integer_literal = (IntegerLiteral){.type = INTEGER_I64, .value = value}}, start, start_line); + return create_integer_token(lexer_info, INTEGER_I64, value, start, start_line); } char *error_message = (char *)malloc(sizeof(char) * 68); snprintf(error_message, 68, "Invalid hexadecimal literal: unexpected '%c' in hexadecimal integer.", c); @@ -480,9 +550,16 @@ static LexerResult parse_numeric_literal(LexerInfo *lexer_info, char c, size_t s if (c == '-') c = advance(lexer_info); if (c == '0') { c = advance(lexer_info); - if (c == 'b' || c == 'B') return parse_binary_integer(lexer_info, c, start, start_line); - else if (c == 'o' || c == 'O') return parse_octal_integer(lexer_info, c, start, start_line); - else if (c == 'x' || c == 'X') return parse_hexadecimal_integer(lexer_info, c, start, start_line); + if (c == 'b' || c == 'B') { + c = advance(lexer_info); + return parse_binary_integer(lexer_info, c, start, start_line); + } else if (c == 'o' || c == 'O') { + c = advance(lexer_info); + return parse_octal_integer(lexer_info, c, start, start_line); + } else if (c == 'x' || c == 'X') { + c = advance(lexer_info); + return parse_hexadecimal_integer(lexer_info, c, start, start_line); + } } return parse_decimal_integer(lexer_info, c, start, start_line); } diff --git a/SLS_C/tests/lexer_tests.c b/SLS_C/tests/lexer_tests.c index fe68f68..fd2ab5a 100644 --- a/SLS_C/tests/lexer_tests.c +++ b/SLS_C/tests/lexer_tests.c @@ -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++, &(TestErrorMessage){44, "Integer overflow: 128 exceeds range for i8."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){46, "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++, &(TestErrorMessage){46, "Integer underflow: -129 exceeds range for i8."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){46, "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++, &(TestErrorMessage){47, "Integer overflow: 32768 exceeds range for i16."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "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++, &(TestErrorMessage){49, "Integer underflow: -32769 exceeds range for i16."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "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++, &(TestErrorMessage){52, "Integer overflow: 2147483648 exceeds range for i32."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "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++, &(TestErrorMessage){54, "Integer underflow: -2147483649 exceeds range for i32."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "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++, &(TestErrorMessage){61, "Integer overflow: 9223372036854775808 exceeds range for i64."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "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++, &(TestErrorMessage){63, "Integer underflow: -9223372036854775809 exceeds range for i64."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "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++, &(TestErrorMessage){44, "Integer overflow: 256 exceeds range for u8."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){46, "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++, &(TestErrorMessage){44, "Integer underflow: -1 exceeds range for u8."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){46, "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++, &(TestErrorMessage){47, "Integer overflow: 65536 exceeds range for u16."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "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++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u16."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "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++, &(TestErrorMessage){52, "Integer overflow: 4294967296 exceeds range for u32."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "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++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u32."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "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++, &(TestErrorMessage){62, "Integer overflow: 18446744073709551616 exceeds range for u64."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "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++, &(TestErrorMessage){45, "Integer underflow: -1 exceeds range for u64."})) return test.result; + if (test_for_error(&test, result, i++, &(TestErrorMessage){47, "Integer overflow: value exceeds range for u64."})) return test.result; return pass_test(&test, result); } diff --git a/SLS_Tests/cases.yaml b/SLS_Tests/cases.yaml index f545e4b..f303ece 100644 --- a/SLS_Tests/cases.yaml +++ b/SLS_Tests/cases.yaml @@ -356,12 +356,12 @@ code: 128:i8 tokens: - type: error - value: 'Integer overflow: 128 exceeds range for i8.' + value: 'Integer overflow: value exceeds range for i8.' - name: Integer i8 Underflow code: -129:i8 tokens: - type: error - value: 'Integer underflow: -129 exceeds range for i8.' + value: 'Integer overflow: value exceeds range for i8.' - name: Integer i8 Hex Max code: 0x7F:i8 tokens: @@ -510,12 +510,12 @@ code: 32768:i16 tokens: - type: error - value: 'Integer overflow: 32768 exceeds range for i16.' + value: 'Integer overflow: value exceeds range for i16.' - name: Integer i16 Underflow code: -32769:i16 tokens: - type: error - value: 'Integer underflow: -32769 exceeds range for i16.' + value: 'Integer overflow: value exceeds range for i16.' - name: Integer i16 Hex Sample code: 0x1234:i16 tokens: @@ -652,12 +652,12 @@ code: 2147483648:i32 tokens: - type: error - value: 'Integer overflow: 2147483648 exceeds range for i32.' + value: 'Integer overflow: value exceeds range for i32.' - name: Integer i32 Underflow code: -2147483649:i32 tokens: - type: error - value: 'Integer underflow: -2147483649 exceeds range for i32.' + value: 'Integer overflow: value exceeds range for i32.' - name: Integer i32 With Underscores code: 1_000_000:i32 tokens: @@ -794,12 +794,12 @@ code: 9223372036854775808:i64 tokens: - type: error - value: 'Integer overflow: 9223372036854775808 exceeds range for i64.' + value: 'Integer overflow: value exceeds range for i64.' - name: Integer i64 Underflow code: -9223372036854775809:i64 tokens: - type: error - value: 'Integer underflow: -9223372036854775809 exceeds range for i64.' + value: 'Integer overflow: value exceeds range for i64.' - name: Integer i64 With Underscores code: 1_000_000:i64 tokens: @@ -948,12 +948,12 @@ code: 256:u8 tokens: - type: error - value: 'Integer overflow: 256 exceeds range for u8.' + value: 'Integer overflow: value exceeds range for u8.' - name: Integer u8 Underflow code: -1:u8 tokens: - type: error - value: 'Integer underflow: -1 exceeds range for u8.' + value: 'Integer overflow: value exceeds range for u8.' - name: Integer u8 Hex Max code: 0xFF:u8 tokens: @@ -1078,12 +1078,12 @@ code: 65536:u16 tokens: - type: error - value: 'Integer overflow: 65536 exceeds range for u16.' + value: 'Integer overflow: value exceeds range for u16.' - name: Integer u16 Underflow code: -1:u16 tokens: - type: error - value: 'Integer underflow: -1 exceeds range for u16.' + value: 'Integer overflow: value exceeds range for u16.' - name: Integer u16 Hex Max code: 0xFFFF:u16 tokens: @@ -1220,12 +1220,12 @@ code: 4294967296:u32 tokens: - type: error - value: 'Integer overflow: 4294967296 exceeds range for u32.' + value: 'Integer overflow: value exceeds range for u32.' - name: Integer u32 Underflow code: -1:u32 tokens: - type: error - value: 'Integer underflow: -1 exceeds range for u32.' + value: 'Integer overflow: value exceeds range for u32.' - name: Integer u32 With Underscores code: 1_000_000:u32 tokens: @@ -1374,12 +1374,12 @@ code: 18446744073709551616:u64 tokens: - type: error - value: 'Integer overflow: 18446744073709551616 exceeds range for u64.' + value: 'Integer overflow: value exceeds range for u64.' - name: Integer u64 Underflow code: -1:u64 tokens: - type: error - value: 'Integer underflow: -1 exceeds range for u64.' + value: 'Integer overflow: value exceeds range for u64.' - name: Integer u64 With Underscores code: 1_000_000:u64 tokens: diff --git a/SLS_Tests/generate_tests.py b/SLS_Tests/generate_tests.py index e19f140..ba12ce8 100644 --- a/SLS_Tests/generate_tests.py +++ b/SLS_Tests/generate_tests.py @@ -213,13 +213,13 @@ class IntegerTestGenerator: overflow_val = max_val + 1 self.make_error_test(f"Integer {type_name} Overflow", f"{overflow_val}:{type_name}", - f"Integer overflow: {overflow_val} exceeds range for {type_name}.") + f"Integer overflow: value exceeds range for {type_name}.") # Underflow underflow_val = min_val - 1 self.make_error_test(f"Integer {type_name} Underflow", f"{underflow_val}:{type_name}", - f"Integer underflow: {underflow_val} exceeds range for {type_name}.") + f"Integer overflow: value exceeds range for {type_name}.") def generate_special_typed_tests(self, type_name: str): """Generate special tests for specific types."""