use std::sync::Arc;
use snob::{csets, csets::CharacterSet, Scanner};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Color {
White,
Black,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PdnTokenBody {
MoveNumber(usize, Color),
MoveSeparator,
CaptureSeparator,
AlphaSquare(char, char),
NumSquare(u8),
MoveStrength(Arc<str>),
Nag(usize),
LeftParenthesis,
RightParenthesis,
LeftBracket,
RightBracket,
Asterisk,
Setup(Arc<str>),
String(Arc<str>),
Comment(Arc<str>),
Identifier(Arc<str>),
Space(Arc<str>),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TokenHeader {
start: usize,
len: usize,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct PdnToken {
pub header: TokenHeader,
pub body: PdnTokenBody,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum TokenErrorType {
InvalidNumber(usize),
InvalidNag,
InvalidSquare,
UnterminatedSetup,
UnterminatedComment,
UnterminatedString,
InvalidToken,
}
pub struct TokenError {
header: TokenHeader,
ty: TokenErrorType,
}
pub struct PdnScanner {
scanner: Scanner,
}
impl PdnScanner {
fn scan_string(&mut self) -> Option<String> {
let mut string = String::new();
loop {
if let Some(position) = self.scanner.many("\\\"".complement()) {
let part = self
.scanner
.goto(position)
.expect("position should be valid");
string.push_str(&part);
} else if let Some(position) = self.scanner.starts_with("\\\"") {
self.scanner.goto(position);
string.push('"');
} else {
break;
}
}
if let Some(position) = self.scanner.any('"') {
self.scanner.goto(position);
Some(string)
} else {
None
}
}
fn scan_unescaped_string(&mut self, terminator: char) -> Option<String> {
let position = self.scanner.upto(terminator)?;
let string = self
.scanner
.goto(position)
.expect("position should be valid");
let position = self
.scanner
.any(terminator)
.expect("there should be a terminator next");
self.scanner.goto(position);
Some(string)
}
fn scan_number(&mut self) -> Option<usize> {
let position = self.scanner.many(csets::AsciiDigits)?;
let number = self
.scanner
.goto(position)
.expect("position should be valid");
let number: usize = number.parse().expect("should be a valid number");
Some(number)
}
fn scan_identifier(&mut self) -> Option<String> {
let position = self
.scanner
.many(csets::AsciiLetters.union(csets::AsciiDigits).union('_'))?;
let identifier = self
.scanner
.goto(position)
.expect("position should be valid");
Some(identifier)
}
fn next_token(&mut self) -> Option<Result<PdnTokenBody, TokenErrorType>> {
if self.scanner.is_at_end() {
return None;
}
let token = if let Some(position) = self.scanner.any('-') {
self.scanner.goto(position);
Ok(PdnTokenBody::MoveSeparator)
} else if let Some(position) = self.scanner.any('x') {
self.scanner.goto(position);
Ok(PdnTokenBody::CaptureSeparator)
} else if let Some(position) = self.scanner.any('(') {
self.scanner.goto(position);
// try a move strength token
if let Some(position) = self.scanner.many("?!") {
let char = self
.scanner
.char_at(position)
.expect("position should be valid");
if char == ')' {
let strength = self
.scanner
.goto(position)
.expect("position should be valid");
let position = self
.scanner
.any(')')
.expect("move strength should terminate");
self.scanner.goto(position);
return Some(Ok(PdnTokenBody::MoveStrength(strength.into())));
}
}
Ok(PdnTokenBody::LeftParenthesis)
} else if let Some(position) = self.scanner.any(')') {
self.scanner.goto(position);
Ok(PdnTokenBody::RightParenthesis)
} else if let Some(position) = self.scanner.any('[') {
self.scanner.goto(position);
Ok(PdnTokenBody::LeftBracket)
} else if let Some(position) = self.scanner.any(']') {
self.scanner.goto(position);
Ok(PdnTokenBody::RightBracket)
} else if let Some(position) = self.scanner.any('*') {
self.scanner.goto(position);
Ok(PdnTokenBody::Asterisk)
} else if let Some(position) = self.scanner.any('$') {
self.scanner.goto(position);
match self.scan_number() {
Some(number) => Ok(PdnTokenBody::Nag(number)),
None => Err(TokenErrorType::InvalidNag),
}
} else if let Some(position) = self.scanner.any('/') {
self.scanner.goto(position);
match self.scan_unescaped_string('/') {
Some(string) => Ok(PdnTokenBody::Setup(string.into())),
None => Err(TokenErrorType::UnterminatedSetup),
}
} else if let Some(position) = self.scanner.any('{') {
self.scanner.goto(position);
match self.scan_unescaped_string('}') {
Some(string) => Ok(PdnTokenBody::Comment(string.into())),
None => Err(TokenErrorType::UnterminatedComment),
}
} else if let Some(position) = self.scanner.any('"') {
self.scanner.goto(position);
match self.scan_string() {
Some(string) => Ok(PdnTokenBody::String(string.into())),
None => Err(TokenErrorType::UnterminatedString),
}
} else if let Some(position) = self.scanner.many("?!") {
let strength = self
.scanner
.goto(position)
.expect("position should be valid");
Ok(PdnTokenBody::MoveStrength(strength.into()))
} else if let Some(position) = self.scanner.any("abcdefgh") {
let letter = self
.scanner
.goto(position)
.expect("position should be valid")
.chars()
.next()
.expect("should contain one letter");
if let Some(position) = self.scanner.any("12345678") {
let number = self
.scanner
.goto(position)
.expect("position should be valid")
.chars()
.next()
.expect("should contain one letter");
Ok(PdnTokenBody::AlphaSquare(letter, number))
} else {
self.scanner.advance(1); // skip over second character
Err(TokenErrorType::InvalidSquare)
}
} else if self.scanner.any(csets::AsciiUppercase).is_some() {
let identifier = self
.scan_identifier()
.expect("should be a valid identifier");
Ok(PdnTokenBody::Identifier(identifier.into()))
} else if self.scanner.any(csets::AsciiDigits).is_some() {
let number = self.scan_number().expect("should be a valid number");
if let Some(position) = self.scanner.starts_with("...") {
self.scanner.goto(position);
Ok(PdnTokenBody::MoveNumber(number, Color::Black))
} else if let Some(position) = self.scanner.any('.') {
self.scanner.goto(position);
Ok(PdnTokenBody::MoveNumber(number, Color::White))
} else if number < 100 {
Ok(PdnTokenBody::NumSquare(number as u8))
} else {
Err(TokenErrorType::InvalidNumber(number))
}
} else if let Some(position) = self.scanner.many(csets::AsciiWhitespace) {
let whitespace = self
.scanner
.goto(position)
.expect("position should be valid");
Ok(PdnTokenBody::Space(whitespace.into()))
} else {
let position = self
.scanner
.upto(csets::AsciiLetters.union(csets::AsciiDigits.union("-x(?!)[]")))
.unwrap_or_else(|| self.scanner.len());
self.scanner
.goto(position)
.expect("position should be valid");
Err(TokenErrorType::InvalidToken)
};
Some(token)
}
}
impl Iterator for PdnScanner {
type Item = Result<PdnToken, TokenError>;
fn next(&mut self) -> Option<Self::Item> {
let start = self.scanner.position();
let token = self.next_token()?;
let end = self.scanner.position();
let len = end - start;
let header = TokenHeader { start, len };
let token = match token {
Ok(token) => Ok(PdnToken {
header,
body: token,
}),
Err(error) => Err(TokenError { header, ty: error }),
};
Some(token)
}
}
|
