Add unary expression parsing

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

furc/include/furc/ast/expression.hpp

@@ -9,7 +9,8 @@ namespace ast {
 
 enum class expression_node_t {
     Literal,
-    Binop
+    Unaryop,
+    Binop,
 };
 
 class expression_node : public statement_node {
@@ -25,6 +26,37 @@ protected:
 
 using expression_node_h = node_handle<expression_node>;
 
+enum class unaryop_expression_node_t {
+    Positive,
+    Negative,
+    PrefixIncrement,
+    PostfixIncrement,
+    PrefixDecrement,
+    PostfixDecrement,
+};
+
+class unaryop_expression_node : public expression_node {
+public:
+    unaryop_expression_node(unaryop_expression_node_t type, expression_node_h&& node)
+      : m_type(type), m_node(std::move(node)) {}
+
+    void set_node(expression_node_h&& node) { m_node = std::move(node); }
+
+    unaryop_expression_node_t type() const { return m_type; }
+    const expression_node_h&  get_node() const { return m_node; }
+    expression_node_h&        get_node() { return m_node; }
+    expression_node_h&&       move_node() { return std::move(m_node); }
+public:
+    expression_node_t expression_type() const override { return expression_node_t::Unaryop; }
+
+    std::ostream& print(std::ostream& os) const override;
+private:
+    unaryop_expression_node_t m_type;
+    expression_node_h         m_node;
+};
+
+using unaryop_expression_node_h = node_handle<unaryop_expression_node>;
+
 enum class binop_expression_node_t {
     Add,
     Sub,
@@ -40,7 +72,11 @@ public:
 
     binop_expression_node_t  type() const { return m_type; };
     const expression_node_h& lhs() const { return m_lhs; };
+    expression_node_h&       lhs() { return m_lhs; };
+    expression_node_h&&      move_lhs() { return std::move(m_lhs); };
     const expression_node_h& rhs() const { return m_rhs; };
+    expression_node_h&       rhs() { return m_rhs; };
+    expression_node_h&&      move_rhs() { return std::move(m_rhs); };
 public:
     expression_node_t expression_type() const override { return expression_node_t::Binop; }
 

furc/include/furc/front/parser.hpp

@@ -33,7 +33,8 @@ private:
     ast::literal_node_h     parse_literal();
 
     ast::expression_node_h parse_expression_primary();
-    ast::expression_node_h parse_expression_rhs(const ast::expression_node_h& init, std::uint32_t precedence);
+    ast::expression_node_h parse_expression_unary(std::uint32_t precedence);
+    ast::expression_node_h parse_expression_rhs(ast::expression_node_h&& init, std::uint32_t precedence);
 
     ast::function_body_h parse_body();
 private:

furc/include/furc/front/token.hpp

@@ -32,6 +32,8 @@ enum class token_t {
     Star,
     Slash,
     Percent,
+    DPlus,
+    DMinus,
 };
 
 static inline std::ostream& operator<<(std::ostream& os, token_t type) {
@@ -56,6 +58,8 @@ static inline std::ostream& operator<<(std::ostream& os, token_t type) {
     case token_t::Star: return os << "'*'";
     case token_t::Slash: return os << "'/'";
     case token_t::Percent: return os << "'%'";
+    case token_t::DPlus: return os << "++";
+    case token_t::DMinus: return os << "--";
     }
     return os;
 }
@@ -82,6 +86,8 @@ static inline std::string operator+(const std::string& str, token_t type) {
     case token_t::Star: return str + "'*'";
     case token_t::Slash: return str + "'/'";
     case token_t::Percent: return str + "'%'";
+    case token_t::DPlus: return str + "++";
+    case token_t::DMinus: return str + "--";
     }
     return str;
 }
@@ -167,7 +173,9 @@ struct token {
         case token_t::Minus:
         case token_t::Star:
         case token_t::Slash:
-        case token_t::Percent: return true;
+        case token_t::Percent:
+        case token_t::DPlus:
+        case token_t::DMinus: return true;
         }
     }
 };