morgana_core/syntax/parser/rules/

mod.rs

macro_rules! want {
    ($self: ident, $test: expr, $msg: expr) => {
        match $self.lex.peek() {
            Err(e) => {
                log::debug!("want in {}, found error {}", function_name!(), e);
                // We are taking into consideration the lexing error
                // arising from inspecting the next token, and we can
                // conclude its analysis by simply eating the token.
                _ = $self.lex.eat();
                // --

                Err(e)
            }
            Ok(t) => {
                log::debug!(
                    "want in {}, found token {} @ {}",
                    function_name!(),
                    t.kind,
                    t.range
                );
                let f = $test;
                if f(t.kind.clone()) {
                    _ = $self.lex.eat();
                    Ok(())
                } else {
                    Err(anyhow::anyhow!(
                        crate::syntax::parser::error::ParseError::new(
                            format!(concat!("expected ", $msg, ", found {}"), t.kind),
                            t.range
                        )
                    ))
                }
            }
        }
    };

    ($self: ident, $kind: ident, $var: ident, $msg: expr) => {
        match $self.lex.peek() {
            Err(e) => {
                // See above
                _ = $self.lex.eat();
                // --

                Err(e)
            }

            Ok(t) => match t.kind {
                crate::syntax::lexer::token::TokenKind::$kind($var) => {
                    _ = $self.lex.eat();
                    Ok($var)
                }
                _ => Err(anyhow::anyhow!(
                    crate::syntax::parser::error::ParseError::new(
                        format!(concat!("expected ", $msg, ", found {}"), t.kind),
                        t.range
                    )
                )),
            },
        }
    };
}

macro_rules! ifis {
    ($self: ident, $kind: ident, $var: ident, $then: expr) => {
        if let Ok(t) = $self.lex.peek() {
            log::trace!("ifis -- ok");
            match t.kind {
                crate::syntax::lexer::token::TokenKind::$kind(
                    crate::syntax::lexer::token::$kind::$var,
                ) => {
                    _ = $self.lex.eat();
                    Some($then)
                }
                _ => None,
            }
        } else {
            log::trace!("ifis -- Err");
            None
        }
    };
}

macro_rules! route {
    ($self: ident, $msg:expr, ($($case1:expr),+), $then1:ident,
      $(($($case:expr),+), $then:ident),*) => {
        match $self.lex.peek() {
            Err(e) => {
                _ = $self.lex.eat();
                Err(e)
            }
            Ok(t) => {
                if t.kind.is_in(vec![$($case1),*].into_iter().collect()) {
                    Ok($self.$then1())
                }

                $(
                    else if t.kind.is_in(vec![$($case),*].into_iter().collect()) {
                        Ok($self.$then())
                    }
                )*

                else {
                    Err(anyhow::anyhow!(crate::syntax::parser::error::ParseError::new(
                        format!("expected {}, found {}", $msg, t.kind),
                        t.range
                    )))
                }

            }
        }
    };

    ($self: ident, $msg:expr, $case1:expr, $then1:ident,
      $($case:expr, $then:ident),*) => {
        match $self.lex.peek() {
            Err(e) => {
                _ = $self.lex.eat();
                Err(e)
            }
            Ok(t) => {

                if ($case1)(t.kind.clone()) {
                    Ok($self.$then1())
                }

                $(
                    else if ($case)(t.kind.clone()) {
                        Ok($self.$then())
                    }
                )*

                else {
                    Err(anyhow::anyhow!(crate::syntax::parser::error::ParseError::new(
                        format!("expected {}, found {}", $msg, t.kind),
                        t.range
                    )))
                }

            }
        }
    };


}

use super::grammar::ast::{ConcreteMorg, Statement};

use crate::syntax::{
    lexer::token::*,
    parser::{error::ParseError, grammar::ast::*, Parser},
};

use stdext::function_name;

mod constructor;
mod expression;
mod statement;

impl Parser {
    pub(super) fn morg(&mut self) -> ConcreteMorg {
        log::trace!("{}", function_name!());

        let morg_name: Option<MorgName> = ifis!(self, Keyword, Morg, self.morg_name());
        log::trace!("morg name is {:?}", morg_name);

        let start_statement: Option<StartStatement> =
            ifis!(self, Keyword, Start, self.start_statement());
        log::trace!("start statement is {:?}", morg_name);

        let mut res = ConcreteMorg {
            morg_name,
            start_statement,
            statements: vec![],
        };

        loop {
            match self.lex.peek() {
                Err(e) => {
                    _ = self.lex.eat();
                    self.errs.push(e);
                }
                Ok(t) => match t.kind {
                    TokenKind::EOF => break,
                    TokenKind::Keyword(crate::syntax::lexer::token::Keyword::Node)
                    | TokenKind::Keyword(crate::syntax::lexer::token::Keyword::Skip)
                    | TokenKind::Keyword(crate::syntax::lexer::token::Keyword::Squash)
                    | TokenKind::Keyword(crate::syntax::lexer::token::Keyword::Special) => {
                        res.statements.push(self.statement())
                    }
                    _ => {
                        log::trace!("unexpected from morg: {} @ {}", t.kind, t.range);
                        self.errs.push(anyhow::anyhow!(ParseError::new(
                            format!("unexpected token {}", t.kind),
                            t.range
                        )));
                        _ = self.lex.eat();
                    }
                },
            }
        }

        res
    }

    fn morg_name(&mut self) -> MorgName {
        log::trace!("{}", function_name!());
        want!(self, Identifier, id, "identifier to name the Morg,")
    }

    fn start_statement(&mut self) -> StartStatement {
        log::trace!("{}", function_name!());
        want!(
            self,
            Identifier,
            id,
            "identifier to name the initial symbol"
        )
    }

    fn statement(&mut self) -> Statement {
        log::trace!("{} with token {:?}", function_name!(), self.lex.peek());
        match self.lex.peek() {
            Ok(t) => match t.kind {
                TokenKind::Keyword(crate::syntax::lexer::token::Keyword::Node)
                | TokenKind::Keyword(crate::syntax::lexer::token::Keyword::Squash) => {
                    Statement::Definition(self.definition())
                }
                TokenKind::Keyword(crate::syntax::lexer::token::Keyword::Skip) => {
                    Statement::Skip(self.skip())
                }
                TokenKind::Keyword(crate::syntax::lexer::token::Keyword::Special) => {
                    Statement::Special(self.special())
                }

                _ => unreachable!(),
            },
            Err(_) => unreachable!(),
        }
    }
}