rubic 0.1.1

Ruby parser and compiler
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

use std::fmt;

#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Token
{
    /// A standalone work.
    Word(String),
    /// A symbol.
    Symbol(&'static str),
    /// A string in quotes.
    String(String),
    /// An integer.
    Integer(i64),
    EndOfLine,
    EndOfFile,
}

impl Token
{
    /// The `class` keyword.
    pub fn class() -> Token { Token::Word("class".to_owned()) }
    pub fn module() -> Token { Token::Word("module".to_owned()) }
    pub fn def() -> Token { Token::Word("def".to_owned()) }
    pub fn end() -> Token { Token::Word("end".to_owned()) }

    pub fn left_paren() -> Token { Token::Symbol("(") }
    pub fn right_paren() -> Token { Token::Symbol(")") }

    pub fn less_than() -> Token { Token::Symbol("<") }
    pub fn greater_than() -> Token { Token::Symbol(">") }

    pub fn colon() -> Token { Token::Symbol(":") }
    pub fn comma() -> Token { Token::Symbol(",") }
    pub fn negate() -> Token { Token::Symbol("-") }

    pub fn rocket() -> Token { Token::Symbol("=>") }
    pub fn equals() -> Token { Token::Symbol("=") }

    pub fn is_terminator(&self) -> bool {
        match *self {
            Token::EndOfLine |
                Token::Symbol(";") => true,
            _ => false,
        }
    }
}

impl fmt::Display for Token
{
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Token::Word(ref word) => word.fmt(fmt),
            Token::Symbol(sym) => sym.fmt(fmt),
            Token::String(ref s) => write!(fmt, "\"{}\"", s),
            Token::Integer(i) => i.fmt(fmt),
            Token::EndOfLine => "end-of-line".fmt(fmt),
            Token::EndOfFile => "end-of-file".fmt(fmt),
        }
    }
}