Cleaned up literal

src/Parser/Expression/ExpressionLiteral.cpp

@@ -5,93 +5,59 @@
 #include "Parser/ValueType.h"
 
 shared_ptr<ExpressionLiteral> ExpressionLiteral::expressionLiteralForToken(shared_ptr<Token> token) {
-    switch (token->getKind()) {
+    shared_ptr<ExpressionLiteral> expression = make_shared<ExpressionLiteral>();
-        case TokenKind::INTEGER_CHAR: {
-            string charString = token->getLexme();
-            optional<int> charValue = Utils::charStringToInt(charString);
-            if (!charValue)
-                return nullptr;
-            shared_ptr<ExpressionLiteral> expression = make_shared<ExpressionLiteral>();
-            expression->valueType = ValueType::valueTypeForToken(token, nullptr, 0);
-            expression->sint32Value = *charValue;
-            return expression;
-        }
-        default:
-            return nullptr;
-    }
-}
 
-ExpressionLiteral::ExpressionLiteral():
-Expression(ExpressionKind::LITERAL, nullptr) { }
-
-ExpressionLiteral::ExpressionLiteral(shared_ptr<Token> token):
-Expression(ExpressionKind::LITERAL, nullptr) {
     switch (token->getKind()) {
         case TokenKind::BOOL:
-            boolValue = token->getLexme().compare("true") == 0;
+            expression->boolValue = token->getLexme().compare("true") == 0;
-            valueType = ValueType::valueTypeForToken(token, nullptr, 0);
+            expression->valueType = ValueType::valueTypeForToken(token, nullptr, 0);
             break;
         case TokenKind::INTEGER_DEC: {
             string numString = token->getLexme();
             erase(numString, '_');
-            sint32Value = stoi(numString, nullptr, 10);
+            expression->sint32Value = stoi(numString, nullptr, 10);
-            valueType = ValueType::valueTypeForToken(token, nullptr, 0);
+            expression->valueType = ValueType::valueTypeForToken(token, nullptr, 0);
             break;
         }
         case TokenKind::INTEGER_HEX: {
             string numString = token->getLexme();
             erase(numString, '_');
-            sint32Value = stoi(numString, nullptr, 16);
+            expression->sint32Value = stoi(numString, nullptr, 16);
-            valueType = ValueType::valueTypeForToken(token, nullptr, 0);
+            expression->valueType = ValueType::valueTypeForToken(token, nullptr, 0);
             break;
         }
         case TokenKind::INTEGER_BIN: {
             string numString = token->getLexme();
             erase(numString, '_');
             numString = numString.substr(2, numString.size()-1);
-            sint32Value = stoi(numString, nullptr, 2);
+            expression->sint32Value = stoi(numString, nullptr, 2);
-            valueType = ValueType::valueTypeForToken(token, nullptr, 0);
+            expression->valueType = ValueType::valueTypeForToken(token, nullptr, 0);
             break;
         }
         case TokenKind::INTEGER_CHAR: {
             string charString = token->getLexme();
-
+            optional<int> charValue = Utils::charStringToInt(charString);
-            valueType = ValueType::valueTypeForToken(token, nullptr, 0);
+            if (!charValue)
-            if (charString.length() == 3) {
+                return nullptr;
-                sint32Value = charString[1];
+            
-            } else if (charString.length() == 4 && charString[1] == '\\') {
+            expression->valueType = ValueType::valueTypeForToken(token, nullptr, 0);
-                switch (charString[2]) {
+            expression->sint32Value = *charValue;
-                    case 'b':
+            return expression;
-                        sint32Value = '\b';
-                        break;
-                    case 'n':
-                        sint32Value = '\n';
-                        break;
-                    case 't':
-                        sint32Value = '\t';
-                        break;
-                    case '\\':
-                        sint32Value = '\\';
-                        break;
-                    case '\'':
-                        sint32Value = '\'';
-                        break;
-                    case '\"':
-                        sint32Value = '\"';
-                        break;
-                }
-            }
-            break;
         }
         case TokenKind::REAL:
-            real32Value = stof(token->getLexme());
+            expression->real32Value = stof(token->getLexme());
-            valueType = ValueType::valueTypeForToken(token, nullptr, 0);
+            expression->valueType = ValueType::valueTypeForToken(token, nullptr, 0);
             break;
         default:
-            exit(1);
+            return nullptr;
     }
+
+    return expression;
 }
 
+ExpressionLiteral::ExpressionLiteral():
+Expression(ExpressionKind::LITERAL, nullptr) { }
+
 bool ExpressionLiteral::getBoolValue() {
     return boolValue;
 }

src/Parser/Expression/ExpressionLiteral.h

@@ -12,7 +12,6 @@ private:
 public:
     static shared_ptr<ExpressionLiteral> expressionLiteralForToken(shared_ptr<Token> token);
     
-    ExpressionLiteral(shared_ptr<Token> token);
     ExpressionLiteral();
     bool getBoolValue();
     int32_t getSint32Value();

src/Parser/Parser.cpp

@@ -460,7 +460,7 @@ shared_ptr<Expression> Parser::matchExpressionLiteral() {
     shared_ptr<Token> token = tokens.at(currentIndex);
 
     if (tryMatchingTokenKinds(Token::tokensLiteral, false, true))
-        return make_shared<ExpressionLiteral>(token);
+        return ExpressionLiteral::expressionLiteralForToken(token);
 
     return nullptr;
 }