xo-reader: refactor: move def on_expr() to define_xs subtype

include/xo/reader/define_xs.hpp

@@ -0,0 +1,52 @@
+/** @file define_xs.hpp
+ *
+ *  Author: Roland Conybeare
+ **/
+
+#pragma once
+
+#include "exprstate.hpp"
+//#include <cstdint>
+
+namespace xo {
+    namespace scm {
+        /** @class define_xs
+         *  @brief state to provide parsing of a define-expression
+         **/
+        class define_xs : public exprstate {
+        public:
+            define_xs(rp<DefineExprAccess> def_expr);
+            virtual ~define_xs() = default;
+
+            static std::unique_ptr<define_xs> def_0(rp<DefineExprAccess> def_expr);
+
+            virtual void on_expr(ref::brw<Expression> expr,
+                                 exprstatestack * p_stack,
+                                 rp<Expression> * p_emit_expr) override;
+        private:
+            /**
+             *   def foo : f64 = 1 ;
+             *  ^   ^   ^ ^   ^ ^ ^ ^
+             *  |   |   | |   | | | (done)
+             *  |   |   | |   | | def_4:expect_rhs_expression:expr_progress
+             *  |   |   | |   | def_4:expect_rhs_expression
+             *  |   |   | |   def_3
+             *  |   |   | def_2:expect_type
+             *  |   |   def_1
+             *  |   def_0:expect_symbol
+             *  expect_toplevel_expression_sequence
+             *
+             *   def_0:expect_symbol: got 'def' keyword, symbol to follow
+             *   def_1: got symbol name
+             *   def_2:expect_symbol got (optional) colon, type name to follow
+             *   def_3: got symbol type
+             *   def_4:expect_rhs_expression got (optional) equal sign, value to follow
+             *   (done): definition complete,  pop exprstate from stack
+             *
+             **/
+        };
+    } /*namespace scm*/
+} /*namespace xo*/
+
+
+/** end define_xs.hpp **/

include/xo/reader/exprstate.hpp

@@ -99,9 +99,6 @@ namespace xo {
             static std::unique_ptr<exprstate> make_expr_progress(rp<Expression> expr) {
                 return std::make_unique<exprstate>(exprstate(exprstatetype::expr_progress, expr, nullptr));
             }
-            static std::unique_ptr<exprstate> def_0(rp<DefineExprAccess> def_expr) {
-                return std::make_unique<exprstate>(exprstate(exprstatetype::def_0, nullptr, def_expr));
-            }
             static std::unique_ptr<exprstate> lparen_0() {
                 return std::make_unique<exprstate>(exprstate(exprstatetype::lparen_0, nullptr, nullptr));
             }
@@ -164,26 +161,6 @@ namespace xo {
                                 rp<Expression> * p_emit_expr);
 
         protected:
-            /**
-             *   def foo : f64 = 1 ;
-             *  ^   ^   ^ ^   ^ ^ ^ ^
-             *  |   |   | |   | | | (done)
-             *  |   |   | |   | | def_4:expect_rhs_expression:expr_progress
-             *  |   |   | |   | def_4:expect_rhs_expression
-             *  |   |   | |   def_3
-             *  |   |   | def_2:expect_type
-             *  |   |   def_1
-             *  |   def_0:expect_symbol
-             *  expect_toplevel_expression_sequence
-             *
-             *   def_0:expect_symbol: got 'def' keyword, symbol to follow
-             *   def_1: got symbol name
-             *   def_2:expect_symbol got (optional) colon, type name to follow
-             *   def_3: got symbol type
-             *   def_4:expect_rhs_expression got (optional) equal sign, value to follow
-             *   (done): definition complete,  pop exprstate from stack
-             *
-             **/
             exprstatetype exs_type_;
 
             /** generic expression **/
@@ -255,5 +232,4 @@ namespace xo {
     } /*namespace scm*/
 } /*namespace xo*/
 
-
 /** end exprstate.hpp **/

src/reader/CMakeLists.txt

@@ -3,7 +3,9 @@
 set(SELF_LIB xo_reader)
 set(SELF_SRCS
     parser.cpp
-    reader.cpp)
+    reader.cpp
+    exprstate.cpp
+    define_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

@@ -0,0 +1,71 @@
+/* @file define_xs.cpp */
+
+#include "define_xs.hpp"
+
+namespace xo {
+    namespace scm {
+        define_xs::define_xs(rp<DefineExprAccess> def_expr)
+            : exprstate(exprstatetype::def_0,
+                        nullptr /*gen_expr*/,
+                        def_expr)
+        {}
+
+        void
+        define_xs::on_expr(ref::brw<Expression> expr,
+                           exprstatestack * /* p_stack */,
+                           rp<Expression> * /* p_emit_expr */)
+        {
+            switch (this->exs_type_) {
+            case exprstatetype::expect_toplevel_expression_sequence:
+                assert(false);
+                return;
+
+            case exprstatetype::def_0:
+            case exprstatetype::def_1:
+            case exprstatetype::def_2:
+            case exprstatetype::def_3:
+                /* NOT IMPLEMENTED */
+                assert(false);
+                return;
+            case exprstatetype::def_4: {
+                /* have all the ingredients to create an expression
+                 * representing a definition
+                 *
+                 * 1. if ir_type is a symbol,  interpret as variable name.
+                 *    Need to be able to locate variable by type
+                 * 2. if ir_type is an expression,  adopt as rhs
+                 */
+                rp<Expression> rhs_value = expr.promote();
+
+                if (this->cvt_expr_)
+                    this->cvt_expr_->assign_arg(rhs_value);
+                else
+                    this->def_expr_->assign_rhs(rhs_value);;
+
+                rp<Expression> def_expr = this->def_expr_;
+
+                this->exs_type_ = exprstatetype::def_5;
+                return;
+            }
+
+            case exprstatetype::def_5:
+                assert(false);
+                return;
+
+            case exprstatetype::lparen_0:
+            case exprstatetype::lparen_1:
+            case exprstatetype::expect_rhs_expression:
+            case exprstatetype::expect_type:
+            case exprstatetype::expect_symbol:
+            case exprstatetype::expr_progress:
+            case exprstatetype::invalid:
+            case exprstatetype::n_exprstatetype:
+                /* unreachable */
+                assert(false);
+                return;
+            }
+        }
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end define_xs.cpp */

src/reader/exprstate.cpp

@@ -0,0 +1,15 @@
+/* @file exprstate.cpp */
+
+#include "exprstate.hpp"
+#include "define_xs.hpp"
+
+namespace xo {
+    namespace scm {
+        std::unique_ptr<define_xs>
+        define_xs::def_0(rp<DefineExprAccess> def_expr) {
+            return std::make_unique<define_xs>(define_xs(def_expr));
+        }
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end exprstate.cpp */

src/reader/parser.cpp

@@ -4,6 +4,7 @@
  */
 
 #include "parser.hpp"
+#include "define_xs.hpp"
 #include "xo/expression/DefineExpr.hpp"
 #include "xo/expression/Constant.hpp"
 #include "xo/expression/ConvertExpr.hpp"
@@ -410,7 +411,7 @@ namespace xo {
             }
 
             p_stack->push_exprstate
-                (exprstate::def_0(DefineExprAccess::make_empty()));
+                (define_xs::def_0(DefineExprAccess::make_empty()));
 
             /* todo: replace:
              *   expect_symbol_or_function_signature()
@@ -938,31 +939,9 @@ namespace xo {
             case exprstatetype::def_1:
             case exprstatetype::def_2:
             case exprstatetype::def_3:
-                /* NOT IMPLEMENTED */
+            case exprstatetype::def_4:
-                assert(false);
-                return;
-            case exprstatetype::def_4: {
-                /* have all the ingredients to create an expression
-                 * representing a definition
-                 *
-                 * 1. if ir_type is a symbol,  interpret as variable name.
-                 *    Need to be able to locate variable by type
-                 * 2. if ir_type is an expression,  adopt as rhs
-                 */
-                rp<Expression> rhs_value = expr.promote();
-
-                if (this->cvt_expr_)
-                    this->cvt_expr_->assign_arg(rhs_value);
-                else
-                    this->def_expr_->assign_rhs(rhs_value);;
-
-                rp<Expression> def_expr = this->def_expr_;
-
-                this->exs_type_ = exprstatetype::def_5;
-                return;
-            }
-
             case exprstatetype::def_5:
+                /* unreachable.  see define_xs::on_expr() */
                 assert(false);
                 return;