You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
131 lines
3.5 KiB
Rust
131 lines
3.5 KiB
Rust
use crate::tokens::*;
|
|
use std::error::Error;
|
|
use std::fmt;
|
|
use std::fmt::{Display, Formatter};
|
|
|
|
#[derive(Debug)]
|
|
pub struct ParseError {
|
|
index: usize,
|
|
}
|
|
impl Display for ParseError {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
|
|
write!(f, "parse error at index {}", self.index)
|
|
}
|
|
}
|
|
impl Error for ParseError {}
|
|
impl ParseError {
|
|
pub fn new(index: usize) -> Self {
|
|
Self { index }
|
|
}
|
|
}
|
|
|
|
pub struct Parser {
|
|
index: usize,
|
|
text: Vec<char>,
|
|
current_char: char,
|
|
section_nesting: u8,
|
|
}
|
|
|
|
impl Parser {
|
|
pub fn next_char(&mut self) -> Option<char> {
|
|
self.index += 1;
|
|
|
|
self.current_char = self.text.get(self.index)?.clone();
|
|
|
|
Some(self.current_char)
|
|
}
|
|
|
|
pub fn revert_to(&mut self, index: usize) -> Result<(), ParseError> {
|
|
self.index = index;
|
|
if let Some(_) = self.next_char() {
|
|
Ok(())
|
|
} else {
|
|
Err(ParseError::new(index))
|
|
}
|
|
}
|
|
|
|
pub fn parse(&mut self) {
|
|
let mut document = Document::new();
|
|
while self.index < self.text.len() {
|
|
if let Ok(token) = self.parse_block() {
|
|
document.add_element(token);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn parse_block(&mut self) -> Result<Block, ParseError> {
|
|
if let Some(_) = self.next_char() {
|
|
let token = if let Ok(section) = self.parse_section() {
|
|
Block::Section(section)
|
|
} else if let Ok(list) = self.parse_list() {
|
|
Block::List(list)
|
|
} else if let Ok(table) = self.parse_table() {
|
|
Block::Table(table)
|
|
} else if let Ok(paragraph) = self.parse_paragraph() {
|
|
Block::Paragraph(paragraph)
|
|
} else {
|
|
return Err(ParseError::new(self.index));
|
|
};
|
|
|
|
Ok(token)
|
|
} else {
|
|
Err(ParseError::new(self.index))
|
|
}
|
|
}
|
|
|
|
pub fn parse_section(&mut self) -> Result<Section, ParseError> {
|
|
let start_index = self.index;
|
|
if self.current_char == '#' {
|
|
let mut size = 1;
|
|
while let Some(next_char) = self.next_char() {
|
|
if next_char == '#' {
|
|
size += 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if size <= self.section_nesting || !self.current_char.is_whitespace() {
|
|
let index = self.index;
|
|
self.revert_to(start_index)?;
|
|
return Err(ParseError::new(index));
|
|
}
|
|
let _ = self.next_char();
|
|
let mut header = self.parse_header()?;
|
|
header.size = size;
|
|
self.section_nesting = size;
|
|
let mut section = Section::new(header);
|
|
|
|
while let Ok(block) = self.parse_block() {
|
|
section.add_element(block);
|
|
}
|
|
|
|
Ok(section)
|
|
} else {
|
|
Err(ParseError::new(self.index))
|
|
}
|
|
}
|
|
|
|
pub fn parse_paragraph(&mut self) -> Result<Paragraph, ParseError> {
|
|
unimplemented!()
|
|
}
|
|
|
|
pub fn parse_list(&mut self) -> Result<List, ParseError> {
|
|
unimplemented!()
|
|
}
|
|
|
|
pub fn parse_table(&mut self) -> Result<Table, ParseError> {
|
|
unimplemented!()
|
|
}
|
|
|
|
pub fn parse_header(&mut self) -> Result<Header, ParseError> {
|
|
Ok(Header {
|
|
size: 0,
|
|
text: self.parse_text()?,
|
|
})
|
|
}
|
|
|
|
pub fn parse_text(&mut self) -> Result<Text, ParseError> {
|
|
unimplemented!()
|
|
}
|
|
}
|