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

use grammar::Value;
use grammar::OperatorType;
use grammar::VariableDeclarationKind;
use owned_slice::OwnedSlice;

#[derive(Debug, PartialEq, Clone, Copy)]
pub enum ReservedKind {
    Enum,
    Implements,
    Package,
    Protected,
    Interface,
    Private,
    Public,
}

#[derive(Debug, PartialEq, Clone, Copy)]
pub enum TemplateKind {
    Open(OwnedSlice),
    Closed(OwnedSlice),
}

#[derive(Debug, PartialEq, Clone, Copy)]
pub enum Token {
    EndOfProgram,
    Semicolon,
    Colon,
    Comma,
    ParenOpen,
    ParenClose,
    BracketOpen,
    BracketClose,
    BraceOpen,
    BraceClose,
    Operator(OperatorType),
    Declaration(VariableDeclarationKind),
    Break,
    Do,
    Case,
    Else,
    Catch,
    Export,
    Class,
    Extends,
    Return,
    While,
    Finally,
    Super,
    With,
    Continue,
    For,
    Switch,
    Yield,
    Debugger,
    Function,
    This,
    Default,
    If,
    Throw,
    Import,
    Try,
    Static,
    Reserved(ReservedKind),
    Identifier(OwnedSlice),
    Literal(Value),
    Template(TemplateKind),
}

impl Token {
    pub fn as_word(&self) -> Option<&'static str> {
        use self::Token::*;
        use grammar::OperatorType::*;
        use grammar::Value::*;

        match *self {
            Break                => Some("break"),
            Do                   => Some("do"),
            Case                 => Some("case"),
            Else                 => Some("else"),
            Catch                => Some("catch"),
            Export               => Some("export"),
            Class                => Some("class"),
            Extends              => Some("extends"),
            Return               => Some("return"),
            While                => Some("while"),
            Finally              => Some("finally"),
            Super                => Some("super"),
            With                 => Some("with"),
            Continue             => Some("continue"),
            For                  => Some("for"),
            Switch               => Some("switch"),
            Yield                => Some("yield"),
            Debugger             => Some("debugger"),
            Function             => Some("function"),
            This                 => Some("this"),
            Default              => Some("default"),
            If                   => Some("if"),
            Throw                => Some("throw"),
            Import               => Some("import"),
            Try                  => Some("try"),
            Static               => Some("static"),
            Operator(New)        => Some("new"),
            Operator(Typeof)     => Some("typeof"),
            Operator(Void)       => Some("void"),
            Operator(Delete)     => Some("delte"),
            Operator(Instanceof) => Some("instanceof"),
            Literal(True)        => Some("true"),
            Literal(False)       => Some("false"),
            Literal(Null)        => Some("null"),
            Literal(Undefined)   => Some("undefined"),

            _                    => None,
        }
    }
}