From d3039955870786dc52c4c9e71e2ce1a6dbe75cf0 Mon Sep 17 00:00:00 2001 From: Kyler Date: Sun, 23 Nov 2025 23:32:42 -0700 Subject: [PATCH] Adjusted error handling --- SLS_C/Failing Tests.md | 41 ++++++++++++++++++++++++++++++++++++++++ SLS_C/src/lexer.c | 43 +++++++++++++++++++++++++----------------- 2 files changed, 67 insertions(+), 17 deletions(-) create mode 100644 SLS_C/Failing Tests.md diff --git a/SLS_C/Failing Tests.md b/SLS_C/Failing Tests.md new file mode 100644 index 0000000..3c04588 --- /dev/null +++ b/SLS_C/Failing Tests.md @@ -0,0 +1,41 @@ +# Failing Tests + +These tests fail and haven't been fixed yet as they would likely take major +refactoring to fix, which I may not have time to do before finals week. + +## Integer i64 Overflow +code: `9223372036854775808:i64` +error: `Integer overflow: value exceeds range for i64.` + +This test fails because the parsed integer has already overflowed inside the +interpreter, so an integer token is returned with no overflow error detected. + +## Integer i64 Underflow +code: `-9223372036854775809:i64` +error: `Integer overflow: value exceeds range for i64.` + +This test fails because the parsed integer has already overflowed inside the +interpreter, so an integer token is returned with no overflow error detected. + +## Integer u64 Overflow +code: `18446744073709551616:u64` +error: `Integer overflow: value exceeds range for u64.` + +This test fails because the parsed integer has already overflowed inside the +interpreter, so an integer token is returned with no overflow error detected. + +## Integer i16 Binary Sample +code: `0b1111111100000000:i16` +value: `-256` + +This test fails because the interpreter fails to recognize this as a negative +number, and parses is as `65280`, which is greater than the signed 16-bit max of +`32767`, resulting in an overflow error. + +## Float Default No Leading Digit Negative +code: `-.25` +value: `-0.25` + +This test fails because the interpreter fails to recognize a token starting with +both a `-` then a `.` then a digit, as a numeric literal, resulting in it being +interpreted as an identifier. diff --git a/SLS_C/src/lexer.c b/SLS_C/src/lexer.c index 29d27bd..fbd665b 100644 --- a/SLS_C/src/lexer.c +++ b/SLS_C/src/lexer.c @@ -325,40 +325,44 @@ static uint64_t create_hexadecimal_integer(LexerInfo *lexer_info, size_t start) static LexerResult create_integer_token(LexerInfo *lexer_info, IntegerBuiltInType type, uint64_t value, size_t start, size_t start_line) { switch (type) { case INTEGER_I64: break; - case INTEGER_U64: break; case INTEGER_I32: - if (value > (uint64_t)UINT32_MAX) { + if ((int64_t)value < INT32_MIN || (int64_t)value > INT32_MAX) { return lexer_error(lexer_info, SLS_STR("Integer overflow: value exceeds range for i32."), start, start_line); } break; case INTEGER_I16: - if (value > (uint64_t)UINT16_MAX) { + if ((int64_t)value < INT16_MIN || (int64_t)value > INT16_MAX) { return lexer_error(lexer_info, SLS_STR("Integer overflow: value exceeds range for i16."), start, start_line); } break; case INTEGER_I8: - if (value > (uint64_t)UINT8_MAX) { + if ((int64_t)value < INT8_MIN || (int64_t)value > INT8_MAX) { return lexer_error(lexer_info, SLS_STR("Integer overflow: value exceeds range for i8."), start, start_line); } break; + case INTEGER_U64: + if (seek(lexer_info, start) == '-') { + return lexer_error(lexer_info, SLS_STR("Integer overflow: value exceeds range for u64."), start, start_line); + } + break; case INTEGER_U32: if (seek(lexer_info, start) == '-') { return lexer_error(lexer_info, SLS_STR("Integer overflow: value exceeds range for u32."), start, start_line); - } if (value > (uint64_t)UINT32_MAX) { + } else if (value > (uint64_t)UINT32_MAX) { return lexer_error(lexer_info, SLS_STR("Integer overflow: value exceeds range for u32."), start, start_line); } break; case INTEGER_U16: if (seek(lexer_info, start) == '-') { return lexer_error(lexer_info, SLS_STR("Integer overflow: value exceeds range for u16."), start, start_line); - } if (value > (uint64_t)UINT16_MAX) { + } else if (value > (uint64_t)UINT16_MAX) { return lexer_error(lexer_info, SLS_STR("Integer overflow: value exceeds range for u16."), start, start_line); } break; case INTEGER_U8: if (seek(lexer_info, start) == '-') { return lexer_error(lexer_info, SLS_STR("Integer overflow: value exceeds range for u8."), start, start_line); - } if (value > (uint64_t)UINT8_MAX) { + } else if (value > (uint64_t)UINT8_MAX) { return lexer_error(lexer_info, SLS_STR("Integer overflow: value exceeds range for u8."), start, start_line); } break; @@ -741,24 +745,29 @@ static LexerResult lexer_next(LexerInfo *lexer_info) { return parse_character_literal(lexer_info, c, start, start_line); } // String Literals - // if (c == '\"') return parse_string_literal(lexer_info, c, start, start_line); + if (c == '\"') return parse_string_literal(lexer_info, c, start, start_line); // Token Strings if (c == '{') return parse_token_string(lexer_info, c, start, start_line); + if (c == '}') return lexer_error(lexer_info, SLS_STR("Unexpected closing brace '}' without matching opening brace."), start, start_line); // Array Literals - // if (c == '[') return parse_array_literal(lexer_info, c, start, start_line); + if (c == '[') return parse_array_literal(lexer_info, c, start, start_line); + if (c == ']') return lexer_error(lexer_info, SLS_STR("Unexpected closing bracket ']' without matching opening bracket."), start, start_line); // Type Tuples - // if (c == '(') return parse_type_tuples(lexer_info, c, start, start_line); + if (c == '(') return parse_type_tuples(lexer_info, c, start, start_line); + if (c == ')') return lexer_error(lexer_info, SLS_STR("Unexpected closing parentheses ')' without matching opening parentheses."), start, start_line); // Identifiers and Booleans if (is_identifier_start(lexer_info)) return parse_identifiers_and_booleans(lexer_info, c, start, start_line); + if (c == ':') + if (far_peek(lexer_info, 1) == ':') + return lexer_error(lexer_info, SLS_STR("Invalid identifier literal: empty identifier after '::'."), start, start_line); + else + return lexer_error(lexer_info, SLS_STR("Unexpected single colon ':'."), start, start_line); + // Random Characters - if (c == ':' || c == '\"' || c == '[' || c == '(') { - SlsStr error_msg = sls_format(SLS_STR("Unexpected character: unexpected '%c' during parsing."), c); - if (error_msg.str == NULL) return (LexerResult){SLS_ERROR, .error = (SlsError){SLS_STR("Out Of Memory Error."), 1}}; - return lexer_error(lexer_info, error_msg, start, start_line); - } - // Lexing Error - return (LexerResult){SLS_ERROR, .error = (SlsError){SLS_STR("Lexer: Unknown Character Error."), 1}}; + SlsStr error_msg = sls_format(SLS_STR("Unexpected character: unexpected '%c' during parsing."), c); + if (error_msg.str == NULL) return (LexerResult){SLS_ERROR, .error = (SlsError){SLS_STR("Out Of Memory Error."), 1}}; + return lexer_error(lexer_info, error_msg, start, start_line); } void clean_token_result(LexerTokenResult *head) {