E9

- Implemented the shell of E9::eval.
- Stubbed out operator_xxx helper methods.

src/A3.h

@@ -37,6 +37,12 @@
 class Arg
 {
 public:
+  Arg ()
+  : _raw ("")
+  , _category ("")
+  {
+  }
+
   Arg (
     const std::string& raw,
     const std::string& category)

src/E9.cpp

@@ -27,6 +27,7 @@
 
 #include <iostream> // TODO Remove.
 #include <Context.h>
+#include <A3.h>
 #include <E9.h>
 
 extern Context context;
@@ -49,15 +50,277 @@ bool E9::evalFilter (const Task& task)
   if (_args.size () == 0)
     return true;
 
+  std::vector <Arg> value_stack;
+  eval (task, value_stack);
 
+  // TODO Coerce result to Boolean.
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-std::string evalExpression (const Task& task)
+std::string E9::evalExpression (const Task& task)
 {
-
+  if (_args.size () == 0)
     return "";
+
+  std::vector <Arg> value_stack;
+  eval (task, value_stack);
+
+  return value_stack.back ()._raw;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::eval (const Task& task, std::vector <Arg>& value_stack)
+{
+  // Case sensitivity is configurable.
+  bool case_sensitive = context.config.getBoolean ("search.case.sensitive");
+
+  std::vector <Arg>::iterator arg;
+  for (arg = _args.begin (); arg != _args.end (); ++arg)
+  {
+    if (arg->_category == "op")
+    {
+      Arg result;
+
+      // Unary operators.
+      if (arg->_raw == "!")
+      {
+        Arg right = value_stack.back ();
+        value_stack.pop_back ();
+        operator_not (result, right);
+      }
+
+      // Binary operators.
+      else
+      {
+        Arg right = value_stack.back ();
+        value_stack.pop_back ();
+        Arg left = value_stack.back ();
+        value_stack.pop_back ();
+
+             if (arg->_raw == "and") operator_and      (result, left, right);
+        else if (arg->_raw == "or")  operator_or       (result, left, right);
+        else if (arg->_raw == "xor") operator_xor      (result, left, right);
+        else if (arg->_raw == "<")   operator_lt       (result, left, right);
+        else if (arg->_raw == "<=")  operator_lte      (result, left, right);
+        else if (arg->_raw == ">=")  operator_gte      (result, left, right);
+        else if (arg->_raw == ">")   operator_gt       (result, left, right);
+        else if (arg->_raw == "!=")  operator_inequal  (result, left, right);
+        else if (arg->_raw == "=")   operator_equal    (result, left, right);
+        else if (arg->_raw == "~")   operator_match    (result, left, right);
+        else if (arg->_raw == "!~")  operator_nomatch  (result, left, right);
+        else if (arg->_raw == "*")   operator_multiply (result, left, right);
+        else if (arg->_raw == "/")   operator_divide   (result, left, right);
+        else if (arg->_raw == "+")   operator_add      (result, left, right);
+        else if (arg->_raw == "-")   operator_subtract (result, left, right);
+        else
+          throw std::string ("Unsupported operator '") + arg->_raw + "'.";
+      }
+
+      // Store the result.
+      value_stack.push_back (result);
+    }
+
+    // Operand.
+    else
+    {
+      value_stack.push_back (*arg);
+    }
+  }
+
+  // Check for stack remnants.
+  if (value_stack.size () != 1)
+    throw std::string ("Error: Expression::eval found extra items on the stack.");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_not (Arg& result, Arg& left)
+{
+
+  std::cout << "# not " << left._raw << "/" << left._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_and (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " and "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_or (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " or "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_xor (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " xor "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_lt (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " < "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_lte (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " <= "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_gte (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " >= "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_gt (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " > "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_inequal (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " != "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_equal (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " = "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_match (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " ~ "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_nomatch (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " !~ "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_multiply (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " * "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_divide (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " / "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_add (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " + "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void E9::operator_subtract (Arg& result, Arg& left, Arg& right)
+{
+
+  std::cout << "# " << left._raw << "/" << left._category
+            << " - "
+            << right._raw << "/" << right._category
+            << " --> "
+            << result._raw << "/" << result._category
+            << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////

src/E9.h

@@ -42,6 +42,29 @@ public:
   bool evalFilter (const Task&);
   std::string evalExpression (const Task&);
 
+private:
+  void eval (const Task&, std::vector <Arg>&);
+
+  // Unary.
+  void operator_not (Arg&, Arg&);
+
+  // Binary.
+  void operator_and      (Arg&, Arg&, Arg&);
+  void operator_or       (Arg&, Arg&, Arg&);
+  void operator_xor      (Arg&, Arg&, Arg&);
+  void operator_lt       (Arg&, Arg&, Arg&);
+  void operator_lte      (Arg&, Arg&, Arg&);
+  void operator_gte      (Arg&, Arg&, Arg&);
+  void operator_gt       (Arg&, Arg&, Arg&);
+  void operator_inequal  (Arg&, Arg&, Arg&);
+  void operator_equal    (Arg&, Arg&, Arg&);
+  void operator_match    (Arg&, Arg&, Arg&);
+  void operator_nomatch  (Arg&, Arg&, Arg&);
+  void operator_multiply (Arg&, Arg&, Arg&);
+  void operator_divide   (Arg&, Arg&, Arg&);
+  void operator_add      (Arg&, Arg&, Arg&);
+  void operator_subtract (Arg&, Arg&, Arg&);
+
 private:
   A3 _args;
   std::map <std::string, RX> _regexes;

src/commands/CmdShow.cpp

@@ -269,16 +269,6 @@ int CmdShow::execute (std::string& output)
   if (context.args.size () == 2)
     section = context.args[1];
 */
-/*
-  Arguments args = context.args.extract_read_only_filter ();
-  std::vector <std::pair <std::string, std::string> >::iterator arg;
-  for (arg = args.begin (); arg != args.end (); ++arg)
-  {
-    if (arg->second == "string")
-    {
-    }
-  }
-*/
 
   if (section == "all")
     section = "";

src/commands/Command.cpp

@@ -31,6 +31,7 @@
 #include <vector>
 #include <stdlib.h>
 #include <Expression.h>
+#include <E9.h>
 #include <Att.h>
 #include <Timer.h>
 #include <text.h>
@@ -82,8 +83,8 @@
 #include <CmdUndo.h>
 #include <CmdUrgency.h>
 #include <CmdVersion.h>
-#include <Context.h>
 
+#include <Context.h>
 #include <ColProject.h>
 #include <ColPriority.h>
 #include <ColDue.h>
@@ -268,10 +269,8 @@ void Command::filter (std::vector <Task>& input, std::vector <Task>& output)
 {
   Timer timer ("Command::filter");
 
-/**/
   A3 filt = context.a3.extract_filter ();
   filt.dump ("extract_filter");
-/**/
 
   Arguments f;
   if (read_only ())
@@ -282,6 +281,7 @@ void Command::filter (std::vector <Task>& input, std::vector <Task>& output)
   if (f.size ())
   {
     Expression e (f);
+    E9 expr (filt);
 
     std::vector <Task>::iterator task;
     for (task = input.begin (); task != input.end (); ++task)
@@ -298,14 +298,9 @@ void Command::filter (std::vector <Task>& output)
 {
   Timer timer ("Command::filter");
 
-/**/
   A3 filt = context.a3.extract_filter ();
   filt.dump ("extract_filter");
 
-  A3 mods = context.a3.extract_modifications ();
-  mods.dump ("extract_modifications");
-/**/
-
   Arguments f;
   if (read_only ())
     f = context.args.extract_read_only_filter ();
@@ -316,6 +311,7 @@ void Command::filter (std::vector <Task>& output)
   {
     const std::vector <Task>& pending = context.tdb2.pending.get_tasks ();
     Expression e (f);
+    E9 expr (filt);
 
     output.clear ();
     std::vector <Task>::const_iterator task;