From 44fdba132c3efd0a5b1a157bb7946cb245e77e57 Mon Sep 17 00:00:00 2001
From: Roland Conybeare <rconybeare@gmail.com>
Date: Thu, 1 Aug 2024 13:32:15 +1000
Subject: [PATCH] xo-parser: refactor: exprstate::on_symbol splits symbol from
 exprir

---
 include/xo/parser/parser.hpp | 10 ++++++-
 src/parser/parser.cpp        | 54 ++++++++++++++++++++++++++++--------
 2 files changed, 52 insertions(+), 12 deletions(-)

diff --git a/include/xo/parser/parser.hpp b/include/xo/parser/parser.hpp
index db6ea524..57d4b319 100644
--- a/include/xo/parser/parser.hpp
+++ b/include/xo/parser/parser.hpp
@@ -47,15 +47,17 @@ namespace xo {
 
         public:
             exprir() = default;
+#ifdef OBSOLETE
             exprir(exprirtype xir_type,
                    const std::string & x)
                 : xir_type_{xir_type}, symbol_name_{x} {}
+#endif
             exprir(exprirtype xir_type,
                    TypeDescr td)
                 : xir_type_{xir_type}, td_{td} {}
 
             exprirtype xir_type() const { return xir_type_; }
-            const std::string & symbol_name() const { return symbol_name_; }
+            //const std::string & symbol_name() const { return symbol_name_; }
             TypeDescr td() const { return td_; }
 
             void print(std::ostream & os) const;
@@ -63,8 +65,10 @@ namespace xo {
         private:
             /** IR type code **/
             exprirtype xir_type_ = exprirtype::invalid;
+#ifdef OBSOLETE
             /** xir_type=symbol: a symbol (type or variable) name **/
             std::string symbol_name_;
+#endif
             /** xir_type=typedescr: object identifying/describing a datatype **/
             TypeDescr td_ = nullptr;
         };
@@ -220,6 +224,10 @@ namespace xo {
             void on_expr(ref::brw<Expression> expr,
                          exprstatestack * p_stack,
                          rp<Expression> * p_emit_expr);
+            /** update exprstate when expecting a symbol **/
+            void on_symbol(const std::string & symbol,
+                           exprstatestack * p_stack,
+                           rp<Expression> * p_emit_expr);
             /** update exprstate in response to IR (intermediate representation)
              *  from nested parsing task
              **/
diff --git a/src/parser/parser.cpp b/src/parser/parser.cpp
index 8772e7fd..600c7191 100644
--- a/src/parser/parser.cpp
+++ b/src/parser/parser.cpp
@@ -40,8 +40,8 @@ namespace xo {
         void
         exprir::print(std::ostream & os) const {
             os << "<exprir"
-               << xtag("type", xir_type_)
-               << xtag("symbol_name", symbol_name_);
+               << xtag("type", xir_type_);
+                //<< xtag("symbol_name", symbol_name_);
             if (td_)
                 os << xtag("td", td_->short_name());
             os << ">";
@@ -310,8 +310,8 @@ namespace xo {
                 /* have to do pop first */
 
                 p_stack->pop_exprstate();
-                p_stack->top_exprstate().on_exprir(exprir(exprirtype::symbol, tk.text()), p_stack, p_emit_expr);
-                //return expraction::pop(exprir(exprirtype::symbol, tk.text()));
+                p_stack->top_exprstate().on_symbol(tk.text(),
+                                                   p_stack, p_emit_expr);
                 return;
 
             case exprstatetype::expect_type: {
@@ -572,15 +572,10 @@ namespace xo {
         }
 
         void
-        exprstate::on_exprir(const exprir & ir,
+        exprstate::on_symbol(const std::string & symbol_name,
                              exprstatestack * /*p_stack*/,
                              rp<Expression> * /*p_emit_expr*/)
         {
-            constexpr bool c_debug_flag = true;
-            scope log(XO_DEBUG(c_debug_flag));
-            log && log(xtag("ir", ir));
-            log && log(xtag("state", *this));
-
             switch(this->exs_type_) {
             case exprstatetype::expect_toplevel_expression_sequence:
                 /* toplevel expression sequence accepts an
@@ -594,9 +589,46 @@ namespace xo {
                 return;
             case exprstatetype::def_0:
                 this->exs_type_ = exprstatetype::def_1;
-                this->def_lhs_symbol_ = ir.symbol_name();
+                this->def_lhs_symbol_ = symbol_name;
 
                 return;
+            case exprstatetype::def_1:
+            case exprstatetype::def_2:
+            case exprstatetype::def_3:
+            case exprstatetype::def_4:
+                /* NOT IMPLEMENTED */
+                assert(false);
+                return;
+
+            case exprstatetype::expect_rhs_expression:
+            case exprstatetype::expect_type:
+            case exprstatetype::expect_symbol:
+                /* unreachable
+                 * (this exprstate issues pop instruction from exprstate::on_input()
+                 */
+                assert(false);
+                return;
+            case exprstatetype::invalid:
+            case exprstatetype::n_exprstatetype:
+                /* unreachable */
+                assert(false);
+                return;
+            }
+        }
+
+        void
+        exprstate::on_exprir(const exprir & ir,
+                             exprstatestack * /*p_stack*/,
+                             rp<Expression> * /*p_emit_expr*/)
+        {
+            constexpr bool c_debug_flag = true;
+            scope log(XO_DEBUG(c_debug_flag));
+            log && log(xtag("ir", ir));
+            log && log(xtag("state", *this));
+
+            switch(this->exs_type_) {
+            case exprstatetype::expect_toplevel_expression_sequence:
+            case exprstatetype::def_0:
             case exprstatetype::def_1:
                 /* NOT IMPLEMENTED */
                 assert(false);