rlisp 0.2.0

experimental lisp interpreter in rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

// mod crate::lexer;

//
// use lexer::Lexer;

use crate::lexer::Keyword;
use crate::lexer::Lexer;
use crate::lexer::Operation;
use crate::lexer::Token;
use crate::node;
use std::iter::Peekable;

pub struct Parser {
    lexer: Peekable<Lexer>,
    pub exprs: Vec<node::Expr>,
}

impl Parser {
    pub fn new(lexer: Lexer) -> Parser {
        Parser {
            lexer: lexer.peekable(),
            exprs: Vec::new(),
        }
    }

    pub fn parse(&mut self) -> Result<(), &'static str> {
        self.parse_block()?;

        Ok(())
    }

    fn parse_block(&mut self) -> Result<(), &'static str> {
        while let Some(token) = self.lexer.next() {
            if token == Token::Lparen {
                let expr = self.parse_expr()?;
                self.exprs.push(expr);
            } else {
                return Err("it expect LParen in parse_block");
            }
        }

        Ok(())
    }

    fn parse_expr(&mut self) -> Result<node::Expr, &'static str> {
        if let Some(token) = self.lexer.peek() {
            match token {
                Token::Operation(_) | Token::Keyword(_) => return self.parse_call(),
                _ => self.parse_list(),
            }
        } else {
            Err("no token in parse_expr")
        }
    }

    fn parse_call(&mut self) -> Result<node::Expr, &'static str> {
        let func_name: node::FuncName;

        func_name = match self.lexer.next().unwrap() {
            Token::Operation(Operation::Plus) => node::FuncName::Plus,
            Token::Keyword(Keyword::Let) => node::FuncName::Let,
            Token::Keyword(Keyword::Print) => node::FuncName::Print,
            _ => return Err("func name invalid in parse_call"),
        };

        Ok(node::Expr::Call(node::Call {
            func_name: func_name,
            args: self.parse_args()?,
        }))
    }

    fn parse_args(&mut self) -> Result<Vec<node::Value>, &'static str> {
        let mut args: Vec<node::Value> = Vec::new();

        while let Some(token) = self.lexer.peek() {
            if *token == Token::Rparen {
                self.lexer.next();
                break;
            }

            args.push(self.parse_arg()?);
        }

        Ok(args)
    }

    fn parse_arg(&mut self) -> Result<node::Value, &'static str> {
        if let Some(token) = self.lexer.next() {
            match token {
                Token::Lparen => Ok(node::Value::Expr(self.parse_expr()?)),
                Token::Identifier(identifier) => {
                    Ok(node::Value::Identifier(String::from(identifier)))
                }
                Token::Integer(number) => Ok(node::Value::Number(number)),
                Token::Literal(literal) => Ok(node::Value::Literal(literal)),
                _ => Err("parse_arg did not match"),
            }
        } else {
            Err("did not match")
        }
    }

    fn parse_list(&mut self) -> Result<node::Expr, &'static str> {
        let mut list: Vec<node::Value> = Vec::new();

        while let Some(token) = self.lexer.peek() {
            if *token == Token::Rparen {
                self.lexer.next();
                break;
            }

            match self.parse_arg() {
                Ok(arg) => list.push(arg),
                Err(e) => return Err(e),
            }
        }

        Ok(node::Expr::List(list))
    }
}