| use std::boxed::Box; |
| use std::iter; |
| |
| use super::{lexer, unused, Error, Location, Spanned, SpannedValue, Unused}; |
| |
| pub(super) enum Item<'a> { |
| Literal(Spanned<&'a [u8]>), |
| EscapedBracket { |
| _first: Unused<Location>, |
| _second: Unused<Location>, |
| }, |
| Component { |
| _opening_bracket: Unused<Location>, |
| _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>, |
| name: Spanned<&'a [u8]>, |
| modifiers: Box<[Modifier<'a>]>, |
| _trailing_whitespace: Unused<Option<Spanned<&'a [u8]>>>, |
| _closing_bracket: Unused<Location>, |
| }, |
| Optional { |
| opening_bracket: Location, |
| _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>, |
| _optional_kw: Unused<Spanned<&'a [u8]>>, |
| _whitespace: Unused<Spanned<&'a [u8]>>, |
| nested_format_description: NestedFormatDescription<'a>, |
| closing_bracket: Location, |
| }, |
| First { |
| opening_bracket: Location, |
| _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>, |
| _first_kw: Unused<Spanned<&'a [u8]>>, |
| _whitespace: Unused<Spanned<&'a [u8]>>, |
| nested_format_descriptions: Box<[NestedFormatDescription<'a>]>, |
| closing_bracket: Location, |
| }, |
| } |
| |
| pub(super) struct NestedFormatDescription<'a> { |
| pub(super) _opening_bracket: Unused<Location>, |
| pub(super) items: Box<[Item<'a>]>, |
| pub(super) _closing_bracket: Unused<Location>, |
| pub(super) _trailing_whitespace: Unused<Option<Spanned<&'a [u8]>>>, |
| } |
| |
| pub(super) struct Modifier<'a> { |
| pub(super) _leading_whitespace: Unused<Spanned<&'a [u8]>>, |
| pub(super) key: Spanned<&'a [u8]>, |
| pub(super) _colon: Unused<Location>, |
| pub(super) value: Spanned<&'a [u8]>, |
| } |
| |
| pub(super) fn parse< |
| 'item: 'iter, |
| 'iter, |
| I: Iterator<Item = Result<lexer::Token<'item>, Error>>, |
| const VERSION: u8, |
| >( |
| tokens: &'iter mut lexer::Lexed<I>, |
| ) -> impl Iterator<Item = Result<Item<'item>, Error>> + 'iter { |
| assert!(version!(1..=2)); |
| parse_inner::<_, false, VERSION>(tokens) |
| } |
| |
| fn parse_inner< |
| 'item, |
| I: Iterator<Item = Result<lexer::Token<'item>, Error>>, |
| const NESTED: bool, |
| const VERSION: u8, |
| >( |
| tokens: &mut lexer::Lexed<I>, |
| ) -> impl Iterator<Item = Result<Item<'item>, Error>> + '_ { |
| iter::from_fn(move || { |
| if NESTED && tokens.peek_closing_bracket().is_some() { |
| return None; |
| } |
| |
| let next = match tokens.next()? { |
| Ok(token) => token, |
| Err(err) => return Some(Err(err)), |
| }; |
| |
| Some(match next { |
| lexer::Token::Literal(Spanned { value: _, span: _ }) if NESTED => { |
| bug!("literal should not be present in nested description") |
| } |
| lexer::Token::Literal(value) => Ok(Item::Literal(value)), |
| lexer::Token::Bracket { |
| kind: lexer::BracketKind::Opening, |
| location, |
| } => { |
| if version!(..=1) { |
| if let Some(second_location) = tokens.next_if_opening_bracket() { |
| Ok(Item::EscapedBracket { |
| _first: unused(location), |
| _second: unused(second_location), |
| }) |
| } else { |
| parse_component::<_, VERSION>(location, tokens) |
| } |
| } else { |
| parse_component::<_, VERSION>(location, tokens) |
| } |
| } |
| lexer::Token::Bracket { |
| kind: lexer::BracketKind::Closing, |
| location: _, |
| } if NESTED => { |
| bug!("closing bracket should be caught by the `if` statement") |
| } |
| lexer::Token::Bracket { |
| kind: lexer::BracketKind::Closing, |
| location: _, |
| } => { |
| bug!("closing bracket should have been consumed by `parse_component`") |
| } |
| lexer::Token::ComponentPart { kind: _, value } if NESTED => Ok(Item::Literal(value)), |
| lexer::Token::ComponentPart { kind: _, value: _ } => { |
| bug!("component part should have been consumed by `parse_component`") |
| } |
| }) |
| }) |
| } |
| |
| fn parse_component<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, const VERSION: u8>( |
| opening_bracket: Location, |
| tokens: &mut lexer::Lexed<I>, |
| ) -> Result<Item<'a>, Error> { |
| let leading_whitespace = tokens.next_if_whitespace(); |
| |
| let Some(name) = tokens.next_if_not_whitespace() else { |
| let span = match leading_whitespace { |
| Some(Spanned { value: _, span }) => span, |
| None => opening_bracket.to(opening_bracket), |
| }; |
| return Err(span.error("expected component name")); |
| }; |
| |
| if *name == b"optional" { |
| let Some(whitespace) = tokens.next_if_whitespace() else { |
| return Err(name.span.error("expected whitespace after `optional`")); |
| }; |
| |
| let nested = parse_nested::<_, VERSION>(whitespace.span.end, tokens)?; |
| |
| let Some(closing_bracket) = tokens.next_if_closing_bracket() else { |
| return Err(opening_bracket.error("unclosed bracket")); |
| }; |
| |
| return Ok(Item::Optional { |
| opening_bracket, |
| _leading_whitespace: unused(leading_whitespace), |
| _optional_kw: unused(name), |
| _whitespace: unused(whitespace), |
| nested_format_description: nested, |
| closing_bracket, |
| }); |
| } |
| |
| if *name == b"first" { |
| let Some(whitespace) = tokens.next_if_whitespace() else { |
| return Err(name.span.error("expected whitespace after `first`")); |
| }; |
| |
| let mut nested_format_descriptions = Vec::new(); |
| while let Ok(description) = parse_nested::<_, VERSION>(whitespace.span.end, tokens) { |
| nested_format_descriptions.push(description); |
| } |
| |
| let Some(closing_bracket) = tokens.next_if_closing_bracket() else { |
| return Err(opening_bracket.error("unclosed bracket")); |
| }; |
| |
| return Ok(Item::First { |
| opening_bracket, |
| _leading_whitespace: unused(leading_whitespace), |
| _first_kw: unused(name), |
| _whitespace: unused(whitespace), |
| nested_format_descriptions: nested_format_descriptions.into_boxed_slice(), |
| closing_bracket, |
| }); |
| } |
| |
| let mut modifiers = Vec::new(); |
| let trailing_whitespace = loop { |
| let Some(whitespace) = tokens.next_if_whitespace() else { break None }; |
| |
| if let Some(location) = tokens.next_if_opening_bracket() { |
| return Err(location |
| .to(location) |
| .error("modifier must be of the form `key:value`")); |
| } |
| |
| let Some(Spanned { value, span }) = tokens.next_if_not_whitespace() else { |
| break Some(whitespace); |
| }; |
| |
| let Some(colon_index) = value.iter().position(|&b| b == b':') else { |
| return Err(span.error("modifier must be of the form `key:value`")); |
| }; |
| let key = &value[..colon_index]; |
| let value = &value[colon_index + 1..]; |
| |
| if key.is_empty() { |
| return Err(span.shrink_to_start().error("expected modifier key")); |
| } |
| if value.is_empty() { |
| return Err(span.shrink_to_end().error("expected modifier value")); |
| } |
| |
| modifiers.push(Modifier { |
| _leading_whitespace: unused(whitespace), |
| key: key.spanned(span.shrink_to_before(colon_index as _)), |
| _colon: unused(span.start.offset(colon_index as _)), |
| value: value.spanned(span.shrink_to_after(colon_index as _)), |
| }); |
| }; |
| |
| let Some(closing_bracket) = tokens.next_if_closing_bracket() else { |
| return Err(opening_bracket.error("unclosed bracket")); |
| }; |
| |
| Ok(Item::Component { |
| _opening_bracket: unused(opening_bracket), |
| _leading_whitespace: unused(leading_whitespace), |
| name, |
| modifiers: modifiers.into_boxed_slice(), |
| _trailing_whitespace: unused(trailing_whitespace), |
| _closing_bracket: unused(closing_bracket), |
| }) |
| } |
| |
| fn parse_nested<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, const VERSION: u8>( |
| last_location: Location, |
| tokens: &mut lexer::Lexed<I>, |
| ) -> Result<NestedFormatDescription<'a>, Error> { |
| let Some(opening_bracket) = tokens.next_if_opening_bracket() else { |
| return Err(last_location.error("expected opening bracket")); |
| }; |
| let items = parse_inner::<_, true, VERSION>(tokens).collect::<Result<_, _>>()?; |
| let Some(closing_bracket) = tokens.next_if_closing_bracket() else { |
| return Err(opening_bracket.error("unclosed bracket")); |
| }; |
| let trailing_whitespace = tokens.next_if_whitespace(); |
| |
| Ok(NestedFormatDescription { |
| _opening_bracket: unused(opening_bracket), |
| items, |
| _closing_bracket: unused(closing_bracket), |
| _trailing_whitespace: unused(trailing_whitespace), |
| }) |
| } |