|
|
|
use crate::parsing::tokens::{LB, SPECIAL_ESCAPE};
|
|
|
|
use crate::parsing::utils::{ParseError, ParseResult};
|
|
|
|
use crate::Parser;
|
|
|
|
|
|
|
|
pub trait CharStateMachine {
|
|
|
|
fn next_char(&mut self) -> Option<char>;
|
|
|
|
fn skip_char(&mut self);
|
|
|
|
fn revert_to(&mut self, index: usize) -> Result<(), ParseError>;
|
|
|
|
fn revert_with_error(&mut self, index: usize) -> ParseError;
|
|
|
|
fn seek_inline_whitespace(&mut self);
|
|
|
|
fn seek_whitespace(&mut self);
|
|
|
|
fn seek_until_linebreak(&mut self);
|
|
|
|
fn check_seek_inline_whitespace(&mut self) -> bool;
|
|
|
|
fn check_escaped(&self) -> bool;
|
|
|
|
fn check_special(&self, character: &char) -> bool;
|
|
|
|
fn check_special_group(&self, group: &[char]) -> bool;
|
|
|
|
fn check_special_sequence(&mut self, sequence: &[char]) -> bool;
|
|
|
|
fn check_special_sequence_group(&mut self, sequences: &[&[char]]) -> bool;
|
|
|
|
fn check_linebreak(&self) -> bool;
|
|
|
|
fn check_eof(&self) -> bool;
|
|
|
|
fn assert_special(&mut self, character: &char, revert_index: usize) -> Result<(), ParseError>;
|
|
|
|
fn assert_special_group(
|
|
|
|
&mut self,
|
|
|
|
group: &[char],
|
|
|
|
revert_index: usize,
|
|
|
|
) -> Result<(), ParseError>;
|
|
|
|
fn assert_special_sequence(
|
|
|
|
&mut self,
|
|
|
|
sequence: &[char],
|
|
|
|
revert_index: usize,
|
|
|
|
) -> Result<(), ParseError>;
|
|
|
|
fn assert_special_sequence_group(
|
|
|
|
&mut self,
|
|
|
|
sequences: &[&[char]],
|
|
|
|
revert_index: usize,
|
|
|
|
) -> Result<(), ParseError>;
|
|
|
|
fn get_string_until(
|
|
|
|
&mut self,
|
|
|
|
break_at: &[char],
|
|
|
|
err_at: &[char],
|
|
|
|
) -> Result<String, ParseError>;
|
|
|
|
fn get_string_until_sequence(
|
|
|
|
&mut self,
|
|
|
|
break_at: &[&[char]],
|
|
|
|
err_at: &[char],
|
|
|
|
) -> Result<String, ParseError>;
|
|
|
|
fn get_string_until_or_revert(
|
|
|
|
&mut self,
|
|
|
|
break_et: &[char],
|
|
|
|
err_at: &[char],
|
|
|
|
revert_index: usize,
|
|
|
|
) -> ParseResult<String>;
|
|
|
|
}
|
|
|
|
|
|
|
|
impl CharStateMachine for Parser {
|
|
|
|
/// Increments the current index and returns the
|
|
|
|
/// char at the indexes position
|
|
|
|
#[inline]
|
|
|
|
fn next_char(&mut self) -> Option<char> {
|
|
|
|
self.index += 1;
|
|
|
|
self.previous_char = self.current_char;
|
|
|
|
if (self.text.len() - 1) <= self.index {
|
|
|
|
for _ in 0..8 {
|
|
|
|
let mut buf = String::new();
|
|
|
|
if let Ok(_) = self.reader.read_line(&mut buf) {
|
|
|
|
self.text.append(&mut buf.chars().collect())
|
|
|
|
} else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
self.current_char = *self.text.get(self.index)?;
|
|
|
|
|
|
|
|
Some(self.current_char)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// skips to the next char
|
|
|
|
#[inline]
|
|
|
|
fn skip_char(&mut self) {
|
|
|
|
self.next_char();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns to an index position
|
|
|
|
#[inline]
|
|
|
|
fn revert_to(&mut self, index: usize) -> Result<(), ParseError> {
|
|
|
|
if let Some(char) = self.text.get(index) {
|
|
|
|
self.index = index;
|
|
|
|
self.current_char = *char;
|
|
|
|
if index > self.text.len() {
|
|
|
|
if let Some(ch) = self.text.get(index - 1) {
|
|
|
|
self.previous_char = *ch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
Err(ParseError::new_with_message(index, "failed to revert"))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// reverts and returns a parse error
|
|
|
|
#[inline]
|
|
|
|
fn revert_with_error(&mut self, index: usize) -> ParseError {
|
|
|
|
let err = ParseError::new(self.index);
|
|
|
|
|
|
|
|
if let Err(revert_err) = self.revert_to(index) {
|
|
|
|
revert_err
|
|
|
|
} else {
|
|
|
|
err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Skips characters until it encounters a character
|
|
|
|
/// that isn't an inline whitespace character
|
|
|
|
fn seek_inline_whitespace(&mut self) {
|
|
|
|
if self.current_char.is_whitespace() && !self.check_linebreak() {
|
|
|
|
while let Some(next_char) = self.next_char() {
|
|
|
|
if !next_char.is_whitespace() || self.check_linebreak() {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Skips characters until it encounters a character
|
|
|
|
/// that isn't a whitespace character
|
|
|
|
fn seek_whitespace(&mut self) {
|
|
|
|
if self.current_char.is_whitespace() {
|
|
|
|
while let Some(next_char) = self.next_char() {
|
|
|
|
if !next_char.is_whitespace() {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// seeks until it encounters a linebreak character
|
|
|
|
fn seek_until_linebreak(&mut self) {
|
|
|
|
if self.check_special(&LB) {
|
|
|
|
self.skip_char();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
while let Some(_) = self.next_char() {
|
|
|
|
if self.check_special(&LB) {
|
|
|
|
self.skip_char();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// seeks inline whitespaces and returns if there
|
|
|
|
/// were seeked whitespaces
|
|
|
|
fn check_seek_inline_whitespace(&mut self) -> bool {
|
|
|
|
let start_index = self.index;
|
|
|
|
self.seek_inline_whitespace();
|
|
|
|
self.index > start_index
|
|
|
|
}
|
|
|
|
|
|
|
|
/// checks if the input character is escaped
|
|
|
|
#[inline]
|
|
|
|
fn check_escaped(&self) -> bool {
|
|
|
|
if self.index == 0 {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if self.previous_char == SPECIAL_ESCAPE {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// checks if the current character is the given input character and not escaped
|
|
|
|
#[inline]
|
|
|
|
fn check_special(&self, character: &char) -> bool {
|
|
|
|
self.current_char == *character && !self.check_escaped()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// checks if the current character is part of the given group
|
|
|
|
fn check_special_group(&self, chars: &[char]) -> bool {
|
|
|
|
chars.contains(&self.current_char) && !self.check_escaped()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// checks if the next characters match a special sequence
|
|
|
|
fn check_special_sequence(&mut self, sequence: &[char]) -> bool {
|
|
|
|
let start_index = self.index;
|
|
|
|
if self.check_escaped() {
|
|
|
|
self.revert_to(start_index).unwrap();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
for sq_character in sequence {
|
|
|
|
if self.current_char != *sq_character {
|
|
|
|
let _ = self.revert_to(start_index);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if self.next_char() == None {
|
|
|
|
let _ = self.revert_to(start_index);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if self.index > 0 {
|
|
|
|
self.revert_to(self.index - 1).unwrap();
|
|
|
|
}
|
|
|
|
|
|
|
|
true
|
|
|
|
}
|
|
|
|
|
|
|
|
/// checks if the next chars are a special sequence
|
|
|
|
fn check_special_sequence_group(&mut self, sequences: &[&[char]]) -> bool {
|
|
|
|
for sequence in sequences {
|
|
|
|
if self.check_special_sequence(*sequence) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
false
|
|
|
|
}
|
|
|
|
|
|
|
|
/// returns if the current character is a linebreak character
|
|
|
|
/// Note: No one likes CRLF
|
|
|
|
#[inline]
|
|
|
|
fn check_linebreak(&self) -> bool {
|
|
|
|
self.current_char == LB && !self.check_escaped()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_eof(&self) -> bool {
|
|
|
|
self.index >= (self.text.len() - 1)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn assert_special(&mut self, character: &char, revert_index: usize) -> Result<(), ParseError> {
|
|
|
|
if self.check_special(character) {
|
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
Err(self.revert_with_error(revert_index))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline]
|
|
|
|
fn assert_special_group(
|
|
|
|
&mut self,
|
|
|
|
group: &[char],
|
|
|
|
revert_index: usize,
|
|
|
|
) -> Result<(), ParseError> {
|
|
|
|
if self.check_special_group(group) {
|
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
Err(self.revert_with_error(revert_index))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn assert_special_sequence(
|
|
|
|
&mut self,
|
|
|
|
sequence: &[char],
|
|
|
|
revert_index: usize,
|
|
|
|
) -> Result<(), ParseError> {
|
|
|
|
if self.check_special_sequence(sequence) {
|
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
Err(self.revert_with_error(revert_index))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn assert_special_sequence_group(
|
|
|
|
&mut self,
|
|
|
|
sequences: &[&[char]],
|
|
|
|
revert_index: usize,
|
|
|
|
) -> Result<(), ParseError> {
|
|
|
|
if self.check_special_sequence_group(sequences) {
|
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
Err(self.revert_with_error(revert_index))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// returns the string until a specific
|
|
|
|
fn get_string_until(
|
|
|
|
&mut self,
|
|
|
|
break_at: &[char],
|
|
|
|
err_at: &[char],
|
|
|
|
) -> Result<String, ParseError> {
|
|
|
|
let start_index = self.index;
|
|
|
|
let mut result = String::new();
|
|
|
|
if self.check_special_group(break_at) {
|
|
|
|
return Ok(result);
|
|
|
|
} else if self.check_special_group(err_at) {
|
|
|
|
return Err(ParseError::new(self.index));
|
|
|
|
}
|
|
|
|
|
|
|
|
result.push(self.current_char);
|
|
|
|
while let Some(ch) = self.next_char() {
|
|
|
|
if self.check_special_group(break_at) || self.check_special_group(err_at) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
result.push(ch);
|
|
|
|
}
|
|
|
|
|
|
|
|
if self.check_special_group(err_at) {
|
|
|
|
Err(self.revert_with_error(start_index))
|
|
|
|
} else {
|
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the string until a specific end sequence or an error character
|
|
|
|
fn get_string_until_sequence(
|
|
|
|
&mut self,
|
|
|
|
break_at: &[&[char]],
|
|
|
|
err_at: &[char],
|
|
|
|
) -> Result<String, ParseError> {
|
|
|
|
let start_index = self.index;
|
|
|
|
let mut result = String::new();
|
|
|
|
if self.check_special_sequence_group(break_at) {
|
|
|
|
return Ok(result);
|
|
|
|
} else if self.check_special_group(err_at) {
|
|
|
|
return Err(ParseError::new(self.index));
|
|
|
|
}
|
|
|
|
|
|
|
|
result.push(self.current_char);
|
|
|
|
while let Some(ch) = self.next_char() {
|
|
|
|
if self.check_special_sequence_group(break_at) || self.check_special_group(err_at) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
result.push(ch);
|
|
|
|
}
|
|
|
|
|
|
|
|
if self.check_special_group(err_at) {
|
|
|
|
Err(self.revert_with_error(start_index))
|
|
|
|
} else {
|
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// returns the string until a specific character or reverts back to the given position
|
|
|
|
fn get_string_until_or_revert(
|
|
|
|
&mut self,
|
|
|
|
break_at: &[char],
|
|
|
|
err_at: &[char],
|
|
|
|
revert_index: usize,
|
|
|
|
) -> ParseResult<String> {
|
|
|
|
if let Ok(string) = self.get_string_until(break_at, err_at) {
|
|
|
|
Ok(string)
|
|
|
|
} else {
|
|
|
|
Err(self.revert_with_error(revert_index))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|