From dbd539fb7612746e158a3aa25263d0e97de72a08 Mon Sep 17 00:00:00 2001 From: sofia Date: Fri, 25 Jul 2025 00:14:03 +0300 Subject: [PATCH] Improve typed literal parsing somewhat --- reid/src/ast/parse.rs | 105 ++++++++++++++++++++++++------------------ 1 file changed, 61 insertions(+), 44 deletions(-) diff --git a/reid/src/ast/parse.rs b/reid/src/ast/parse.rs index 2720c28..5e70e1f 100644 --- a/reid/src/ast/parse.rs +++ b/reid/src/ast/parse.rs @@ -96,30 +96,69 @@ impl Parse for UnaryOperator { } } +fn specific_float_lit(value: f64, stream: &mut TokenStream) -> Result { + use ExpressionKind as Kind; + + let specific_lit = if let Ok(ty) = stream.parse::() { + dbg!(&ty); + match ty.0 { + TypeKind::F16 => Some(SpecificLiteral::F16(value as f32)), + TypeKind::F32 => Some(SpecificLiteral::F32(value as f32)), + TypeKind::F32B => Some(SpecificLiteral::F32B(value as f32)), + TypeKind::F64 => Some(SpecificLiteral::F64(value as f64)), + TypeKind::F128 => Some(SpecificLiteral::F128(value as f64)), + TypeKind::F80 => Some(SpecificLiteral::F80(value as f64)), + TypeKind::F128PPC => Some(SpecificLiteral::F128PPC(value as f64)), + TypeKind::Array(..) => None, + TypeKind::Ptr(..) => None, + TypeKind::Custom(..) => None, + TypeKind::Borrow(..) => None, + _ => return Err(stream.expected_err("integer-compatible type")?), + } + } else { + None + }; + Ok(if let Some(lit) = specific_lit { + Expression( + Kind::Literal(Literal::Specific(lit)), + stream.get_range().unwrap(), + ) + } else { + Expression( + Kind::Literal(Literal::Decimal(value)), + stream.get_range().unwrap(), + ) + }) +} + fn specific_int_lit(value: u128, stream: &mut TokenStream) -> Result { use ExpressionKind as Kind; let specific_lit = if let Ok(ty) = stream.parse::() { - Some(match ty.0 { - TypeKind::I8 => SpecificLiteral::I8(value as i8), - TypeKind::I16 => SpecificLiteral::I16(value as i16), - TypeKind::I32 => SpecificLiteral::I32(value as i32), - TypeKind::I64 => SpecificLiteral::I64(value as i64), - TypeKind::I128 => SpecificLiteral::I128(value as i128), - TypeKind::U8 => SpecificLiteral::U8(value as u8), - TypeKind::U16 => SpecificLiteral::U16(value as u16), - TypeKind::U32 => SpecificLiteral::U32(value as u32), - TypeKind::U64 => SpecificLiteral::U64(value as u64), - TypeKind::U128 => SpecificLiteral::U128(value as u128), - TypeKind::F16 => SpecificLiteral::F16(value as f32), - TypeKind::F32 => SpecificLiteral::F32(value as f32), - TypeKind::F32B => SpecificLiteral::F32B(value as f32), - TypeKind::F64 => SpecificLiteral::F64(value as f64), - TypeKind::F128 => SpecificLiteral::F128(value as f64), - TypeKind::F80 => SpecificLiteral::F80(value as f64), - TypeKind::F128PPC => SpecificLiteral::F128PPC(value as f64), + match ty.0 { + TypeKind::I8 => Some(SpecificLiteral::I8(value as i8)), + TypeKind::I16 => Some(SpecificLiteral::I16(value as i16)), + TypeKind::I32 => Some(SpecificLiteral::I32(value as i32)), + TypeKind::I64 => Some(SpecificLiteral::I64(value as i64)), + TypeKind::I128 => Some(SpecificLiteral::I128(value as i128)), + TypeKind::U8 => Some(SpecificLiteral::U8(value as u8)), + TypeKind::U16 => Some(SpecificLiteral::U16(value as u16)), + TypeKind::U32 => Some(SpecificLiteral::U32(value as u32)), + TypeKind::U64 => Some(SpecificLiteral::U64(value as u64)), + TypeKind::U128 => Some(SpecificLiteral::U128(value as u128)), + TypeKind::F16 => Some(SpecificLiteral::F16(value as f32)), + TypeKind::F32 => Some(SpecificLiteral::F32(value as f32)), + TypeKind::F32B => Some(SpecificLiteral::F32B(value as f32)), + TypeKind::F64 => Some(SpecificLiteral::F64(value as f64)), + TypeKind::F128 => Some(SpecificLiteral::F128(value as f64)), + TypeKind::F80 => Some(SpecificLiteral::F80(value as f64)), + TypeKind::F128PPC => Some(SpecificLiteral::F128PPC(value as f64)), + TypeKind::Array(..) => None, + TypeKind::Ptr(..) => None, + TypeKind::Custom(..) => None, + TypeKind::Borrow(..) => None, _ => return Err(stream.expected_err("integer-compatible type")?), - }) + } } else { None }; @@ -227,31 +266,9 @@ impl Parse for PrimaryExpression { .parse() .expect("Decimal is not parseable as f64!"); - let specific_lit = if let Ok(ty) = stream.parse::() { - Some(match ty.0 { - TypeKind::F16 => SpecificLiteral::F16(value as f32), - TypeKind::F32B => SpecificLiteral::F32B(value as f32), - TypeKind::F32 => SpecificLiteral::F32(value as f32), - TypeKind::F64 => SpecificLiteral::F64(value), - TypeKind::F80 => SpecificLiteral::F80(value), - TypeKind::F128 => SpecificLiteral::F128(value), - TypeKind::F128PPC => SpecificLiteral::F128PPC(value), - _ => return Err(stream.expected_err("float-compatible type")?), - }) - } else { - None - }; - if let Some(lit) = specific_lit { - Expression( - Kind::Literal(Literal::Specific(lit)), - stream.get_range().unwrap(), - ) - } else { - Expression( - Kind::Literal(Literal::Decimal(value)), - stream.get_range().unwrap(), - ) - } + let a = specific_float_lit(value, &mut stream)?; + dbg!(&a); + a } else { specific_int_lit( u128::from_str_radix(&v, 10)