gaybuild/src/ast/mod.rs

pub(crate) mod tree;

use crate::error::Error;
use crate::lex::token;
use crate::lex::token::Token;
use crate::lex::Lexer;

use std::fs;
use std::io;

enum Scope {
    File,
    Target,
    DepList,
    SourceList,
}

struct Parser {
    lexer: Lexer,
    scope: Vec<Scope>,
    filename: String,
}

pub fn parse(filename: String) -> io::Result<Result<tree::Node, Error>> {
    let raw: String = fs::read_to_string(filename.clone())?;
    let mut p = Parser::new(filename, raw);
    Ok(p.parse_file())
}

impl Parser {
    pub fn new(filename: String, raw: String) -> Parser {
        let lexer = Lexer::new(filename.clone(), raw);
        Parser {
            lexer,
            scope: Vec::new(),
            filename,
        }
    }

    pub fn parse_file(&mut self) -> Result<tree::Node, Error> {
        let mut nodes = Vec::new();
        self.scope.push(Scope::File);

        while let Some(result) = self.lexer.next() {
            let token = result?;
            let node = match token.kind {
                token::Kind::TargetKeyword => self.parse_target(),
                token::Kind::SetKeyword => self.parse_set_expr(),
                _ => self.syntax_error(format!("Unexpected token {}", token.kind), &token),
            }?;
            nodes.push(node);
        }

        Ok(tree::Node::File {
            name: self.filename.clone(),
            content: nodes,
        })
    }

    fn parse_target(&mut self) -> Result<tree::Node, Error> {
        self.scope.push(Scope::Target);
        let name_token = self.lexer.expect_kind(token::Kind::Ident)?;
        self.lexer.expect_kind(token::Kind::OBrace)?;

        let mut children = Vec::new();

        while let Some(result) = self.lexer.next() {
            let token = result?;
            match token.kind {
                token::Kind::DependKeyword => children.push(self.parse_depend_expr()?),
                token::Kind::TypeKeyword => children.push(self.parse_type_expr()?),
                token::Kind::SourceKeyword => children.push(self.parse_source_expr()?),
                token::Kind::SetKeyword => children.push(self.parse_set_expr()?),
                token::Kind::CBrace => break,
                _ => {
                    return self.syntax_error(format!("Unexpected token \"{}\"", token.raw), &token)
                }
            }
        }

        self.scope.pop();
        Ok(tree::Node::Target {
            name: Box::new(tree::Node::Ident(name_token.raw)),
            content: children,
        })
    }

    fn parse_depend_expr(&mut self) -> Result<tree::Node, Error> {
        self.scope.push(Scope::DepList);
        let rvalue = self.parse_rvalue(&[token::Kind::Semi])?;
        self.scope.pop();
        Ok(tree::Node::DepList(Box::new(rvalue)))
    }

    fn parse_set_expr(&mut self) -> Result<tree::Node, Error> {
        let lvalue = self.parse_lvalue(&[token::Kind::Eq])?;
        let rvalue = self.parse_rvalue(&[token::Kind::Semi])?;
        Ok(tree::Node::SetExpr {
            name: Box::new(lvalue),
            val: Box::new(rvalue),
        })
    }

    fn parse_type_expr(&mut self) -> Result<tree::Node, Error> {
        let rvalue = self.parse_rvalue(&[token::Kind::Semi])?;
        Ok(tree::Node::TypeExpr(Box::new(rvalue)))
    }

    fn parse_source_expr(&mut self) -> Result<tree::Node, Error> {
        self.scope.push(Scope::SourceList);
        let rvalue = self.parse_rvalue(&[token::Kind::Semi])?;
        self.scope.pop();
        Ok(tree::Node::SourceList(Box::new(rvalue)))
    }

    fn parse_array(&mut self) -> Result<tree::Node, Error> {
        let mut elements = Vec::new();
        while let Some(result) = self.lexer.peek() {
            if result?.kind == token::Kind::CBracket {
                self.lexer.next();
                break;
            } else {
                elements.push(self.parse_rvalue(&[token::Kind::Comma, token::Kind::CBracket])?);
            }
        }
        Ok(tree::Node::Array(elements))
    }

    fn parse_lvalue(&mut self, terminators: &[token::Kind]) -> Result<tree::Node, Error> {
        // this will be expanded when we have array accesses and similar stuff
        let ident_token = self.lexer.expect_kind(token::Kind::Ident)?;
        self.lexer.expect_kinds(terminators)?;
        Ok(tree::Node::Ident(ident_token.raw))
    }

    fn parse_rvalue(&mut self, terminators: &[token::Kind]) -> Result<tree::Node, Error> {
        // this will also be expanded to support more complex expressions, naturally
        let token = self.lexer.require_next()?;
        let node = match token.kind {
            token::Kind::Ident => Ok(tree::Node::Ident(token.raw)),
            token::Kind::IntLiteral => Ok(tree::Node::Int(token.raw.parse().unwrap())),
            token::Kind::StringLiteral => Ok(tree::Node::String(token.raw)),
            token::Kind::OBracket => self.parse_array(),
            k => self.syntax_error(format!("Unexpected {}", k), &token),
        }?;
        self.lexer.expect_kinds(terminators)?;
        Ok(node)
    }

    fn syntax_error<T>(&self, msg: String, token: &Token) -> Result<T, Error> {
        Err(Error::syntax_error(token.pos.clone(), msg))
    }
}