cpp-programming

Simple C++ programs
git clone git://git.laack.co/cpp-programming.git
Log | Files | Refs | README

token.cpp (3755B)


      1 enum class TokenType {
      2 
      3     LEFT_PAREN, RIGHT_PAREN, LEFT_BRACE, RIGHT_BRACE,
      4     COMMA, DOT, MINUS, PLUS, SEMICOLON, SLASH, STAR,
      5 
      6     BANG, BANG_EQUAL,
      7     EQUAL, EQUAL_EQUAL,
      8     GREATER, GREATER_EQUAL,
      9     LESS, LESS_EQUAL,
     10 
     11     IDENTIFIER, STRING, NUMBER,
     12 
     13     AND, CLASS, ELSE, FALSE, FUN, FOR, IF, NIL, OR,
     14     PRINT, RETURN, SUPER, THIS, TRUE, VAR, WHILE,
     15 
     16     EOF_
     17 };
     18 
     19 class Literal {
     20     public:
     21         std::string repString;
     22         double repNum;
     23         bool isString;
     24         Literal(std::string st = "", double num = 0.0, bool isSt = true) {
     25             repString = st;
     26             isString = isSt;
     27             repNum = num;
     28         }
     29         std::string toString() {
     30             if(isString) {
     31                 return repString;
     32             } else {
     33                 return std::to_string(repNum);
     34             }
     35         }
     36 };
     37 
     38 std::string typeAsString(TokenType type) {
     39     switch (type) {
     40         case TokenType::LEFT_PAREN:
     41             return "LEFT_PAREN";
     42         case TokenType::RIGHT_PAREN:
     43             return "RIGHT_PAREN";
     44         case TokenType::LEFT_BRACE:
     45             return "LEFT_BRACE";
     46         case TokenType::RIGHT_BRACE:
     47             return "RIGHT_BRACE";
     48         case TokenType::COMMA:
     49             return "COMMA";
     50         case TokenType::DOT:
     51             return "DOT";
     52         case TokenType::MINUS:
     53             return "MINUS";
     54         case TokenType::PLUS:
     55             return "PLUS";
     56         case TokenType::SEMICOLON:
     57             return "SEMICOLON";
     58         case TokenType::SLASH:
     59             return "SLASH";
     60         case TokenType::STAR:
     61             return "STAR";
     62         case TokenType::BANG:
     63             return "BANG";
     64         case TokenType::BANG_EQUAL:
     65             return "BANG_EQUAL";
     66         case TokenType::EQUAL:
     67             return "EQUAL";
     68         case TokenType::EQUAL_EQUAL:
     69             return "EQUAL_EQUAL";
     70         case TokenType::GREATER:
     71             return "GREATER";
     72         case TokenType::GREATER_EQUAL:
     73             return "GREATER_EQUAL";
     74         case TokenType::LESS:
     75             return "LESS";
     76         case TokenType::LESS_EQUAL:
     77             return "LESS_EQUAL";
     78         case TokenType::IDENTIFIER:
     79             return "IDENTIFIER";
     80         case TokenType::STRING:
     81             return "STRING";
     82         case TokenType::NUMBER:
     83             return "NUMBER";
     84         case TokenType::AND:
     85             return "AND";
     86         case TokenType::CLASS:
     87             return "CLASS";
     88         case TokenType::ELSE:
     89             return "ELSE";
     90         case TokenType::FALSE:
     91             return "FALSE";
     92         case TokenType::FUN:
     93             return "FUN";
     94         case TokenType::FOR:
     95             return "FOR";
     96         case TokenType::IF:
     97             return "IF";
     98         case TokenType::NIL:
     99             return "NIL";
    100         case TokenType::OR:
    101             return "OR";
    102         case TokenType::PRINT:
    103             return "PRINT";
    104         case TokenType::RETURN:
    105             return "RETURN";
    106         case TokenType::SUPER:
    107             return "SUPER";
    108         case TokenType::THIS:
    109             return "THIS";
    110         case TokenType::TRUE:
    111             return "TRUE";
    112         case TokenType::VAR:
    113             return "VAR";
    114         case TokenType::WHILE:
    115             return "WHILE";
    116         case TokenType::EOF_:
    117             return "EOF";
    118     }
    119     return "UNKNOWN";
    120 }
    121 
    122 class Token {
    123     public:
    124         TokenType type;
    125         std::string lexeme;
    126         Literal literal;
    127         int line;
    128         Token() {
    129         }
    130         Token(TokenType tp, std::string lex, Literal li, int ln) {
    131             type = tp;
    132             lexeme = lex;
    133             literal = li;
    134             line = ln;
    135         }
    136 
    137         std::string toString() {
    138             return typeAsString(type) + " " + lexeme + " " + literal.toString();
    139         }
    140 };