aboutsummaryrefslogtreecommitdiff
path: root/src/frontend/parse.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/frontend/parse.rs')
-rw-r--r--src/frontend/parse.rs297
1 files changed, 297 insertions, 0 deletions
diff --git a/src/frontend/parse.rs b/src/frontend/parse.rs
new file mode 100644
index 0000000..c525982
--- /dev/null
+++ b/src/frontend/parse.rs
@@ -0,0 +1,297 @@
+use std::fmt;
+
+use crate::frontend::lex::*;
+use crate::frontend::ast::*;
+use crate::frontend::ast::Binding::*;
+use crate::frontend::ast::Control::*;
+use crate::frontend::ast::Pattern::*;
+use Token::*;
+use Literal::*;
+use Punctuation::*;
+
+type Input = std::iter::Peekable<std::vec::IntoIter<Token>>;
+
+#[derive(Clone, Copy)]
+struct State {
+ depth: usize,
+ step: usize
+}
+
+impl State {
+ fn indent(&self) -> State {
+ State { depth: self.depth + self.step, step: self.step }
+ }
+ fn dedent(&self) -> State {
+ State { depth: self.depth - self.step, step: self.step }
+ }
+}
+
+/// Convert a basic TokenStream into an AbstractSyntaxTree
+pub fn astify(input: TokenStream, name: &str) -> Result<Expr> {
+ let mut input = input.into_iter().peekable();
+ let body = parse_body(&mut input, State { depth: 0, step: 0 })?;
+ Ok(Expr::Binding(Module{ id: name.to_string(), body }))
+}
+
+/// Parse a series of Exprs, for ex. the body of a function.
+fn parse_body(input: &mut Input, state: State) -> Result<Vec<Expr>> {
+ let mut res = Vec::new();
+ while input.peek() == Some(&Indent(state.depth)) {
+ input.next();
+ res.push(parse_expr(input, state)?);
+ }
+ Ok(res)
+}
+
+/// Expr ::= Let | Var | Const | Func | Type |
+/// Mod | Import | Block | Static |
+/// For | While | Loop | If | When | Try | Match
+fn parse_expr(input: &mut Input, state: State) -> Result<Expr> {
+ use Keyword::*;
+ match input.next() {
+ Some(Key(word)) => match word {
+ Pub => {
+ match input.next() {
+ Some(Key(word)) => match word {
+ Const => parse_const(input, state, true),
+ Func => parse_funcdecl(input, state, true),
+ Type => parse_typedecl(input, state, true),
+ Mod => parse_mod(input, state, true),
+ _ => return Err("unrecognized keyword following pub".into()),
+ }
+ Some(_) => return Err("unrecognized thing following pub".into()),
+ None => return Err("end of input".into()),
+ }
+ },
+ Let => parse_let(input, state),
+ Var => parse_var(input, state),
+ Const => parse_const(input, state, false),
+ Func => parse_funcdecl(input, state, false),
+ Type => parse_typedecl(input, state, false),
+ Mod => parse_mod(input, state, false),
+ From => parse_import(input, state, true),
+ Import => parse_import(input, state, false),
+ Block => parse_block(input, state),
+ Static => parse_static(input, state),
+ For => parse_for(input, state),
+ While => parse_while(input, state),
+ Loop => parse_loop(input, state),
+ If => parse_if(input, state),
+ When => parse_when(input, state),
+ Try => parse_try(input, state),
+ Match => parse_match(input, state),
+ _ => return Err("invalid keyword starting expression".into()),
+ },
+ _ => todo!(), // what can i do with this?? match line here
+ }
+}
+
+/// Let ::= 'let' Pattern Annotation? '=' Expr
+fn parse_let(input: &mut Input, state: State) -> Result<Expr> {
+ let id = parse_pattern(input, state)?;
+ let mut kind = None;
+ if let Some(Sep(Colon)) = input.peek() {
+ input.next();
+ kind = Some(parse_typedesc(input, state)?);
+ }
+ if input.next() != Some(Sep(Equals)) {
+ return Err("= not following binding".into())
+ }
+ let value = Box::new(parse_expr(input, state)?);
+ Ok(Expr::Binding(Let { id, kind, value }))
+}
+/// Var ::= 'var' Pattern Annotation? ('=' Expr)?
+fn parse_var(input: &mut Input, state: State) -> Result<Expr> {
+ let id = parse_pattern(input, state)?;
+ let mut kind = None;
+ if let Some(Sep(Colon)) = input.peek() {
+ input.next();
+ kind = Some(parse_typedesc(input, state)?);
+ }
+ let mut value = None;
+ if input.next() != Some(Sep(Equals)) {
+ value = Some(Box::new(parse_expr(input, state)?));
+ }
+ Ok(Expr::Binding(Var { id, kind, value }))
+}
+// Const ::= 'pub'? 'const' Pattern Annotation? '=' Expr
+fn parse_const(input: &mut Input, state: State, public: bool) -> Result<Expr> {
+ let id = parse_pattern(input, state)?;
+ let mut kind = None;
+ if let Some(Sep(Colon)) = input.peek() {
+ input.next();
+ kind = Some(parse_typedesc(input, state)?);
+ }
+ if input.next() != Some(Sep(Equals)) {
+ return Err("= not following binding".into())
+ }
+ let value = Box::new(parse_expr(input, state)?);
+ Ok(Expr::Binding(Const { public, id, kind, value }))
+}
+// Func ::= 'pub'? ('func' | 'proc') Ident Generics? Parameters? (':' TypeDesc) '=' Body
+fn parse_funcdecl(input: &mut Input, state: State, public: bool) -> Result<Expr> { todo!() }
+// TypeDecl ::= 'pub'? 'type' Pattern Generics? '=' 'distinct'? 'ref'? TypeDesc
+fn parse_typedecl(input: &mut Input, state: State, public: bool) -> Result<Expr> {
+ let pattern = parse_pattern(input, state)?;
+ todo!()
+}
+// Mod ::= 'pub'? 'mod' Ident ':' Body
+fn parse_mod(input: &mut Input, state: State, public: bool) -> Result<Expr> {
+ match input.next() {
+ Some(Word(id)) => {
+ match input.next() {
+ Some(Sep(Colon)) => {
+ let body = parse_body(input, state.indent())?;
+ Ok(Expr::Binding(Module { id, body }))
+ },
+ _ => return Err("unexpected token following mod label".into()),
+ }
+ },
+ _ => return Err("unexpected thing following mod keyword".into()),
+ }
+}
+
+// Import ::= ('from' Ident)? 'import' Ident (',' Ident)* ('as' Ident)?
+fn parse_import(input: &mut Input, state: State, from_scope: bool) -> Result<Expr> {
+ let mut from = None;
+ if from_scope {
+ match input.next() {
+ Some(Word(id)) => from = Some(id),
+ _ => return Err("identifier not following from keyword".into())
+ }
+ if input.next() != Some(Key(Keyword::Import)) {
+ return Err("expected import to follow from".into())
+ }
+ }
+ todo!()
+}
+// Block ::= 'block' Ident? ':' Body
+fn parse_block(input: &mut Input, state: State) -> Result<Expr> { // todo: body + offset
+ match input.next() {
+ Some(Sep(Colon)) => {
+ let id = None;
+ let body = parse_body(input, state.indent())?;
+ Ok(Expr::Control(Block { id, body }))
+ },
+ Some(Word(label)) => {
+ match input.next() {
+ Some(Sep(Colon)) => {
+ let id = Some(label);
+ let body = parse_body(input, state.indent())?;
+ Ok(Expr::Control(Block { id, body }))
+ },
+ _ => return Err("unexpected token following block label".into()),
+ }
+ },
+ _ => return Err("unexpected thing following block keyword".into()),
+ }
+}
+// Static ::= 'static' ':' Body
+fn parse_static(input: &mut Input, state: State) -> Result<Expr> {
+ if input.next() != Some(Sep(Colon)) {
+ return Err("colon must follow static invocation".into());
+ }
+ let body = parse_body(input, state.indent())?;
+ Ok(Expr::Control(Static { body }))
+}
+
+// For ::= 'for' Pattern 'in' Expr ':' Body
+fn parse_for(input: &mut Input, state: State) -> Result<Expr> {
+ let binding = parse_pattern(input, state)?;
+ if input.next() != Some(Key(Keyword::In)) {
+ return Err("expected in keyword after for pattern".into());
+ }
+ let range = Box::new(parse_expr(input, state)?);
+ if input.next() != Some(Sep(Colon)) {
+ return Err("expected colon after in expression".into());
+ }
+ let body = parse_body(input, state.indent())?;
+ Ok(Expr::Control(For { binding, range, body }))
+}
+// While ::= 'while' Expr ':' Body
+fn parse_while(input: &mut Input, state: State) -> Result<Expr> {
+ let cond = Box::new(parse_expr(input, state)?);
+ if input.next() != Some(Sep(Colon)) {
+ return Err("expected colon after while keyword".into());
+ }
+ let body = parse_body(input, state.indent())?;
+ Ok(Expr::Control(While { cond, body }))
+}
+// Loop ::= 'loop' ':' Body
+fn parse_loop(input: &mut Input, state: State) -> Result<Expr> {
+ if input.next() != Some(Sep(Colon)) {
+ return Err("expected colon after loop keyword".into());
+ }
+ let body = parse_body(input, state.indent())?;
+ Ok(Expr::Control(Loop { body }))
+}
+
+// If ::= 'if' Expr ':' Body ('elif' Expr ':' Body)* ('else' ':' Body)?
+fn parse_if(input: &mut Input, state: State) -> Result<Expr> {
+ let mut branches = Vec::new();
+ branches.push(parse_cond_branch(input, state)?);
+ while input.peek() == Some(&Key(Keyword::Elif)) {
+ input.next();
+ branches.push(parse_cond_branch(input, state)?);
+ }
+ let mut else_body = None;
+ if input.peek() == Some(&Key(Keyword::Else)) {
+ input.next();
+ else_body = Some(parse_body(input, state.indent())?);
+ }
+ Ok(Expr::Control(If { branches, else_body }))
+}
+// When ::= 'when' Expr ':' Body ('elif' Expr ':' Body)* ('else' ':' Body)?
+fn parse_when(input: &mut Input, state: State) -> Result<Expr> {
+ let mut branches = Vec::new();
+ branches.push(parse_cond_branch(input, state)?);
+ while input.peek() == Some(&Key(Keyword::Elif)) {
+ input.next();
+ branches.push(parse_cond_branch(input, state)?);
+ }
+ let mut else_body = None;
+ if input.peek() == Some(&Key(Keyword::Else)) {
+ input.next();
+ else_body = Some(parse_body(input, state.indent())?);
+ }
+ let mut body = Vec::new();
+ body.push(Expr::Control(If { branches, else_body }));
+ Ok(Expr::Control(Static { body }))
+}
+// Try ::= 'try' ':' Body ('except' Ident (',' Ident)* ':' Body) ('finally' ':' Body)?
+fn parse_try(input: &mut Input, state: State) -> Result<Expr> {
+ if input.next() != Some(Sep(Colon)) {
+ return Err("expected colon after try keyword".into());
+ }
+ let body = parse_body(input, state.indent())?;
+ let catches = Vec::new();
+ while input.peek() == Some(&Key(Keyword::Catch)) {
+ input.next();
+ todo!();
+ }
+ let mut finally = None;
+ if input.peek() == Some(&Key(Keyword::Finally)) {
+ input.next();
+ if input.next() != Some(Sep(Colon)) {
+ return Err("expected colon after try keyword".into());
+ }
+ finally = Some(parse_body(input, state.indent())?);
+ }
+ Ok(Expr::Control(Try { body, catches, finally }))
+}
+// Match ::= 'match' Expr ('of' Pattern (',' Pattern)* ('where' Expr)? ':' Body)+
+fn parse_match(input: &mut Input, state: State) -> Result<Expr> {
+ let item = parse_pattern(input, state)?;
+ let mut branches = Vec::new();
+ while input.peek() == Some(&Key(Keyword::Of)) {
+ input.next();
+ todo!();
+ }
+ Ok(Expr::Control(Match { item, branches }))
+}
+
+fn parse_typedesc(input: &mut Input, state: State) -> Result<Type> { todo!() }
+fn parse_pattern(input: &mut Input, state: State) -> Result<Pattern> { todo!() }
+fn parse_cond_branch(input: &mut Input, state: State) -> Result<CondBranch> { todo!() }
+
+// lex, parse, expand, compile?
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-10-16 13:29:08 +0000