Parse var reference

src/Parser.cpp

@@ -100,7 +100,7 @@ shared_ptr<Statement> Parser::matchStatementVarDeclaration() {
 
     // Expect new line
     if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true))
-        return matchStatementInvalid();
+        return matchStatementInvalid("Expected a new line");
 
     return make_shared<StatementVarDeclaration>(identifierToken->getLexme(), valueType, expression);
 }
@@ -150,7 +150,7 @@ shared_ptr<Statement> Parser::matchStatementExpression() {
     if (expression == nullptr)
         return nullptr;
     else if (!expression->isValid())
-        return make_shared<StatementInvalid>(tokens.at(currentIndex));
+        return make_shared<StatementInvalid>(tokens.at(currentIndex), expression->toString(0));
 
     // Consume new line
     tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true);
@@ -158,8 +158,8 @@ shared_ptr<Statement> Parser::matchStatementExpression() {
     return make_shared<StatementExpression>(expression);
 }
 
-shared_ptr<StatementInvalid> Parser::matchStatementInvalid() {
-    return make_shared<StatementInvalid>(tokens.at(currentIndex));
+shared_ptr<StatementInvalid> Parser::matchStatementInvalid(string message) {
+    return make_shared<StatementInvalid>(tokens.at(currentIndex), message);
 }
 
 //
@@ -234,6 +234,10 @@ shared_ptr<Expression> Parser::matchPrimary() {
     if (expression != nullptr)
         return expression;
     
+    expression = matchExpressionVar();
+    if (expression != nullptr)
+        return expression;
+    
     expression = matchExpressionGrouping();
     if (expression != nullptr)
         return expression;
@@ -244,7 +248,7 @@ shared_ptr<Expression> Parser::matchPrimary() {
 shared_ptr<Expression> Parser::matchExpressionLiteral() {
     shared_ptr<Token> token = tokens.at(currentIndex);
 
-    if (tryMatchingTokenKinds({TokenKind::BOOL, TokenKind::INTEGER, TokenKind::REAL}, false, true))
+    if (tryMatchingTokenKinds(Token::tokensLiteral, false, true))
         return make_shared<ExpressionLiteral>(token);
 
     return nullptr;

src/Parser.h

@@ -20,7 +20,7 @@ private:
     shared_ptr<Statement> matchStatementBlock();
     shared_ptr<Statement> matchStatementReturn();
     shared_ptr<Statement> matchStatementExpression();
-    shared_ptr<StatementInvalid> matchStatementInvalid();
+    shared_ptr<StatementInvalid> matchStatementInvalid(string message = "");
 
     shared_ptr<Expression> nextExpression();
     shared_ptr<Expression> matchEquality(); // =, !=

src/Statement.cpp

@@ -172,10 +172,14 @@ string StatementExpression::toString(int indent) {
 
 //
 // StatementInvalid
-StatementInvalid::StatementInvalid(shared_ptr<Token> token):
-Statement(StatementKind::INVALID), token(token) {
+StatementInvalid::StatementInvalid(shared_ptr<Token> token, string message):
+Statement(StatementKind::INVALID), token(token), message(message) {
 }
 
 string StatementInvalid::toString(int indent) {
-    return "Invalid token " + token->toString() + " at " + to_string(token->getLine()) + ":" + to_string(token->getColumn()) + "\n";
+    return "Error for token " + token->getLexme() + " at " + to_string(token->getLine()) + ":" + to_string(token->getColumn()) + ": " + message + "\n";
+}
+
+string StatementInvalid::getMessage() {
+    return message;
 }

src/Statement.h

@@ -104,10 +104,12 @@ public:
 class StatementInvalid: public Statement {
 private:
     shared_ptr<Token> token;
+    string message;
 
 public:
-    StatementInvalid(shared_ptr<Token> token);
+    StatementInvalid(shared_ptr<Token> token, string message);
     string toString(int indent) override;
+    string getMessage();
 };
 
 #endif

src/Token.cpp

@@ -35,6 +35,11 @@ vector<TokenKind> Token::tokensBinary = {
     TokenKind::SLASH,
     TokenKind::PERCENT
 };
+vector<TokenKind> Token::tokensLiteral = {
+    TokenKind::BOOL,
+    TokenKind::INTEGER,
+    TokenKind::REAL
+};
 
 Token::Token(TokenKind kind, string lexme, int line, int column):
     kind(kind), lexme(lexme), line(line), column(column) {

src/Token.h

@@ -20,6 +20,7 @@ public:
     static vector<TokenKind> tokensTerm;
     static vector<TokenKind> tokensFactor;
     static vector<TokenKind> tokensBinary;
+    static vector<TokenKind> tokensLiteral;
 
     Token(TokenKind kind, string lexme, int line, int column);
     TokenKind getKind();