156 lines
3.1 KiB
Rust
156 lines
3.1 KiB
Rust
pub struct Mark {
|
|
i: usize
|
|
}
|
|
|
|
pub trait Read<'a> {
|
|
// Per char reading.
|
|
fn next_char(&mut self) -> Result<char>;
|
|
fn peek_char(&mut self) -> Result<char>;
|
|
|
|
// Sectioning off data.
|
|
fn mark(&self) -> Mark;
|
|
/// Returns reference to the section.
|
|
fn from_mark(&mut self, m: Mark) -> &'a str;
|
|
|
|
/// Attempt to enter a new level of nesting.
|
|
fn enter_nest(&mut self) -> Result<()>;
|
|
/// Leave a nest.
|
|
fn leave_nest(&mut self);
|
|
|
|
/// Called when the parser passes a line.
|
|
fn passed_line(&mut self);
|
|
}
|
|
|
|
//pub trait Visitor {}
|
|
|
|
pub struct Parser<'a, R: Read + 'a> {
|
|
r: &'a mut R
|
|
}
|
|
|
|
impl<'a, R: Read> Parser<'a, R> {
|
|
fn parse_value(&mut self) -> Result<()> {
|
|
loop {
|
|
match self.r.next() {
|
|
Some(c) => match c {
|
|
COMMENT_CHAR => if !self.skip_to_next_line() {
|
|
return Ok(())
|
|
},
|
|
// Whitespace
|
|
LF_CHAR => self.r.mark_line(),
|
|
CR_CHAR => {
|
|
self.skip_char(LF_CHAR);
|
|
self.r.mark_line();
|
|
},
|
|
SPACE_CHAR | TAB_CHAR => {
|
|
self.skip_one();
|
|
},
|
|
// Values
|
|
DICT_START_CHAR => return self.parse_dict(),
|
|
LIST_START_CHAR => return self.parse_list(),
|
|
TEXT_DELIM_CHAR => return self.parse_text(),
|
|
MULTI_TEXT_DELIM_CHAR => return self.parse_multi_text(),
|
|
REAL_NEG_CHAR => return self.parse_real_negative(),
|
|
REAL_ZERO_CHAR => return self.parse_real_positive_decimal(),
|
|
'1'...'9' => return self.parse_real_positive_int(),
|
|
'a'...'z' => return self.parse_initial_lowercase(c),
|
|
'A'...'Z' => return self.parse_initial_uppercase(c),
|
|
// Unexpected
|
|
c => return Some(ParseError::Unexpected(c))
|
|
},
|
|
None => return Ok(())
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn skip_one(&mut self) -> bool {
|
|
match self.r.next() {
|
|
Some(_) => true,
|
|
None => false
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn skip_char(&mut self, c: char) -> bool {
|
|
match self.r.peek() {
|
|
Some(peeked_c) if c == peeked_c => self.skip_one(),
|
|
Some(_) => true,
|
|
_ => false
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn skip_to_next_line(&mut self) -> bool {
|
|
loop {
|
|
match self.r.next() {
|
|
Some(LF_CHAR) => {
|
|
self.r.mark_line();
|
|
return true
|
|
},
|
|
Some(CR_CHAR) => {
|
|
if self.skip_char(LF_CHAR) {
|
|
self.r.mark_line();
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
},
|
|
Some(_) => return true,
|
|
None => return false
|
|
}
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn parse_dict(&mut self) -> Option<ParseError> {
|
|
if self.r.enter_ctx() {
|
|
None
|
|
} else {
|
|
Some(ParseError::NestingLimit)
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn parse_list(&mut self) -> Option<ParseError> {
|
|
if self.r.enter_ctx() {
|
|
None
|
|
} else {
|
|
Some(ParseError::NestingLimit)
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn parse_text(&mut self) -> Option<ParseError> {
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
fn parse_multi_text(&mut self) -> Option<ParseError> {
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
fn parse_real_negative(&mut self) -> Option<ParseError> {
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
fn parse_real_positive_int(&mut self) -> Option<ParseError> {
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
fn parse_real_positive_decimal(&mut self) -> Option<ParseError> {
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
fn parse_initial_lowercase(&mut self, c: char) -> Option<ParseError> {
|
|
None
|
|
}
|
|
|
|
#[inline]
|
|
fn parse_initial_uppercase(&mut self, c: char) -> Option<ParseError> {
|
|
None
|
|
}
|
|
} |