mirror of
https://github.com/Dummi26/mers.git
synced 2025-12-16 03:57:50 +01:00
full rewrite, kinda works
This commit is contained in:
Mark
0
mers_lib/src/parsing/errors.rs
Executable file
0
mers_lib/src/parsing/errors.rs
Executable file
156
mers_lib/src/parsing/mod.rs
Executable file
156
mers_lib/src/parsing/mod.rs
Executable file
@@ -0,0 +1,156 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use crate::{
|
||||
info::Info,
|
||||
program::{self, parsed::CompInfo},
|
||||
};
|
||||
|
||||
pub mod errors;
|
||||
pub mod statements;
|
||||
pub mod types;
|
||||
|
||||
pub fn parse(src: &mut Source) -> Result<Box<dyn program::parsed::MersStatement>, ()> {
|
||||
Ok(Box::new(statements::parse_block(src)?))
|
||||
}
|
||||
|
||||
pub struct Source {
|
||||
src: String,
|
||||
i: usize,
|
||||
sections: Vec<SectionMarker>,
|
||||
}
|
||||
impl Source {
|
||||
pub fn new(src: String) -> Self {
|
||||
Self {
|
||||
src,
|
||||
i: 0,
|
||||
sections: vec![],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn skip_whitespace(&mut self) {
|
||||
if let Some(i) = self.src[self.i..].char_indices().find_map(|(i, ch)| {
|
||||
if !ch.is_whitespace() {
|
||||
Some(i)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}) {
|
||||
self.i += i;
|
||||
} else {
|
||||
self.i = self.src.len();
|
||||
}
|
||||
}
|
||||
|
||||
fn end_sections(&mut self) {
|
||||
let pos = self.get_pos();
|
||||
for section in self.sections.iter_mut() {
|
||||
section.checked_end(pos);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn peek_char(&self) -> Option<char> {
|
||||
self.src[self.i..].chars().next()
|
||||
}
|
||||
pub fn next_char(&mut self) -> Option<char> {
|
||||
self.end_sections();
|
||||
let ch = self.src[self.i..].chars().next()?;
|
||||
self.i += ch.len_utf8();
|
||||
Some(ch)
|
||||
}
|
||||
fn word_splitter(ch: char) -> bool {
|
||||
ch.is_whitespace() || ".,;)}".contains(ch)
|
||||
}
|
||||
pub fn peek_word(&self) -> &str {
|
||||
self.src[self.i..]
|
||||
.split(Self::word_splitter)
|
||||
.next()
|
||||
.unwrap_or("")
|
||||
}
|
||||
pub fn next_word(&mut self) -> &str {
|
||||
self.end_sections();
|
||||
let word = self.src[self.i..]
|
||||
.split(Self::word_splitter)
|
||||
.next()
|
||||
.unwrap_or("");
|
||||
self.i += word.len();
|
||||
word
|
||||
}
|
||||
pub fn peek_line(&self) -> &str {
|
||||
self.src[self.i..].lines().next().unwrap_or("")
|
||||
}
|
||||
pub fn next_line(&mut self) -> &str {
|
||||
self.end_sections();
|
||||
let line = self.src[self.i..].lines().next().unwrap_or("");
|
||||
self.i += line.len();
|
||||
line
|
||||
}
|
||||
|
||||
pub fn get_pos(&self) -> SourcePos {
|
||||
SourcePos(self.i)
|
||||
}
|
||||
pub fn set_pos(&mut self, new: SourcePos) {
|
||||
self.i = new.0
|
||||
}
|
||||
|
||||
/// Returns a SectionMarker which, when dropped, indicates the end of this section.
|
||||
/// Useful for debugging the parser.
|
||||
pub fn section_begin(&mut self, section: String) -> Arc<String> {
|
||||
#[cfg(debug_assertions)]
|
||||
println!("Section begin: {}", §ion);
|
||||
let arc = Arc::new(section);
|
||||
self.sections.push(SectionMarker {
|
||||
section: Arc::clone(&arc),
|
||||
start: self.get_pos(),
|
||||
end: None,
|
||||
});
|
||||
arc
|
||||
}
|
||||
pub fn sections(&self) -> &Vec<SectionMarker> {
|
||||
&self.sections
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Source {
|
||||
fn drop(&mut self) {
|
||||
self.end_sections()
|
||||
}
|
||||
}
|
||||
|
||||
/// Returned from Source::begin(), this indicates that parsing of
|
||||
/// a certain section has not yet finished.
|
||||
/// Once this is dropped, a section is considered done.
|
||||
pub struct SectionMarker {
|
||||
section: Arc<String>,
|
||||
start: SourcePos,
|
||||
end: Option<SourcePos>,
|
||||
}
|
||||
impl SectionMarker {
|
||||
pub fn section(&self) -> &str {
|
||||
&self.section
|
||||
}
|
||||
pub fn start(&self) -> &SourcePos {
|
||||
&self.start
|
||||
}
|
||||
pub fn end(&self) -> &Option<SourcePos> {
|
||||
&self.end
|
||||
}
|
||||
/// If this is the only remaining SectionMarker for this section,
|
||||
/// this method sets its `end` property.
|
||||
fn checked_end(&mut self, end: SourcePos) {
|
||||
if self.end.is_none() {
|
||||
if Arc::strong_count(&self.section) == 1 {
|
||||
self.end = Some(end);
|
||||
#[cfg(debug_assertions)]
|
||||
println!("Section end : {}", &self.section);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub struct SourcePos(usize);
|
||||
impl SourcePos {
|
||||
fn diff(&self, rhs: &Self) -> usize {
|
||||
rhs.0 - self.0
|
||||
}
|
||||
}
|
||||
199
mers_lib/src/parsing/statements.rs
Executable file
199
mers_lib/src/parsing/statements.rs
Executable file
@@ -0,0 +1,199 @@
|
||||
use std::sync::Arc;
|
||||
|
||||
use super::Source;
|
||||
use crate::{
|
||||
data::{self, Data},
|
||||
program::{self, parsed::MersStatement},
|
||||
};
|
||||
|
||||
pub fn parse(src: &mut Source) -> Result<Option<Box<dyn program::parsed::MersStatement>>, ()> {
|
||||
src.section_begin("statement".to_string());
|
||||
let mut first = if let Some(s) = parse_no_chain(src)? {
|
||||
s
|
||||
} else {
|
||||
return Ok(None);
|
||||
};
|
||||
src.skip_whitespace();
|
||||
match src.peek_word() {
|
||||
":=" => {
|
||||
src.next_word();
|
||||
first = Box::new(program::parsed::init_to::InitTo {
|
||||
target: first,
|
||||
source: parse(src)?.expect("todo"),
|
||||
});
|
||||
}
|
||||
"=" => {
|
||||
src.next_word();
|
||||
first = Box::new(program::parsed::assign_to::AssignTo {
|
||||
target: first,
|
||||
source: parse(src)?.expect("todo"),
|
||||
});
|
||||
}
|
||||
"->" => {
|
||||
src.next_word();
|
||||
first = Box::new(program::parsed::function::Function {
|
||||
arg: first,
|
||||
run: parse(src)?.expect("err: bad eof, fn needs some statement"),
|
||||
});
|
||||
}
|
||||
_ => loop {
|
||||
src.skip_whitespace();
|
||||
if let Some('.') = src.peek_char() {
|
||||
src.next_char();
|
||||
let chained = parse_no_chain(src)?.expect("err: EOF instead of chain");
|
||||
first = Box::new(program::parsed::chain::Chain { first, chained });
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
},
|
||||
}
|
||||
if matches!(src.peek_char(), Some(',' | ';')) {
|
||||
src.next_char();
|
||||
}
|
||||
Ok(Some(first))
|
||||
}
|
||||
/// Assumes the { has already been parsed
|
||||
pub fn parse_block(src: &mut Source) -> Result<program::parsed::block::Block, ()> {
|
||||
Ok(program::parsed::block::Block {
|
||||
statements: parse_multiple(src, '}')?,
|
||||
})
|
||||
}
|
||||
pub fn parse_tuple(src: &mut Source) -> Result<program::parsed::tuple::Tuple, ()> {
|
||||
Ok(program::parsed::tuple::Tuple {
|
||||
elems: parse_multiple(src, ')')?,
|
||||
})
|
||||
}
|
||||
pub fn parse_multiple(src: &mut Source, end: char) -> Result<Vec<Box<dyn MersStatement>>, ()> {
|
||||
src.section_begin("block".to_string());
|
||||
let mut statements = vec![];
|
||||
loop {
|
||||
src.skip_whitespace();
|
||||
if matches!(src.peek_char(), Some(e) if e == end) {
|
||||
src.next_char();
|
||||
break;
|
||||
} else if let Some(s) = parse(src)? {
|
||||
statements.push(s);
|
||||
} else {
|
||||
// EOF
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(statements)
|
||||
}
|
||||
pub fn parse_no_chain(
|
||||
src: &mut Source,
|
||||
) -> Result<Option<Box<dyn program::parsed::MersStatement>>, ()> {
|
||||
src.section_begin("statement no chain".to_string());
|
||||
src.skip_whitespace();
|
||||
match src.peek_char() {
|
||||
Some('{') => {
|
||||
src.next_char();
|
||||
return Ok(Some(Box::new(parse_block(src)?)));
|
||||
}
|
||||
Some('(') => {
|
||||
src.next_char();
|
||||
return Ok(Some(Box::new(parse_tuple(src)?)));
|
||||
}
|
||||
Some('"') => {
|
||||
src.section_begin("string literal".to_string());
|
||||
src.next_char();
|
||||
let mut s = String::new();
|
||||
loop {
|
||||
if let Some(ch) = src.next_char() {
|
||||
if ch == '\\' {
|
||||
s.push(match src.next_char() {
|
||||
Some('\\') => '\\',
|
||||
Some('r') => '\r',
|
||||
Some('n') => '\n',
|
||||
Some('t') => '\t',
|
||||
Some(o) => todo!("err: unknown backslash escape '\\{o}'"),
|
||||
None => todo!("err: eof in backslash escape"),
|
||||
});
|
||||
} else if ch == '"' {
|
||||
break;
|
||||
} else {
|
||||
s.push(ch);
|
||||
}
|
||||
} else {
|
||||
todo!("err: eof in string")
|
||||
}
|
||||
}
|
||||
return Ok(Some(Box::new(program::parsed::value::Value(Data::new(
|
||||
crate::data::string::String(s),
|
||||
)))));
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
Ok(Some(match src.next_word() {
|
||||
"if" => {
|
||||
src.section_begin("if".to_string());
|
||||
Box::new(program::parsed::r#if::If {
|
||||
condition: parse(src)?.expect("err: EOF instead of condition"),
|
||||
on_true: parse(src)?.expect("err: EOF instead of on_true"),
|
||||
on_false: {
|
||||
src.skip_whitespace();
|
||||
if src.peek_word() == "else" {
|
||||
src.section_begin("else".to_string());
|
||||
src.next_word();
|
||||
Some(parse(src)?.expect("err: EOF instead of on_false after else"))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
},
|
||||
})
|
||||
}
|
||||
"loop" => {
|
||||
src.section_begin("loop".to_string());
|
||||
Box::new(program::parsed::r#loop::Loop {
|
||||
inner: parse(src)?.expect("err: EOF instead of inner statement after loop"),
|
||||
})
|
||||
}
|
||||
"switch" => {
|
||||
src.section_begin("loop".to_string());
|
||||
todo!()
|
||||
}
|
||||
"true" => Box::new(program::parsed::value::Value(Data::new(
|
||||
crate::data::bool::Bool(true),
|
||||
))),
|
||||
"false" => Box::new(program::parsed::value::Value(Data::new(
|
||||
crate::data::bool::Bool(false),
|
||||
))),
|
||||
"" => return Ok(None),
|
||||
o => {
|
||||
let o = o.to_string();
|
||||
src.section_begin("literals, variables, and other non-keyword things".to_string());
|
||||
if let Ok(n) = o.parse() {
|
||||
if src.peek_char() == Some('.') {
|
||||
let here = src.get_pos();
|
||||
src.next_char();
|
||||
if let Ok(num) = format!("{o}.{}", src.next_word()).parse() {
|
||||
Box::new(program::parsed::value::Value(Data::new(
|
||||
crate::data::float::Float(num),
|
||||
)))
|
||||
} else {
|
||||
src.set_pos(here);
|
||||
Box::new(program::parsed::value::Value(Data::new(
|
||||
crate::data::int::Int(n),
|
||||
)))
|
||||
}
|
||||
} else {
|
||||
Box::new(program::parsed::value::Value(Data::new(
|
||||
crate::data::int::Int(n),
|
||||
)))
|
||||
}
|
||||
} else {
|
||||
if let Some('&') = o.chars().next() {
|
||||
Box::new(program::parsed::variable::Variable {
|
||||
is_ref: true,
|
||||
var: o[1..].to_string(),
|
||||
})
|
||||
} else {
|
||||
Box::new(program::parsed::variable::Variable {
|
||||
is_ref: false,
|
||||
var: o.to_string(),
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
}))
|
||||
}
|
||||
51
mers_lib/src/parsing/types.rs
Executable file
51
mers_lib/src/parsing/types.rs
Executable file
@@ -0,0 +1,51 @@
|
||||
use super::Source;
|
||||
|
||||
/// multiple types are represented as a `Vec<ParsedType>`.
|
||||
pub enum ParsedType {
|
||||
Tuple(Vec<Vec<Self>>),
|
||||
Type(String),
|
||||
}
|
||||
|
||||
fn parse_single_type(src: &mut Source) -> Result<ParsedType, ()> {
|
||||
src.section_begin("parse single type".to_string());
|
||||
src.skip_whitespace();
|
||||
Ok(match src.peek_char() {
|
||||
// Tuple
|
||||
Some('(') => {
|
||||
src.next_char();
|
||||
src.section_begin("parse tuple's inner types".to_string());
|
||||
let mut inner = vec![];
|
||||
loop {
|
||||
match src.peek_char() {
|
||||
Some(')') => {
|
||||
src.next_char();
|
||||
break;
|
||||
}
|
||||
Some(',') => {
|
||||
src.next_char();
|
||||
}
|
||||
_ => todo!("err: bad char in tuple inner type"),
|
||||
}
|
||||
inner.push(parse_type(src)?);
|
||||
}
|
||||
ParsedType::Tuple(inner)
|
||||
}
|
||||
Some(_) => ParsedType::Type(src.next_word().to_lowercase()),
|
||||
None => todo!(),
|
||||
})
|
||||
}
|
||||
|
||||
fn parse_type(src: &mut Source) -> Result<Vec<ParsedType>, ()> {
|
||||
src.section_begin("parse single type".to_string());
|
||||
let mut types = vec![];
|
||||
loop {
|
||||
types.push(parse_single_type(src)?);
|
||||
src.skip_whitespace();
|
||||
if let Some('/') = src.peek_char() {
|
||||
continue;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(types)
|
||||
}
|
||||
Reference in New Issue
Block a user