teascade/reid-llvm
1
0
Fork 0
Code Issues Pull Requests Packages Releases 3 Wiki Activity

Improve typed literal parsing somewhat

Browse Source
This commit is contained in:
Sofia 2025-07-25 00:14:03 +03:00
parent f2ea749566
commit dbd539fb76
1 changed files with 61 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

105
reid/src/ast/parse.rs
View File

@ -96,30 +96,69 @@ impl Parse for UnaryOperator {
} }
} }
fn specific_float_lit(value: f64, stream: &mut TokenStream) -> Result<Expression, Error> {
use ExpressionKind as Kind;
let specific_lit = if let Ok(ty) = stream.parse::<Type>() {
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<Expression, Error> { fn specific_int_lit(value: u128, stream: &mut TokenStream) -> Result<Expression, Error> {
use ExpressionKind as Kind; use ExpressionKind as Kind;
let specific_lit = if let Ok(ty) = stream.parse::<Type>() { let specific_lit = if let Ok(ty) = stream.parse::<Type>() {
Some(match ty.0 { match ty.0 {
TypeKind::I8 => SpecificLiteral::I8(value as i8), TypeKind::I8 => Some(SpecificLiteral::I8(value as i8)),
TypeKind::I16 => SpecificLiteral::I16(value as i16), TypeKind::I16 => Some(SpecificLiteral::I16(value as i16)),
TypeKind::I32 => SpecificLiteral::I32(value as i32), TypeKind::I32 => Some(SpecificLiteral::I32(value as i32)),
TypeKind::I64 => SpecificLiteral::I64(value as i64), TypeKind::I64 => Some(SpecificLiteral::I64(value as i64)),
TypeKind::I128 => SpecificLiteral::I128(value as i128), TypeKind::I128 => Some(SpecificLiteral::I128(value as i128)),
TypeKind::U8 => SpecificLiteral::U8(value as u8), TypeKind::U8 => Some(SpecificLiteral::U8(value as u8)),
TypeKind::U16 => SpecificLiteral::U16(value as u16), TypeKind::U16 => Some(SpecificLiteral::U16(value as u16)),
TypeKind::U32 => SpecificLiteral::U32(value as u32), TypeKind::U32 => Some(SpecificLiteral::U32(value as u32)),
TypeKind::U64 => SpecificLiteral::U64(value as u64), TypeKind::U64 => Some(SpecificLiteral::U64(value as u64)),
TypeKind::U128 => SpecificLiteral::U128(value as u128), TypeKind::U128 => Some(SpecificLiteral::U128(value as u128)),
TypeKind::F16 => SpecificLiteral::F16(value as f32), TypeKind::F16 => Some(SpecificLiteral::F16(value as f32)),
TypeKind::F32 => SpecificLiteral::F32(value as f32), TypeKind::F32 => Some(SpecificLiteral::F32(value as f32)),
TypeKind::F32B => SpecificLiteral::F32B(value as f32), TypeKind::F32B => Some(SpecificLiteral::F32B(value as f32)),
TypeKind::F64 => SpecificLiteral::F64(value as f64), TypeKind::F64 => Some(SpecificLiteral::F64(value as f64)),
TypeKind::F128 => SpecificLiteral::F128(value as f64), TypeKind::F128 => Some(SpecificLiteral::F128(value as f64)),
TypeKind::F80 => SpecificLiteral::F80(value as f64), TypeKind::F80 => Some(SpecificLiteral::F80(value as f64)),
TypeKind::F128PPC => SpecificLiteral::F128PPC(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")?), _ => return Err(stream.expected_err("integer-compatible type")?),
}) }
} else { } else {
None None
}; };
@ -227,31 +266,9 @@ impl Parse for PrimaryExpression {
.parse() .parse()
.expect("Decimal is not parseable as f64!"); .expect("Decimal is not parseable as f64!");
let specific_lit = if let Ok(ty) = stream.parse::<Type>() { let a = specific_float_lit(value, &mut stream)?;
Some(match ty.0 { dbg!(&a);
TypeKind::F16 => SpecificLiteral::F16(value as f32), a
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(),
)
}
} else { } else {
specific_int_lit( specific_int_lit(
u128::from_str_radix(&v, 10) u128::from_str_radix(&v, 10)