monkey-rs 0.1.0

/*!
# Token

`token` defines the tokens accepted from a Monkey source file.
*/
use std::fmt;

/// Defines the tokens in the token stream generated by the lexer.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Token {
    /* Reserved */
    /// An illegal, unrecognized token.
    Illegal,
    /// Token marking the end of a file stream.
    Eof,

    /* Identifiers and literals */
    /// Identifier, e.g., `add`, `foobar`, `x`, `y`, ...
    Ident(String),
    /// Integer literal, e.g., `[0-9]`
    Int(i32),
    /// A string literal, e.g., \"Hello, world!\"
    String(String),

    /* Operators */
    /// Assignment operator `=`
    Assign,
    /// Summation arithmetic operator `+`
    Plus,
    /// Subtraction arithmetic operator `-`
    Minus,
    /// Negation logical operator `!`
    Bang,
    /// Multiplication arithmetic operator `*`
    Asterisk,
    /// Division arithmetic operator `/`
    Slash,
    /// Less than logical operator `<`
    Lt,
    /// Greater than logical operator `>`
    Gt,
    /// Equality logical operator `==`
    Eq,
    /// Inequality logical operator `!=`
    NotEq,

    /* Delimiters */
    /// Comma `,`
    Comma,
    /// Semicolon `;`
    Semicolon,
    /// Colon `:`
    Colon,

    /// Left parenthesis `(`
    LParen,
    /// Right parenthesis `)`
    RParen,

    /// Left curly brace `{{`
    LBrace,
    /// Right curly bracket `}}`
    RBrace,

    /// Left square bracket `[`
    LBracket,
    /// Right square bracket `]`
    RBracket,

    /* Keywords */
    /// `fn` keyword
    Function,
    /// `let` keyword
    Let,
    /// `true` keyword
    True,
    /// `false` keyword
    False,
    /// `if` keyword
    If,
    /// `else` keyword
    Else,
    /// `return` keyword
    Return,
}

impl fmt::Display for Token {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Token::Illegal => write!(f, "ILLEGAL"),
            Token::Eof => write!(f, "EOF"),
            Token::Ident(id) => write!(f, "{}", id),
            Token::Int(i) => write!(f, "{}", i),
            Token::Assign => write!(f, "="),
            Token::Plus => write!(f, "+"),
            Token::Minus => write!(f, "-"),
            Token::Bang => write!(f, "!"),
            Token::Asterisk => write!(f, "*"),
            Token::Slash => write!(f, "/"),
            Token::Lt => write!(f, "<"),
            Token::Gt => write!(f, ">"),
            Token::Eq => write!(f, "=="),
            Token::NotEq => write!(f, "!="),
            Token::Comma => write!(f, ","),
            Token::Semicolon => write!(f, ";"),
            Token::LParen => write!(f, "("),
            Token::RParen => write!(f, ")"),
            Token::LBrace => write!(f, "{{"),
            Token::RBrace => write!(f, "}}"),
            Token::Function => write!(f, "FUNCTION"),
            Token::Let => write!(f, "LET"),
            Token::True => write!(f, "TRUE"),
            Token::False => write!(f, "FALSE"),
            Token::If => write!(f, "IF"),
            Token::Else => write!(f, "ELSE"),
            Token::Return => write!(f, "RETURN"),
            Token::String(str) => write!(f, "{}", str),
            Token::LBracket => write!(f, "["),
            Token::RBracket => write!(f, "]"),
            Token::Colon => write!(f, ":"),
        }
    }
}

/// Return the token associated with a raw identifier. If the identifier is not
/// associated with a defined keyword, (e.g., a user-defined identifier),
/// defaults to `Token::Ident`.
pub fn lookup_ident(ident: &str) -> Token {
    match ident {
        /* keywords */
        "fn" => Token::Function,
        "let" => Token::Let,
        "true" => Token::True,
        "false" => Token::False,
        "if" => Token::If,
        "else" => Token::Else,
        "return" => Token::Return,

        /* user-defined identifier */
        _ => Token::Ident(ident.to_string()),
    }
}