From 3117bac5442a61813c19202bb0f436536d1208fc Mon Sep 17 00:00:00 2001
From: Stephane Del Pino <stephane.delpino44@gmail.com>
Date: Wed, 24 Jul 2019 16:59:26 +0200
Subject: [PATCH] Remove bit-wise affectation operators: '^=', '|=' and '&='

Also removed their synonyms: 'xor_eq', 'or_eq' and 'and_eq'.
Again, if really needed, it will be easy to redefine them.
---
 src/language/ASTBuilder.cpp                   |  3 -
 .../ASTNodeAffectationExpressionBuilder.cpp   | 92 ++++---------------
 src/language/ASTNodeDataTypeBuilder.cpp       |  3 +-
 src/language/ASTNodeExpressionBuilder.cpp     |  3 +-
 src/language/PEGGrammar.hpp                   | 13 +--
 5 files changed, 21 insertions(+), 93 deletions(-)

diff --git a/src/language/ASTBuilder.cpp b/src/language/ASTBuilder.cpp
index 22acb285c..82a60d54d 100644
--- a/src/language/ASTBuilder.cpp
+++ b/src/language/ASTBuilder.cpp
@@ -242,9 +242,6 @@ using selector =
                                                       divideeq_op,
                                                       pluseq_op,
                                                       minuseq_op,
-                                                      bit_andeq_op,
-                                                      bit_xoreq_op,
-                                                      bit_oreq_op,
                                                       unary_plusplus,
                                                       unary_minusminus,
                                                       post_minusminus,
diff --git a/src/language/ASTNodeAffectationExpressionBuilder.cpp b/src/language/ASTNodeAffectationExpressionBuilder.cpp
index 690ddabcf..60e4a5964 100644
--- a/src/language/ASTNodeAffectationExpressionBuilder.cpp
+++ b/src/language/ASTNodeAffectationExpressionBuilder.cpp
@@ -62,39 +62,6 @@ struct AffOp<language::minuseq_op>
   }
 };
 
-template <>
-struct AffOp<language::bit_andeq_op>
-{
-  template <typename A, typename B>
-  PUGS_INLINE void
-  eval(A& a, const B& b)
-  {
-    a &= b;
-  }
-};
-
-template <>
-struct AffOp<language::bit_xoreq_op>
-{
-  template <typename A, typename B>
-  PUGS_INLINE void
-  eval(A& a, const B& b)
-  {
-    a ^= b;
-  }
-};
-
-template <>
-struct AffOp<language::bit_oreq_op>
-{
-  template <typename A, typename B>
-  PUGS_INLINE void
-  eval(A& a, const B& b)
-  {
-    a |= b;
-  }
-};
-
 template <typename OperatorT, typename ValueT, typename DataT>
 class AffectationProcessor final : public INodeProcessor
 {
@@ -103,11 +70,7 @@ class AffectationProcessor final : public INodeProcessor
   ASTNodeDataVariant* p_value{nullptr};
 
   static inline const bool _is_defined{[] {
-    if constexpr (std::is_same_v<OperatorT, language::bit_andeq_op> or
-                  std::is_same_v<OperatorT, language::bit_xoreq_op> or
-                  std::is_same_v<OperatorT, language::bit_oreq_op>) {
-      return std::is_same_v<std::decay_t<ValueT>, std::decay_t<DataT>> and std::is_integral_v<std::decay_t<ValueT>>;
-    } else if constexpr (std::is_same_v<std::decay_t<ValueT>, bool>) {
+    if constexpr (std::is_same_v<std::decay_t<ValueT>, bool>) {
       if constexpr (not std::is_same_v<OperatorT, language::eq_op>) {
         return false;
       }
@@ -154,46 +117,31 @@ class AffectationToStringProcessor final : public INodeProcessor
   ASTNode& m_node;
   ASTNodeDataVariant* p_value{nullptr};
 
-  static inline const bool _is_defined{[] {
-    if constexpr (std::is_same_v<OperatorT, language::bit_andeq_op> or
-                  std::is_same_v<OperatorT, language::bit_xoreq_op> or std::is_same_v<OperatorT, language::bit_oreq_op>)
-      return false;
-    else {
-      return true;
-    }
-  }()};
-
  public:
   AffectationToStringProcessor(ASTNode& node) : m_node{node}
   {
-    if constexpr (_is_defined) {
-      const std::string& symbol = m_node.children[0]->string();
-      auto [i_symbol, found]    = m_node.m_symbol_table->find(symbol, m_node.children[0]->begin());
-      Assert(found);
-      p_value = &i_symbol->second.value();
-    } else {
-      throw parse_error("invalid operands to binary expression", std::vector{m_node.begin()});
-    }
+    const std::string& symbol = m_node.children[0]->string();
+    auto [i_symbol, found]    = m_node.m_symbol_table->find(symbol, m_node.children[0]->begin());
+    Assert(found);
+    p_value = &i_symbol->second.value();
   }
 
   void
   execute(ExecUntilBreakOrContinue& exec_policy)
   {
-    if constexpr (_is_defined) {
-      m_node.children[1]->execute(exec_policy);
+    m_node.children[1]->execute(exec_policy);
 
-      if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
-        if constexpr (std::is_same_v<std::string, DataT>) {
-          *p_value = m_node.children[1]->m_value;
-        } else {
-          *p_value = std::to_string(std::get<DataT>(m_node.children[1]->m_value));
-        }
-      } else if constexpr (std::is_same_v<OperatorT, language::pluseq_op>) {
-        if constexpr (std::is_same_v<std::string, DataT>) {
-          std::get<std::string>(*p_value) += std::get<std::string>(m_node.children[1]->m_value);
-        } else {
-          std::get<std::string>(*p_value) += std::to_string(std::get<DataT>(m_node.children[1]->m_value));
-        }
+    if constexpr (std::is_same_v<OperatorT, language::eq_op>) {
+      if constexpr (std::is_same_v<std::string, DataT>) {
+        *p_value = m_node.children[1]->m_value;
+      } else {
+        *p_value = std::to_string(std::get<DataT>(m_node.children[1]->m_value));
+      }
+    } else if constexpr (std::is_same_v<OperatorT, language::pluseq_op>) {
+      if constexpr (std::is_same_v<std::string, DataT>) {
+        std::get<std::string>(*p_value) += std::get<std::string>(m_node.children[1]->m_value);
+      } else {
+        std::get<std::string>(*p_value) += std::to_string(std::get<DataT>(m_node.children[1]->m_value));
       }
     }
   }
@@ -304,12 +252,6 @@ ASTNodeAffectationExpressionBuilder::ASTNodeAffectationExpressionBuilder(ASTNode
     set_affectation_processor(n, language::pluseq_op{});
   } else if (n.is<language::minuseq_op>()) {
     set_affectation_processor(n, language::minuseq_op{});
-  } else if (n.is<language::bit_andeq_op>()) {
-    set_affectation_processor(n, language::bit_andeq_op{});
-  } else if (n.is<language::bit_xoreq_op>()) {
-    set_affectation_processor(n, language::bit_xoreq_op{});
-  } else if (n.is<language::bit_oreq_op>()) {
-    set_affectation_processor(n, language::bit_oreq_op{});
   } else {
     throw parse_error("unexpected error: undefined affectation operator", std::vector{n.begin()});
   }
diff --git a/src/language/ASTNodeDataTypeBuilder.cpp b/src/language/ASTNodeDataTypeBuilder.cpp
index a7268f8a3..86b39f5a5 100644
--- a/src/language/ASTNodeDataTypeBuilder.cpp
+++ b/src/language/ASTNodeDataTypeBuilder.cpp
@@ -66,8 +66,7 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n)
     if (n.is<language::break_kw>() or n.is<language::continue_kw>()) {
       n.m_data_type = ASTNodeDataType::void_t;
     } else if (n.is<language::eq_op>() or n.is<language::multiplyeq_op>() or n.is<language::divideeq_op>() or
-               n.is<language::pluseq_op>() or n.is<language::minuseq_op>() or n.is<language::bit_andeq_op>() or
-               n.is<language::bit_xoreq_op>() or n.is<language::bit_oreq_op>()) {
+               n.is<language::pluseq_op>() or n.is<language::minuseq_op>()) {
       n.m_data_type = n.children[0]->m_data_type;
     } else if (n.is<language::for_post>() or n.is<language::for_init>() or n.is<language::for_statement_bloc>()) {
       n.m_data_type = ASTNodeDataType::void_t;
diff --git a/src/language/ASTNodeExpressionBuilder.cpp b/src/language/ASTNodeExpressionBuilder.cpp
index 498830c75..703fd104e 100644
--- a/src/language/ASTNodeExpressionBuilder.cpp
+++ b/src/language/ASTNodeExpressionBuilder.cpp
@@ -272,8 +272,7 @@ build_node_type(ASTNode& n)
     n.m_node_processor = std::make_unique<NoProcess>();
 
   } else if ((n.is<language::eq_op>() or n.is<language::multiplyeq_op>() or n.is<language::divideeq_op>() or
-              n.is<language::pluseq_op>() or n.is<language::minuseq_op>() or n.is<language::bit_andeq_op>() or
-              n.is<language::bit_xoreq_op>() or n.is<language::bit_oreq_op>())) {
+              n.is<language::pluseq_op>() or n.is<language::minuseq_op>())) {
     ASTNodeAffectationExpressionBuilder{n};
 
   } else if (n.is<language::real>()) {
diff --git a/src/language/PEGGrammar.hpp b/src/language/PEGGrammar.hpp
index 83748365c..3dac6bd40 100644
--- a/src/language/PEGGrammar.hpp
+++ b/src/language/PEGGrammar.hpp
@@ -76,10 +76,6 @@ struct or_kw :  TAO_PEGTL_KEYWORD("or") {};
 
 struct xor_kw :  TAO_PEGTL_KEYWORD("xor") {};
 
-struct and_eq_kw :  TAO_PEGTL_KEYWORD("and_eq") {};
-struct xor_eq_kw :  TAO_PEGTL_KEYWORD("xor_eq") {};
-struct or_eq_kw :  TAO_PEGTL_KEYWORD("or_eq") {};
-
 struct not_kw :  TAO_PEGTL_KEYWORD("not") {};
 struct true_kw :  TAO_PEGTL_KEYWORD("true") {};
 struct false_kw :  TAO_PEGTL_KEYWORD("false") {};
@@ -111,7 +107,7 @@ struct cout_kw : TAO_PEGTL_KEYWORD("cout") {};
 struct cerr_kw : TAO_PEGTL_KEYWORD("cerr") {};
 struct clog_kw : TAO_PEGTL_KEYWORD("clog") {};
 
-struct keywork : sor < basic_type, true_kw, false_kw, do_kw, while_kw, for_kw, if_kw, else_kw, and_kw, or_kw, xor_kw, and_eq_kw, xor_eq_kw, or_eq_kw, break_kw, continue_kw, cout_kw, cerr_kw, clog_kw > {};
+struct keywork : sor < basic_type, true_kw, false_kw, do_kw, while_kw, for_kw, if_kw, else_kw, and_kw, or_kw, xor_kw, break_kw, continue_kw, cout_kw, cerr_kw, clog_kw > {};
 
 struct name : minus< identifier, keywork >  {};
 struct NAME : seq < name, ignored > {};
@@ -172,10 +168,6 @@ struct divideeq_op : seq< TAO_PEGTL_STRING("/="), ignored > {};
 struct pluseq_op : seq< TAO_PEGTL_STRING("+="), ignored > {};
 struct minuseq_op : seq< TAO_PEGTL_STRING("-="), ignored > {};
 
-struct bit_andeq_op : seq< sor< TAO_PEGTL_STRING("&="), and_eq_kw >, ignored > {};
-struct bit_xoreq_op : seq< sor< TAO_PEGTL_STRING("^="), xor_eq_kw >, ignored > {};
-struct bit_oreq_op : seq< sor< TAO_PEGTL_STRING("|="), or_eq_kw >, ignored > {};
-
 struct product : list_must< unary_expression, sor< multiply_op, divide_op > > {};
 
 struct sum : list_must< product, sor< plus_op, minus_op > > {};
@@ -192,8 +184,7 @@ struct logical_or : list_must< logical_and, or_op >{};
 
 struct expression : logical_or {};
 
-struct affect_op : sor< eq_op, multiplyeq_op, divideeq_op, pluseq_op, minuseq_op,  bit_andeq_op,
-                        bit_xoreq_op, bit_oreq_op > {};
+struct affect_op : sor< eq_op, multiplyeq_op, divideeq_op, pluseq_op, minuseq_op > {};
 
 struct affectation : seq< NAME , if_must< affect_op, expression > >{};
 
-- 
GitLab