xo-reader: refactor: + expect_expr_xs cls [wip]

include/xo/reader/expect_expr_xs.hpp

@@ -0,0 +1,29 @@
+/* file expect_expr_xs.hpp
+ *
+ * author: Roland Conybeare, Aug 2024
+ */
+
+#pragma once
+
+#include "exprstate.hpp"
+
+namespace xo {
+    namespace scm {
+
+        /** @class expect_expr_xs
+         *  @brief state machine to expect + capture an expression
+         **/
+        class expect_expr_xs : public exprstate {
+        public:
+            expect_expr_xs();
+
+            static std::unique_ptr<expect_expr_xs> expect_rhs_expression();
+
+        private:
+        };
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+
+/* end expect_expr_xs.hpp */

include/xo/reader/exprstate.hpp

@@ -70,9 +70,11 @@ namespace xo {
                 {}
             virtual ~exprstate() = default;
 
+#ifdef RELOCATED
             static std::unique_ptr<exprstate> expect_rhs_expression() {
                 return std::make_unique<exprstate>(exprstate(exprstatetype::expect_rhs_expression));
             }
+#endif
             static std::unique_ptr<exprstate> expect_symbol() {
                 return std::make_unique<exprstate>(exprstate(exprstatetype::expect_symbol));
             }

src/reader/CMakeLists.txt

@@ -8,7 +8,8 @@ set(SELF_SRCS
     define_xs.cpp
     progress_xs.cpp
     paren_xs.cpp
-    exprseq_xs.cpp)
+    exprseq_xs.cpp
+    expect_expr_xs.cpp)
 
 xo_add_shared_library4(${SELF_LIB} ${PROJECT_NAME}Targets ${PROJECT_VERSION} 1 ${SELF_SRCS})
 xo_dependency(${SELF_LIB} xo_expression)

src/reader/define_xs.cpp

@@ -1,6 +1,7 @@
 /* @file define_xs.cpp */
 
 #include "define_xs.hpp"
+#include "expect_expr_xs.hpp"
 
 namespace xo {
     namespace scm {
@@ -15,35 +16,6 @@ namespace xo {
               def_expr_{std::move(def_expr)}
         {}
 
-#ifdef OBSOLETE
-        bool
-        define_xs::admits_definition() const
-        {
-            switch (defxs_type_) {
-
-            case defexprstatetype::def_0:
-            case defexprstatetype::def_1:
-            case defexprstatetype::def_2:
-            case defexprstatetype::def_3:
-            case defexprstatetype::def_4:
-            case defexprstatetype::def_5:
-                /* note for def_4:
-                 * rhs could certainly be a function body that contains
-                 * nested defines; but then immediately-enclosing-exprstate
-                 * would be a block
-                 */
-                return false;
-            case defexprstatetype::invalid:
-            case defexprstatetype::n_defexprstatetype:
-                /* unreachable */
-                assert(false);
-                return false;
-            }
-
-            return false;
-        }
-#endif
-
         bool
         define_xs::admits_symbol() const {
             switch (defxs_type_) {
@@ -401,7 +373,7 @@ namespace xo {
             {
                 this->defxs_type_ = defexprstatetype::def_4;
 
-                p_stack->push_exprstate(exprstate::expect_rhs_expression());
+                p_stack->push_exprstate(expect_expr_xs::expect_rhs_expression());
             } else {
                 assert(false);
             }

src/reader/expect_expr_xs.cpp

@@ -0,0 +1,24 @@
+/* file expect_expr_xs.cpp
+ *
+ * author: Roland Conybeare
+ */
+
+#include "expect_expr_xs.hpp"
+
+namespace xo {
+    namespace scm {
+
+        std::unique_ptr<expect_expr_xs>
+        expect_expr_xs::expect_rhs_expression() {
+            return std::make_unique<expect_expr_xs>(expect_expr_xs());
+
+        }
+
+        expect_expr_xs::expect_expr_xs()
+            : exprstate(exprstatetype::expect_rhs_expression)
+        {}
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end expect_expr_xs.cpp */

src/reader/exprstate.cpp

@@ -4,6 +4,7 @@
 #include "define_xs.hpp"
 #include "progress_xs.hpp"
 #include "paren_xs.hpp"
+#include "expect_expr_xs.hpp"
 //#include "xo/expression/DefineExpr.hpp"
 #include "xo/expression/Constant.hpp"
 //#include "xo/expression/ConvertExpr.hpp"
@@ -491,7 +492,7 @@ namespace xo {
             if (this->exs_type_ == exprstatetype::expect_rhs_expression) {
                 /* push lparen_0 to remember to look for subsequent rightparen. */
                 p_stack->push_exprstate(paren_xs::lparen_0());
-                p_stack->push_exprstate(exprstate::expect_rhs_expression());
+                p_stack->push_exprstate(expect_expr_xs::expect_rhs_expression());
             }
         }
 
@@ -660,7 +661,7 @@ namespace xo {
 
             case exprstatetype::expect_rhs_expression: {
 
-                std::unique_ptr<exprstate> self = p_stack->pop_exprstate(); /* NOT KOSHER.  invalidates *this */
+                std::unique_ptr<exprstate> self = p_stack->pop_exprstate();
 
                 p_stack->top_exprstate().on_expr(expr,
                                                  p_stack,