token.hpp

Go to the documentation of this file.

 
#pragma once
#include <cstdint>
#include <sstream>

typedef enum : uint8_t {
    TOK_BOOL,                               
    TOK_CHAR,                               
    TOK_SHORT,                              
    TOK_INT,                                
    TOK_LONG,                               
    TOK_FLOAT,                              
    TOK_DOUBLE,                             
    TOK_NOTH,                               
    
    TOK_LET,                                
    TOK_FUN,                                
    TOK_IF,                                 
    TOK_ELSE,                               
    TOK_FOR,                                
    TOK_DO,                                 
    TOK_WHILE,                              
    TOK_CONTINUE,                           
    TOK_BREAK,                              
    TOK_MODULE,                             
    TOK_PUB,                                
    TOK_PRIV,                               
    TOK_USE,                                
    TOK_CONST,                              
    TOK_RETURN,                             
    TOK_UNSAFE,                             
    TOK_EXTERN,                             
 
    TOK_ID,                                 
    TOK_CHARACTER_LIT,                      
    TOK_SHORT_LIT,                          
    TOK_INT_LIT,                            
    TOK_LONG_LIT,                           
    TOK_FLOAT_LIT,                          
    TOK_DOUBLE_LIT,                         
    TOK_BOOLEAN_LIT,                        
    TOK_STRING_LIT,                         
 
    TOK_OP_PLUS,                            
    TOK_OP_PLUS_EQ,                         
    TOK_OP_INC,                             
    TOK_OP_MINUS,                           
    TOK_OP_MINUS_EQ,                        
    TOK_OP_DEC,                             
    TOK_OP_MULT,                            
    TOK_OP_MULT_EQ,                         
    TOK_OP_DIV,                             
    TOK_OP_DIV_EQ,                          
    TOK_OP_MODULO,                          
    TOK_OP_MODULO_EQ,                       
    TOK_OP_EQ,                              
    TOK_OP_EQ_EQ,                           
    TOK_OP_NOT_EQ_EQ,                       
    TOK_OP_GT,                              
    TOK_OP_GT_EQ,                           
    TOK_OP_LS,                              
    TOK_OP_LS_EQ,                           
    TOK_OP_L_NOT,                           
    TOK_OP_L_AND,                           
    TOK_OP_L_OR,                            
    TOK_OP_REF,                             
    TOK_OP_COMMA,                           
    TOK_OP_DOT,                             
    TOK_OP_COLON,                           
    TOK_OP_SEMICOLON,                       
    TOK_OP_LPAREN,                          
    TOK_OP_RPAREN,                          
    TOK_OP_LBRACE,                          
    TOK_OP_RBRACE,                          
    TOK_OP_LBRACKET,                        
    TOK_OP_RBRACKET,                        
    TOK_OP_QUESTION,                        
    TOK_OP_NEXT                             
} TokenType;

struct Token {
    TokenType type;                         
    std::string value;                      
 
    uint32_t line;                          
    uint32_t column;                        
    std::string file_name;                  
 
    Token(TokenType t, std::string v, uint32_t l, uint32_t c, std::string fn) : type(t), value(v), line(l), column(c), file_name(fn) {}

    std::string to_str() {
        std::stringstream ss;
        switch (type) {
            case TOK_CHAR:
                ss << "char";
                break;
            case TOK_SHORT:
                ss << "short";
                break;
            case TOK_INT:
                ss << "int";
                break;
            case TOK_LONG:
                ss << "long";
                break;
            case TOK_FLOAT:
                ss << "float";
                break;
            case TOK_DOUBLE:
                ss << "double";
                break;
            case TOK_BOOL:
                ss << "bool";
                break;
            case TOK_NOTH:
                ss << "noth";
                break;
            case TOK_LET:
                ss << "let";
                break;
            case TOK_FUN:
                ss << "fun";
                break;
            case TOK_IF:
                ss << "if";
                break;
            case TOK_ELSE:
                ss << "else";
                break;
            case TOK_FOR:
                ss << "for";
                break;
            case TOK_WHILE:
                ss << "while";
                break;
            case TOK_CONST:
                ss << "const";
                break;
            case TOK_RETURN:
                ss << "return";
                break;
            case TOK_ID:
                ss << "id";
                break;
            case TOK_CHARACTER_LIT:
                ss << "char_lit";
                break;
            case TOK_SHORT_LIT:
                ss << "short_lit";
                break;
            case TOK_INT_LIT:
                ss << "int_lit";
                break;
            case TOK_LONG_LIT:
                ss << "long_lit";
                break;
            case TOK_FLOAT_LIT:
                ss << "float_lit";
                break;
            case TOK_DOUBLE_LIT:
                ss << "double_lit";
                break;
            case TOK_BOOLEAN_LIT:
                ss << "bool_lit";
                break;
            case TOK_STRING_LIT:
                ss << "string_lit";
                break;
            case TOK_OP_PLUS:
                ss << "plus_op";
                break;
            case TOK_OP_PLUS_EQ:
                ss << "plus_eq_op";
                break;
            case TOK_OP_MINUS:
                ss << "minus_op";
                break;
            case TOK_OP_MINUS_EQ:
                ss << "minus_eq_op";
                break;
            case TOK_OP_MULT:
                ss << "mult_op";
                break;
            case TOK_OP_MULT_EQ:
                ss << "mult_eq_op";
                break;
            case TOK_OP_DIV:
                ss << "div_op";
                break;
            case TOK_OP_DIV_EQ:
                ss << "div_eq_op";
                break;
            case TOK_OP_MODULO:
                ss << "mod_op";
                break;
            case TOK_OP_MODULO_EQ:
                ss << "mod_eq_op";
                break;
            case TOK_OP_EQ:
                ss << "eq_op";
                break;
            case TOK_OP_EQ_EQ:
                ss << "eq_eq_op";
                break;
            case TOK_OP_NOT_EQ_EQ:
                ss << "not_eq_eq_op";
                break;
            case TOK_OP_GT:
                ss << "gt_op";
                break;
            case TOK_OP_GT_EQ:
                ss << "gt_eq_op";
                break;
            case TOK_OP_LS:
                ss << "ls_op";
            case TOK_OP_LS_EQ:
                ss << "ls_eq_op";
                break;
            case TOK_OP_L_NOT:
                ss << "l_not_op";
                break;
            case TOK_OP_L_AND:
                ss << "l_and_op";
                break;
            case TOK_OP_L_OR:
                ss << "l_or_op";
                break;
            case TOK_OP_COMMA:
                ss << "comma";
                break;
            case TOK_OP_DOT:
                ss << "dot";
                break;
            case TOK_OP_COLON:
                ss << "colon";
                break;
            case TOK_OP_SEMICOLON:
                ss << "semicolon";
                break;
            case TOK_OP_LPAREN:
                ss << "l_paren";
                break;
            case TOK_OP_RPAREN:
                ss << "r_paren";
                break;
            case TOK_OP_LBRACE:
                ss << "l_brace";
                break;
            case TOK_OP_RBRACE:
                ss << "r_brace";
                break;
            case TOK_OP_LBRACKET:
                ss << "l_bracket";
                break;
            case TOK_OP_RBRACKET:
                ss << "r_bracket";
                break;
            case TOK_OP_QUESTION:
                ss << "question";
                break;
            case TOK_OP_NEXT:
                ss << "next";
                break;
            default:
                ss << "<unknown>";
                break;
        }
        ss << " : '" << value << "' (" << column << ':' << line << ')';
        return ss.str();
    }
};