Remove ugly hack for ISEOF and MATCH

Author: TPolzer

BUILD

@@ -58,6 +58,7 @@ cc_library(
     hdrs = ["expression.h"],
     deps = [
         ":parser",
+        ":stream",
         ":value",
         ":variable",
         "@com_google_absl//absl/strings",

checktestdata.cc

@@ -399,28 +399,11 @@ class Listener : public checktestdataBaseListener {
     } else if (ctx->function()) {
       switch (ctx->function()->getStart()->getType()) {
         case checktestdataParser::ISEOF: {
-          Value v;
-          expr_stack_.emplace_back([this, v]() mutable {
-            v = Value{input_->empty()};
-            return std::make_pair(false, &v);
-          });
+          expr_stack_.emplace_back(&input_);
           break;
         }
         case checktestdataParser::MATCH: {
-          Value v;
-          Expression clazz = pop_expr();
-          expr_stack_.emplace_back([this, v, clazz]() mutable {
-            const auto& s = std::get<Value::string>(clazz.eval().value_);
-            v = Value{false};
-            for (char c : s) {
-              if (peek(*input_) == c) {
-                v = Value{true};
-                break;
-              }
-            }
-            return std::make_pair(false, &v);
-          });
-
+          expr_stack_.emplace_back(&input_, pop_expr());
           break;
         }
         default: {

expression.cc

@@ -5,6 +5,8 @@
 #include <exception>
 #include <mutex>
 
+#include "stream.h"
+
 #include "absl/strings/str_cat.h"
 
 namespace {
@@ -86,6 +88,8 @@ Value parseToken(const antlr4::Token* literal) {
 }
 }  // namespace
 
+Expression::Expression() = default;
+
 Expression::Expression(Value v)
     : value_(std::move(v)), eval_(&Expression::constEval) {}
 
@@ -131,6 +135,7 @@ Expression::Expression(const antlr4::Token* unop, Expression e) {
   }
 }
 
+// UNIQUE, STRLEN, INARRAY functions
 Expression::Expression(const antlr4::Token* function,
                        std::vector<Expression> arguments) {
   switch (function->getType()) {
@@ -154,6 +159,43 @@ Expression::Expression(const antlr4::Token* function,
   }
 }
 
+// ISEOF function
+Expression::Expression(std::string_view** input)
+    : eval_(&Expression::iseofEval), input_(input) {}
+
+// MATCH function
+Expression::Expression(std::string_view** input, Expression match)
+    : eval_(&Expression::matchEval), children_({match}), input_(input) {}
+
+template <Expression::EvalFn inner>
+std::pair<bool, const Value*> Expression::foldConst() {
+  auto result = (this->*inner)();
+  if (result.first) {
+    *this = Expression{*result.second};
+  } else {
+    eval_ = inner;
+  }
+  return callEval();
+}
+
+std::pair<bool, const Value*> Expression::iseofEval() {
+  value_ = Value{(**input_).empty()};
+  return {false, &value_};
+}
+
+std::pair<bool, const Value*> Expression::matchEval() {
+  Value::string clazz = std::get<Value::string>(children_[0].eval().value_);
+  bool found = false;
+  for (char c : clazz) {
+    if (peek(**input_) == c) {
+      found = true;
+      break;
+    }
+  }
+  value_ = Value{found};
+  return {false, &value_};
+}
+
 std::pair<bool, const Value*> Expression::strlenEval() {
   auto res = children_[0].callEval();
   value_ = Value{

expression.h

@@ -13,18 +13,18 @@ class Expression {
  public:
   const Value& eval() { return *callEval().second; }
   void assign(const Value& v) { (this->*assign_)(v); }
-  Expression() {}
+  Expression();
   Expression(Value v);
   Expression(Variable* variable, std::vector<Expression> idx);
   Expression(const antlr4::Token* literal);
   Expression(const antlr4::Token* binop, Expression a, Expression b);
   Expression(const antlr4::Token* unop, Expression e);
+  // UNIQUE, STRLEN, INARRAY functions
   Expression(const antlr4::Token* function, std::vector<Expression> arguments);
-  template <typename F,
-            typename _ = std::enable_if_t<std::is_invocable_v<F>, void>>
-  Expression(F f)
-      : eval_(&Expression::foldConst<&Expression::backdoorEval<F>>),
-        context_(std::move(f)) {}
+  // ISEOF function
+  Expression(std::string_view** input);
+  // MATCH function
+  Expression(std::string_view** input, Expression match);
 
  private:
   auto idx() {
@@ -36,15 +36,7 @@ class Expression {
   std::pair<bool, const Value*> constEval();
   using EvalFn = decltype(&Expression::constEval);
   template <EvalFn inner>
-  std::pair<bool, const Value*> foldConst() {
-    auto result = (this->*inner)();
-    if (result.first) {
-      *this = Expression{std::move(*result.second)};
-    } else {
-      eval_ = inner;
-    }
-    return callEval();
-  }
+  std::pair<bool, const Value*> foldConst();
   template <int op>
   std::pair<bool, const Value*> binopEval();
   std::pair<bool, const Value*> unaryMinusEval();
@@ -56,10 +48,8 @@ class Expression {
   std::pair<bool, const Value*> uniqueEval();
   std::pair<bool, const Value*> inarrayEval();
   std::pair<bool, const Value*> strlenEval();
-  template <typename F>
-  std::pair<bool, const Value*> backdoorEval() {
-    return (*std::any_cast<F>(&context_))();
-  }
+  std::pair<bool, const Value*> iseofEval();
+  std::pair<bool, const Value*> matchEval();
   template <size_t size>
   void variableArrayAssignment(const Value& value) {
     variable_->set<size>(idx(), value);
@@ -76,10 +66,10 @@ class Expression {
   AssignFn getVariableAssignment(size_t i);
 
   Value value_;
-  Variable* variable_;
+  Variable* variable_ = nullptr;
   std::vector<const Variable*> variables_;
   EvalFn eval_ = &Expression::invalid;
   AssignFn assign_ = &Expression::invalidAssignment;
   std::vector<Expression> children_;
-  std::any context_;
+  std::string_view** input_ = nullptr;
 };