From b52a0481cfa3e1fcb1c3a9aa7fcfde5a9052df49 Mon Sep 17 00:00:00 2001 From: LunaStev Date: Sat, 13 Dec 2025 22:07:49 +0900 Subject: [PATCH] refactor: remove unsupported extended float types (f128-f1024) Remove f128, f256, f512, and f1024 float types from lexer and parser as they are not supported by LLVM's standard code generation. Changes: - Remove extended float type variants from FloatType enum: - Delete F128, F256, F512, F1024 enum variants - Keep only F32 and F64 (standard IEEE 754 formats) - Remove lexer tokenization for extended floats: - Delete keyword matching for "f128", "f256", "f512", "f1024" - Simplify lexer identifier classification logic - Remove parser type conversion for extended floats: - Delete FloatType::F{128,256,512,1024} match arms - Keep only standard 32-bit and 64-bit float conversion - Update test suite with realistic integer type tests: - test67.wave: Demonstrate i8, u8, i32, u32, i128, u128 usage - test68.wave: Show i1024 bit shifting (arbitrary precision int) - test69.wave: Test i1024 overflow behavior with large values Rationale: LLVM's core code generator only supports f32 (float) and f64 (double) natively. Extended precision floats (f128, f256, etc.) would require: - Custom soft-float library implementations - Complex runtime support for arithmetic operations - Platform-specific ABI considerations Wave focuses on standard IEEE 754 floats for portability and LLVM compatibility. Arbitrary precision integers (i1024, etc.) remain supported through LLVM's APInt infrastructure. Users requiring extended float precision should use external libraries or explicit soft-float implementations rather than built-in types. Signed-off-by: LunaStev --- front/lexer/src/lexer/lexer.rs | 20 -------------------- front/lexer/src/lexer/token.rs | 4 ---- front/parser/src/parser/parser.rs | 4 ---- test/test67.wave | 17 +++++++++++++++++ test/test68.wave | 12 ++++++++++++ test/test69.wave | 14 ++++++++++++++ 6 files changed, 43 insertions(+), 28 deletions(-) create mode 100644 test/test67.wave create mode 100644 test/test68.wave create mode 100644 test/test69.wave diff --git a/front/lexer/src/lexer/lexer.rs b/front/lexer/src/lexer/lexer.rs index fa5a3036..57234889 100644 --- a/front/lexer/src/lexer/lexer.rs +++ b/front/lexer/src/lexer/lexer.rs @@ -854,26 +854,6 @@ impl<'a> Lexer<'a> { lexeme: "f64".to_string(), line: self.line, }, - "f128" => Token { - token_type: TokenType::TokenTypeFloat(FloatType::F128), - lexeme: "f128".to_string(), - line: self.line, - }, - "f256" => Token { - token_type: TokenType::TokenTypeFloat(FloatType::F256), - lexeme: "f256".to_string(), - line: self.line, - }, - "f512" => Token { - token_type: TokenType::TokenTypeFloat(FloatType::F512), - lexeme: "f512".to_string(), - line: self.line, - }, - "f1024" => Token { - token_type: TokenType::TokenTypeFloat(FloatType::F1024), - lexeme: "f1024".to_string(), - line: self.line, - }, "str" => { Token { token_type: TokenType::TypeString, diff --git a/front/lexer/src/lexer/token.rs b/front/lexer/src/lexer/token.rs index af1b0dea..2cf46253 100644 --- a/front/lexer/src/lexer/token.rs +++ b/front/lexer/src/lexer/token.rs @@ -30,10 +30,6 @@ pub enum UnsignedIntegerType { pub enum FloatType { F32, F64, - F128, - F256, - F512, - F1024, } impl fmt::Display for IntegerType { diff --git a/front/parser/src/parser/parser.rs b/front/parser/src/parser/parser.rs index d7f7baee..013d01b5 100644 --- a/front/parser/src/parser/parser.rs +++ b/front/parser/src/parser/parser.rs @@ -173,10 +173,6 @@ pub fn token_type_to_wave_type(token_type: &TokenType) -> Option { TokenType::TokenTypeFloat(float_type) => match float_type { FloatType::F32 => Some(WaveType::Float(32)), FloatType::F64 => Some(WaveType::Float(64)), - FloatType::F128 => Some(WaveType::Float(128)), - FloatType::F256 => Some(WaveType::Float(256)), - FloatType::F512 => Some(WaveType::Float(512)), - FloatType::F1024 => Some(WaveType::Float(1024)), }, TokenType::TypeFloat(bits) => Some(WaveType::Float(*bits)), TokenType::TypeBool => Some(WaveType::Bool), diff --git a/test/test67.wave b/test/test67.wave new file mode 100644 index 00000000..95da87f5 --- /dev/null +++ b/test/test67.wave @@ -0,0 +1,17 @@ +fun main() { + var a8: i8 = 127; + var b8: u8 = 255; + + var a32: i32 = 2147483647; + var b32: u32 = 4294967295; + + var a128: i128 = 170141183460469231731687303715884105727; + var b128: u128 = 340282366920938463463374607431768211455; + + println("i8: {}", a8); + println("u8: {}", b8); + println("i32: {}", a32); + println("u32: {}", b32); + println("i128: {}", a128); + println("u128: {}", b128); +} diff --git a/test/test68.wave b/test/test68.wave new file mode 100644 index 00000000..f9af072e --- /dev/null +++ b/test/test68.wave @@ -0,0 +1,12 @@ +fun main() { + var one: i1024 = 1; + var x: i1024 = one; + + var i: i32 = 0; + while (i < 1023) { + x = x << 1; + i = i + 1; + } + + println("i1024 max-ish: {}", x); +} diff --git a/test/test69.wave b/test/test69.wave new file mode 100644 index 00000000..fb5d89e8 --- /dev/null +++ b/test/test69.wave @@ -0,0 +1,14 @@ +fun main() { + var max: i1024 = 1; + var i: i32 = 0; + + while (i < 1023) { + max = max << 1; + i = i + 1; + } + + println("before overflow: {}", max); + + var overflow = max + 1; + println("after overflow: {}", overflow); +}