use std::{iter::Peekable, sync::Arc};
use crate::tokens::{Color, PdnToken, PdnTokenBody, TokenHeader};
#[derive(Debug, Clone)]
pub struct PdnFile {
games: Vec<Game>,
game_separators: Vec<TokenHeader>,
}
#[derive(Debug, Clone)]
pub struct Game {
header: Vec<PdnTag>,
body: Vec<BodyPart>,
}
#[derive(Debug, Clone)]
pub struct PdnTag {
left_bracket: TokenHeader,
identifier_token: TokenHeader,
string_token: TokenHeader,
right_bracket: TokenHeader,
identifier: Arc<str>,
string: Arc<str>,
}
#[derive(Debug, Clone)]
pub enum BodyPart {
Move(GameMove),
Variation(Variation),
Comment(TokenHeader, Arc<str>),
Setup(TokenHeader, Arc<str>),
Nag(TokenHeader, usize),
}
#[derive(Debug, Clone)]
pub struct Variation {
left_parenthesis: TokenHeader,
body: Vec<BodyPart>,
right_parenthesis: TokenHeader,
}
#[derive(Debug, Clone)]
pub struct GameMove {
move_number: Option<(TokenHeader, usize, Color)>,
game_move: Move,
move_strength: Option<(TokenHeader, Arc<str>)>,
}
#[derive(Debug, Clone)]
pub enum Move {
Normal(Square, TokenHeader, Square),
Capture(Square, Vec<(TokenHeader, Square)>),
}
#[derive(Debug, Clone)]
pub enum Square {
Alpha(TokenHeader, char, char),
Num(TokenHeader, u8),
}
/// Returns `Ok` if parsed successfully. If there are no tokens left,
/// `Err(None)` is returned. If the next token is not a square position, then
/// `Err(Some(token))` is returned.
fn parse_square(scanner: &mut impl Iterator<Item = PdnToken>) -> Result<Square, Option<PdnToken>> {
let Some(token) = scanner.next() else {
return Err(None);
};
let header = token.header;
let body = &token.body;
match *body {
PdnTokenBody::AlphaSquare(letter, number) => Ok(Square::Alpha(header, letter, number)),
PdnTokenBody::NumSquare(number) => Ok(Square::Num(header, number)),
_ => Err(Some(token)),
}
}
#[derive(Debug, Clone)]
pub enum MoveError {
EndOfFile,
NoStartSquare(Option<PdnToken>),
NoEndSquare(Option<PdnToken>),
InvalidCaptureSquares(Vec<Option<PdnToken>>),
NoMoveSeparator,
}
fn parse_normal_move(
first_square: Square,
scanner: &mut impl Iterator<Item = PdnToken>,
) -> Result<Move, MoveError> {
let Some(separator) = scanner.next() else {
return Err(MoveError::NoMoveSeparator);
};
let square = match parse_square(scanner) {
Ok(square) => square,
Err(error) => return Err(MoveError::NoEndSquare(error)),
};
Ok(Move::Normal(first_square, separator.header, square))
}
fn parse_capture_move(
first_square: Square,
scanner: &mut Peekable<impl Iterator<Item = PdnToken>>,
) -> Result<Move, MoveError> {
let mut captures = Vec::new();
let mut errors = Vec::new();
while let Some(token) = scanner.peek() {
if token.body != PdnTokenBody::CaptureSeparator {
break;
}
let separator = scanner.next().expect("separator should be next");
match parse_square(scanner) {
Ok(square) => captures.push((separator.header, square)),
Err(error) => errors.push(error),
}
}
if !errors.is_empty() {
Err(MoveError::InvalidCaptureSquares(errors))
} else {
Ok(Move::Capture(first_square, captures))
}
}
fn parse_move(scanner: &mut Peekable<impl Iterator<Item = PdnToken>>) -> Result<Move, MoveError> {
let square = match parse_square(scanner) {
Ok(square) => square,
Err(error) => return Err(MoveError::NoStartSquare(error)),
};
let Some(token) = scanner.peek() else {
return Err(MoveError::NoMoveSeparator);
};
let body = &token.body;
match body {
PdnTokenBody::MoveSeparator => parse_normal_move(square, scanner),
PdnTokenBody::CaptureSeparator => parse_capture_move(square, scanner),
_ => Err(MoveError::NoMoveSeparator),
}
}
#[derive(Debug, Clone)]
pub enum GameMoveError {
EndOfFile,
BadMove(MoveError),
}
fn whitespace_if_found(
scanner: &mut Peekable<impl Iterator<Item = PdnToken>>,
) -> Option<TokenHeader> {
let token = scanner.peek()?;
if let PdnTokenBody::Space(_) = token.body {
Some(scanner.next()?.header)
} else {
None
}
}
fn parse_game_move(
scanner: &mut Peekable<impl Iterator<Item = PdnToken>>,
) -> Result<GameMove, GameMoveError> {
let Some(next_token) = scanner.peek() else {
return Err(GameMoveError::EndOfFile);
};
let move_number = match next_token.body {
PdnTokenBody::MoveNumber(number, color) => Some((next_token.header, number, color)),
_ => None,
};
if move_number.is_some() {
scanner.next();
}
whitespace_if_found(scanner);
let game_move = parse_move(scanner);
let move_strength = if let Some(token) = scanner.peek() {
if let PdnTokenBody::MoveStrength(string) = &token.body {
Some((token.header, string.clone()))
} else {
None
}
} else {
None
};
if move_strength.is_some() {
scanner.next();
}
match game_move {
Ok(game_move) => Ok(GameMove {
move_number,
game_move,
move_strength,
}),
Err(error) => Err(GameMoveError::BadMove(error)),
}
}
#[derive(Debug, Clone)]
pub enum VariationError {
UnexpectedEnd(BodyError),
BadBody(BodyError),
}
fn parse_variation(
scanner: &mut Peekable<impl Iterator<Item = PdnToken>>,
) -> Result<Variation, VariationError> {
let left_parenthesis = scanner.next().expect("should start with left paren").header;
let body = parse_body_until(scanner, PdnTokenBody::RightParenthesis)?;
let right_parenthesis = scanner.next().expect("should end with right paren").header;
Ok(Variation {
left_parenthesis,
body,
right_parenthesis,
})
}
#[derive(Debug, Clone)]
pub enum BodyPartError {
EndOfFile,
InvalidToken(PdnToken),
BadMove(GameMoveError),
BadVariation(VariationError),
}
fn parse_body_part(
scanner: &mut Peekable<impl Iterator<Item = PdnToken>>,
) -> Result<BodyPart, BodyPartError> {
let Some(token) = scanner.peek() else {
return Err(BodyPartError::EndOfFile);
};
match &token.body {
PdnTokenBody::MoveNumber(..)
| PdnTokenBody::AlphaSquare(..)
| PdnTokenBody::NumSquare(..) => match parse_game_move(scanner) {
Ok(mov) => Ok(BodyPart::Move(mov)),
Err(error) => Err(BodyPartError::BadMove(error)),
},
PdnTokenBody::LeftParenthesis => match parse_variation(scanner) {
Ok(variation) => Ok(BodyPart::Variation(variation)),
Err(error) => Err(BodyPartError::BadVariation(error)),
},
PdnTokenBody::Comment(string) => Ok(BodyPart::Comment(token.header, string.clone())),
PdnTokenBody::Setup(string) => Ok(BodyPart::Setup(token.header, string.clone())),
PdnTokenBody::Nag(number) => Ok(BodyPart::Nag(token.header, *number)),
_ => Err(BodyPartError::InvalidToken(token.clone())),
}
}
pub type BodyError = Vec<Result<BodyPart, BodyPartError>>;
fn parse_body_until(
scanner: &mut Peekable<impl Iterator<Item = PdnToken>>,
until: PdnTokenBody,
) -> Result<Vec<BodyPart>, VariationError> {
let mut parts = Vec::new();
loop {
whitespace_if_found(scanner);
let Some(token) = scanner.peek() else {
return Err(VariationError::UnexpectedEnd(parts));
};
if token.body == until {
break;
}
parts.push(parse_body_part(scanner));
whitespace_if_found(scanner);
}
if parts.iter().any(|r| r.is_err()) {
Err(VariationError::BadBody(parts))
} else {
Ok(parts.iter().map(|r| r.as_ref().cloned().unwrap()).collect())
}
}
#[derive(Debug, Clone)]
pub enum PdnTagError {
EndOfFile,
NoStartBracket(PdnToken),
Unterminated(Vec<PdnToken>),
NoIdentifier,
NoString,
NoEndBracket,
}
fn parse_pdn_tag(
scanner: &mut Peekable<impl Iterator<Item = PdnToken>>,
) -> Result<PdnTag, PdnTagError> {
whitespace_if_found(scanner);
let Some(left_bracket) = scanner.next() else {
return Err(PdnTagError::EndOfFile);
};
if left_bracket.body != PdnTokenBody::LeftBracket {
return Err(PdnTagError::NoStartBracket(left_bracket));
}
whitespace_if_found(scanner);
let Some(identifier_token) = scanner.next() else {
return Err(PdnTagError::Unterminated(vec![left_bracket]));
};
let PdnTokenBody::Identifier(identifier) = &identifier_token.body else {
return Err(PdnTagError::NoIdentifier);
};
whitespace_if_found(scanner);
let Some(value_token) = scanner.next() else {
return Err(PdnTagError::Unterminated(vec![
left_bracket,
identifier_token,
]));
};
let PdnTokenBody::String(value) = &value_token.body else {
return Err(PdnTagError::NoIdentifier);
};
whitespace_if_found(scanner);
let Some(right_bracket) = scanner.next() else {
return Err(PdnTagError::Unterminated(vec![
left_bracket,
identifier_token,
value_token,
]));
};
if right_bracket.body != PdnTokenBody::RightBracket {
return Err(PdnTagError::NoEndBracket);
}
whitespace_if_found(scanner);
Ok(PdnTag {
left_bracket: left_bracket.header,
identifier_token: identifier_token.header,
string_token: value_token.header,
right_bracket: right_bracket.header,
identifier: identifier.clone(),
string: value.clone(),
})
}
pub type HeaderError = Vec<Result<PdnTag, PdnTagError>>;
fn parse_header(
scanner: &mut Peekable<impl Iterator<Item = PdnToken>>,
) -> Result<Vec<PdnTag>, HeaderError> {
let mut tags = Vec::new();
loop {
let Some(token) = scanner.peek() else {
break;
};
if token.body != PdnTokenBody::LeftBracket {
break;
}
tags.push(parse_pdn_tag(scanner));
}
if tags.iter().any(|r| r.is_err()) {
Err(tags)
} else {
Ok(tags.iter().map(|r| r.as_ref().cloned().unwrap()).collect())
}
}
#[derive(Debug, Clone)]
pub struct GameError {
header: Result<Vec<PdnTag>, HeaderError>,
body: Result<Vec<BodyPart>, VariationError>,
}
fn parse_game(scanner: &mut Peekable<impl Iterator<Item = PdnToken>>) -> Result<Game, GameError> {
let header = parse_header(scanner);
let body = parse_body_until(scanner, PdnTokenBody::Asterisk);
whitespace_if_found(scanner);
if let Ok(header) = header {
if let Ok(body) = body {
Ok(Game { header, body })
} else {
Err(GameError {
header: Ok(header),
body,
})
}
} else {
Err(GameError { header, body })
}
}
pub type PdnError = Vec<Result<Game, GameError>>;
fn parse(scanner: &mut impl Iterator<Item = PdnToken>) -> Result<PdnFile, PdnError> {
let mut scanner = scanner.peekable();
let mut games = Vec::new();
let mut game_separators = Vec::new();
loop {
let Some(token) = scanner.peek() else {
break;
};
if token.body != PdnTokenBody::LeftBracket {
break;
}
games.push(parse_game(&mut scanner));
game_separators.push(scanner.next().unwrap().header);
}
if games.iter().any(|r| r.is_err()) {
Err(games)
} else {
let games = games.iter().map(|r| r.as_ref().cloned().unwrap()).collect();
Ok(PdnFile {
games,
game_separators,
})
}
}
|
