完成Parser定义以及表达式解析

src/Ast/Operator.cpp

@@ -22,8 +22,10 @@ namespace Fig
 
     HashMap<TokenType, BinaryOperator> &GetBinaryOpMap()
     {
-        static HashMap<TokenType, BinaryOperator> binaryOpMap{{TokenType::Plus, BinaryOperator::Add},
+        static HashMap<TokenType, BinaryOperator> binaryOpMap{
+            {TokenType::Plus, BinaryOperator::Add},
             {TokenType::Minus, BinaryOperator::Subtract},
+            {TokenType::Asterisk, BinaryOperator::Multiply},
             {TokenType::Slash, BinaryOperator::Divide},
             {TokenType::Percent, BinaryOperator::Modulo},
 
@@ -42,30 +44,54 @@ namespace Fig
             {TokenType::Power, BinaryOperator::Power},
 
             {TokenType::Assign, BinaryOperator::Assign},
+            {TokenType::PlusEqual, BinaryOperator::AddAssign},
+            {TokenType::MinusEqual, BinaryOperator::SubAssign},
+            {TokenType::AsteriskEqual, BinaryOperator::MultiplyAssign},
+            {TokenType::SlashEqual, BinaryOperator::DivideAssign},
+            {TokenType::PercentEqual, BinaryOperator::ModuloAssign},
+            {TokenType::CaretEqual, BinaryOperator::BitXorAssign},
 
             {TokenType::Pipe, BinaryOperator::BitAnd},
             {TokenType::Ampersand, BinaryOperator::BitAnd},
             {TokenType::ShiftLeft, BinaryOperator::ShiftLeft},
-            {TokenType::ShiftRight, BinaryOperator::ShiftRight}};
+            {TokenType::ShiftRight, BinaryOperator::ShiftRight},
+
+            {TokenType::Dot, BinaryOperator::MemberAccess},
+        };
         return binaryOpMap;
     }
 
-    // 赋值 < 三元 < 逻辑或 < 逻辑与 < 位运算 < 比较 < 位移 < 加减 < 乘除 < 幂 < 一元
+    // 赋值 < 三元 < 逻辑或 < 逻辑与 < 位运算 < 比较 < 位移 < 加减 < 乘除 < 幂 < 一元 < 成员访问 < (后缀)
+
+    /*
+        暂划分:
+            二元运算符：0 - 20000
+            一元运算符：20001 - 40000
+            后缀/成员/其他：40001 - 60001
+
+    */
 
     HashMap<UnaryOperator, BindingPower> &GetUnaryOpBindingPowerMap()
     {
         static HashMap<UnaryOperator, BindingPower> unbpm{
-            {UnaryOperator::BitNot, 10000},
-            {UnaryOperator::Negate, 10000},
-            {UnaryOperator::Not, 10000},
-            {UnaryOperator::AddressOf, 10000},
+            {UnaryOperator::BitNot, 20001},
+            {UnaryOperator::Negate, 20001},
+            {UnaryOperator::Not, 20001},
+            {UnaryOperator::AddressOf, 20001},
         };
         return unbpm;
     }
 
     HashMap<BinaryOperator, BindingPower> &GetBinaryOpBindingPowerMap()
     {
-        static HashMap<BinaryOperator, BindingPower> bnbpm{{BinaryOperator::Assign, 100},
+        static HashMap<BinaryOperator, BindingPower> bnbpm{
+            {BinaryOperator::Assign, 100},
+            {BinaryOperator::AddAssign, 100},
+            {BinaryOperator::SubAssign, 100},
+            {BinaryOperator::MultiplyAssign, 100},
+            {BinaryOperator::DivideAssign, 100},
+            {BinaryOperator::ModuloAssign, 100},
+            {BinaryOperator::BitXorAssign, 100},
 
             {BinaryOperator::LogicalOr, 500},
             {BinaryOperator::LogicalAnd, 550},
@@ -93,8 +119,51 @@ namespace Fig
             {BinaryOperator::Divide, 4500},
 
             {BinaryOperator::Power, 5000},
+
+            {BinaryOperator::MemberAccess, 40001},
         };
+        return bnbpm;
     }
+
+    BindingPower GetUnaryOpRBp(UnaryOperator op)
+    {
+        return GetUnaryOpBindingPowerMap().at(op);
+    }
+
+    BindingPower GetBinaryOpLBp(BinaryOperator op)
+    {
+        return GetBinaryOpBindingPowerMap().at(op);
+    }
+
+    BindingPower GetBinaryOpRBp(BinaryOperator op)
+    {
+        /*
+            右结合，左绑定力 >= 右
+            a = b = c
+            a = (b = c)
+            a.b.c
+        */
+        switch (op)
+        {
+            case BinaryOperator::Assign: return GetBinaryOpLBp(op);
+            case BinaryOperator::AddAssign: return GetBinaryOpLBp(op);
+            case BinaryOperator::SubAssign: return GetBinaryOpLBp(op);
+            case BinaryOperator::MultiplyAssign: return GetBinaryOpLBp(op);
+            case BinaryOperator::DivideAssign: return GetBinaryOpLBp(op);
+            case BinaryOperator::ModuloAssign: return GetBinaryOpLBp(op);
+            case BinaryOperator::BitXorAssign: return GetBinaryOpLBp(op);
+            case BinaryOperator::Power: return GetBinaryOpLBp(op);
+
+            default:
+                /*
+                    左结合, 左绑定力 < 右
+                    a * b * c
+                    (a * b) * c
+                */
+                return GetBinaryOpLBp(op) + 1;
+        }
+    }
+
     bool IsTokenOp(TokenType type, bool binary /* = true*/)
     {
         if (binary)
@@ -103,4 +172,14 @@ namespace Fig
         }
         return GetUnaryOpMap().contains(type);
     }
+
+    UnaryOperator TokenToUnaryOp(const Token &token)
+    {
+        return GetUnaryOpMap().at(token.type);
+    }
+    BinaryOperator TokenToBinaryOp(const Token &token)
+    {
+        return GetBinaryOpMap().at(token.type);
+    }
+
 }; // namespace Fig