Pratt parser tamamlandı

core/Parser/ASTNode.cpp

@@ -21,6 +21,10 @@ class ASTNode
     public:
         ASTKind kind;
         ASTNode * parent;
+        virtual void log(int indent)
+        {
+            std::cout << "<Unknown>\n";
+        }
     public:
         void addChild(ASTNode * children)
         {
@@ -37,6 +41,18 @@ class BinaryExpressionNode : public ASTNode
     protected:
         ASTKind Kind = ASTKind::BinaryExpression;
     public:
+        void log(int indent) override
+        {
+            std::cout
+                << padRight(" ",indent)
+                << "BinaryExpressionNode"
+                << OPERATOR_MAP_STRREV.find(this->Operator)->second
+                << "( "<< OPERATOR_MAP_REV.find(this->Operator)->second << " )"
+                << "\n";
+    
+            this->Right->log(indent + 4);
+            if(this->Left != nullptr) this->Left->log(indent + 4);
+        }
         ASTNode* Right;
         TokenType Operator;
         ASTNode* Left;
@@ -47,6 +63,10 @@ class LiteralNode : public ASTNode
 {
     protected:
         ASTKind kind = ASTKind::Literal;
+        void log(int indent)
+        {
+            std::cout << padRight(" ",indent)  << "LiteralNode {" << this->lexerToken.token << "}\n";
+        }
     public:
         Token lexerToken;
         ParserToken parserToken;

core/Parser/Parser.cpp

@@ -78,18 +78,18 @@ ParserToken Parser::getToken(int offset){
 }
 
 void Parser::nextToken(){
-    if(this->tokens.size() <= this->current + 1)
+    if(this->tokens.size() >= this->current + 1)
     {
         this->current++;
     }
 }
 
 ParserToken Parser::lookehead(uint32_t forward){
-    return this->getToken(this->current + forward);
+    return this->getToken(forward);
 }
 
 ParserToken Parser::currentToken(){
-    return this->getToken(this->current);
+    return this->getToken(0);
 }
 
 void Parser::parse(TokenList tokens){
@@ -113,7 +113,8 @@ void Parser::primaryExpression()
         })
     )
     {
-        this->volumeExpression(0);
+        ASTNode * tree = this->volumeExpression(0);
+        tree->log(0);
     }
 }
 

core/Parser/ParserToken.cpp

@@ -295,6 +295,104 @@ static const std::unordered_map<std::string_view, TokenType> OPERATOR_MAP = {
     {".", TokenType::DOT},
     {"?", TokenType::TERNARY},
 };
+static const std::unordered_map<TokenType,std::string_view> OPERATOR_MAP_REV = {
+    {TokenType::ARROW,"->"},
+    {TokenType::COLON_COLON,"::"},
+    {TokenType::EQUAL_EQUAL,"=="},
+    {TokenType::BANG_EQUAL,"!="},
+    {TokenType::LESS_EQUAL,"<="},
+    {TokenType::GREATER_EQUAL,">="},
+    {TokenType::AMPERSAND_AMPERSAND,"&&"},
+    {TokenType::PIPE_PIPE,"||"},
+    {TokenType::PLUS_PLUS,"++"},
+    {TokenType::MINUS_MINUS,"--"},
+    {TokenType::LSHIFT,"<<"},
+    {TokenType::RSHIFT,">>"},
+    {TokenType::STAR_STAR,"**"},
+    {TokenType::PLUS_EQUAL,"+="},
+    {TokenType::MINUS_EQUAL,"-="},
+    {TokenType::STAR_EQUAL,"*="},
+    {TokenType::SLASH_EQUAL,"/="},
+    {TokenType::PERCENT_EQUAL,"%="},
+    {TokenType::AMPERSAND_EQUAL,"&="},
+    {TokenType::PIPE_EQUAL,"|="},
+    {TokenType::CARET_EQUAL,"^="},
+    {TokenType::LSHIFT_EQUAL,"<<="},
+    {TokenType::RSHIFT_EQUAL,">>="},
+    {TokenType::PLUS,"+"},
+    {TokenType::MINUS,"-"},
+    {TokenType::STAR,"*"},
+    {TokenType::SLASH,"/"},
+    {TokenType::PERCENT,"%"},
+    {TokenType::LESS,"<"},
+    {TokenType::GREATER,">"},
+    {TokenType::CARET,"^"},
+    {TokenType::BANG,"!"},
+    {TokenType::TILDE,"~"},
+    {TokenType::AMPERSAND,"&"},
+    {TokenType::PIPE,"|"},
+    {TokenType::EQUAL,"="},
+    {TokenType::LBRACKET,"["},
+    {TokenType::RBRACKET,"]"},
+    {TokenType::LPAREN,"("},
+    {TokenType::RPAREN,")"},
+    {TokenType::LBRACE,"{"},
+    {TokenType::RBRACE,"}"},
+    {TokenType::SEMICOLON,";"},
+    {TokenType::COMMA,","},
+    {TokenType::COLON,":"},
+    {TokenType::DOT,"."},
+    {TokenType::TERNARY,"?"},
+};
+static const std::unordered_map<TokenType,std::string_view> OPERATOR_MAP_STRREV = {
+    {TokenType::ARROW,"ARROW"},
+    {TokenType::COLON_COLON,"COLON_COLON"},
+    {TokenType::EQUAL_EQUAL,"EQUAL_EQUAL"},
+    {TokenType::BANG_EQUAL,"BANG_EQUAL"},
+    {TokenType::LESS_EQUAL,"LESS_EQUAL"},
+    {TokenType::GREATER_EQUAL,"GREATER_EQUAL"},
+    {TokenType::AMPERSAND_AMPERSAND,"AMPERSAND_AMPERSAND"},
+    {TokenType::PIPE_PIPE,"PIPE_PIPE"},
+    {TokenType::PLUS_PLUS,"PLUS_PLUS"},
+    {TokenType::MINUS_MINUS,"MINUS_MINUS"},
+    {TokenType::LSHIFT,"LSHIFT"},
+    {TokenType::RSHIFT,"RSHIFT"},
+    {TokenType::STAR_STAR,"STAR_STAR"},
+    {TokenType::PLUS_EQUAL,"PLUS_EQUAL"},
+    {TokenType::MINUS_EQUAL,"MINUS_EQUAL"},
+    {TokenType::STAR_EQUAL,"STAR_EQUAL"},
+    {TokenType::SLASH_EQUAL,"SLASH_EQUAL"},
+    {TokenType::PERCENT_EQUAL,"PERCENT_EQUAL"},
+    {TokenType::AMPERSAND_EQUAL,"AMPERSAND_EQUAL"},
+    {TokenType::PIPE_EQUAL,"PIPE_EQUAL"},
+    {TokenType::CARET_EQUAL,"CARET_EQUAL"},
+    {TokenType::LSHIFT_EQUAL,"LSHIFT_EQUAL"},
+    {TokenType::RSHIFT_EQUAL,"RSHIFT_EQUAL"},
+    {TokenType::PLUS,"PLUS"},
+    {TokenType::MINUS,"MINUS"},
+    {TokenType::STAR,"STAR"},
+    {TokenType::SLASH,"SLASH"},
+    {TokenType::PERCENT,"PERCENT"},
+    {TokenType::LESS,"LESS"},
+    {TokenType::GREATER,"GREATER"},
+    {TokenType::CARET,"CARET"},
+    {TokenType::BANG,"BANG"},
+    {TokenType::TILDE,"TILDE"},
+    {TokenType::AMPERSAND,"AMPERSAND"},
+    {TokenType::PIPE,"PIPE"},
+    {TokenType::EQUAL,"EQUAL"},
+    {TokenType::LBRACKET,"LBRACKET"},
+    {TokenType::RBRACKET,"RBRACKET"},
+    {TokenType::LPAREN,"LPAREN"},
+    {TokenType::RPAREN,"RPAREN"},
+    {TokenType::LBRACE,"LBRACE"},
+    {TokenType::RBRACE,"RBRACE"},
+    {TokenType::SEMICOLON,"SEMICOLON"},
+    {TokenType::COMMA,"COMMA"},
+    {TokenType::COLON,"COLON"},
+    {TokenType::DOT,"DOT"},
+    {TokenType::TERNARY,"TERNARY"},
+};
 
 
 uint16_t TokenPrecedence(TokenType type) {

source.sqt

@@ -1 +1 @@
-75.37
+1 - 2 + 3 * 4 / 5