Add var assign expression

Signed-off-by: CHatingPython <chatingpython@gmail.com>

furc/include/furc/ast/expression.hpp

@@ -10,6 +10,7 @@ namespace ast {
 enum class expression_node_t {
     Literal,
     VarRead,
+    VarAssign,
     Unaryop,
     Binop,
     Paren,
@@ -81,6 +82,7 @@ private:
 using unaryop_expression_node_h = node_handle<unaryop_expression_node>;
 
 enum class binop_expression_node_t {
+    None = 0,
     Add,
     Sub,
     Mul,
@@ -114,6 +116,31 @@ private:
 
 using binop_expression_node_h = node_handle<binop_expression_node>;
 
+class var_assign_expression_node : public expression_node {
+public:
+    var_assign_expression_node(expression_node_h&& lhs, expression_node_h&& rhs)
+      : m_compound(binop_expression_node_t::None), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {}
+
+    var_assign_expression_node(binop_expression_node_t compound, expression_node_h&& lhs, expression_node_h&& rhs)
+      : m_compound(compound), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)) {}
+
+    binop_expression_node_t  compound() const { return m_compound; }
+    const expression_node_h& lhs() const { return m_lhs; }
+    const expression_node_h& rhs() const { return m_rhs; }
+public:
+    expression_node_t expression_type() const override { return expression_node_t::VarAssign; }
+
+    std::ostream& print(std::ostream& os) const override;
+protected:
+    bool equal(const node& rhs) const override;
+private:
+    binop_expression_node_t m_compound;
+    expression_node_h       m_lhs;
+    expression_node_h       m_rhs;
+};
+
+using var_assign_expression_node_h = node_handle<var_assign_expression_node>;
+
 } // namespace ast
 } // namespace furc
 

furc/include/furc/front/token.hpp

@@ -34,6 +34,13 @@ enum class token_t {
     Percent,
     DPlus,
     DMinus,
+
+    Eq,
+    PlusEq,
+    MinusEq,
+    StarEq,
+    SlashEq,
+    PercentEq,
 };
 
 static inline std::ostream& operator<<(std::ostream& os, token_t type) {
@@ -60,6 +67,12 @@ static inline std::ostream& operator<<(std::ostream& os, token_t type) {
     case token_t::Percent: return os << "'%'";
     case token_t::DPlus: return os << "++";
     case token_t::DMinus: return os << "--";
+    case token_t::Eq: return os << "=";
+    case token_t::PlusEq: return os << "+=";
+    case token_t::MinusEq: return os << "-=";
+    case token_t::StarEq: return os << "*=";
+    case token_t::SlashEq: return os << "/=";
+    case token_t::PercentEq: return os << "%=";
     }
     return os;
 }
@@ -88,6 +101,12 @@ static inline std::string operator+(const std::string& str, token_t type) {
     case token_t::Percent: return str + "'%'";
     case token_t::DPlus: return str + "++";
     case token_t::DMinus: return str + "--";
+    case token_t::Eq: return str + "=";
+    case token_t::PlusEq: return str + "+=";
+    case token_t::MinusEq: return str + "-=";
+    case token_t::StarEq: return str + "*=";
+    case token_t::SlashEq: return str + "/=";
+    case token_t::PercentEq: return str + "%=";
     }
     return str;
 }
@@ -158,24 +177,7 @@ struct token {
         case token_t::String: return value.string == rhs.value.string;
         case token_t::Keyword: return value.keyword == rhs.value.keyword;
         case token_t::Integer: return value.integer == rhs.value.integer;
-        case token_t::None:
-        case token_t::Lparen:
-        case token_t::Rparen:
-        case token_t::Lbrace:
-        case token_t::Rbrace:
-        case token_t::Lbracket:
-        case token_t::Rbracket:
-        case token_t::Semicolon:
-        case token_t::Colon:
-        case token_t::Comma:
-        case token_t::Dot:
-        case token_t::Plus:
-        case token_t::Minus:
-        case token_t::Star:
-        case token_t::Slash:
-        case token_t::Percent:
-        case token_t::DPlus:
-        case token_t::DMinus: return true;
+        default: return true;
         }
     }
 };