Worked on numeric literal parsing

SLS_C/src/lexer.c

@@ -9,6 +9,7 @@
 #include <stddef.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <math.h>
 
 #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);
+        if (c == 'b' || c == 'B') {
-        else if (c == 'o' || c == 'O') return parse_octal_integer(lexer_info, c, start, start_line);
+            c = advance(lexer_info);
-        else if (c == 'x' || c == 'X') return parse_hexadecimal_integer(lexer_info, c, start, start_line);
+            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);
 }

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

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:

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."""