xo-reader: refactor: splitoff defexpr state machine from exprstate

include/xo/reader/define_xs.hpp

@@ -10,6 +10,19 @@
 
 namespace xo {
     namespace scm {
+        enum class defexprstatetype {
+            invalid = -1,
+
+            def_0,
+            def_1,
+            def_2,
+            def_3,
+            def_4,
+            def_5,
+
+            n_defexprstatetype,
+        };
+
         /** @class define_xs
          *  @brief state to provide parsing of a define-expression
          **/
@@ -18,8 +31,11 @@ namespace xo {
             define_xs(rp<DefineExprAccess> def_expr);
             virtual ~define_xs() = default;
 
+            static const define_xs * from(const exprstate * x) { return dynamic_cast<const define_xs *>(x); }
             static std::unique_ptr<define_xs> def_0(rp<DefineExprAccess> def_expr);
 
+            defexprstatetype defxs_type() const { return defxs_type_; }
+
             virtual bool admits_definition() const override;
             virtual bool admits_symbol() const override;
             virtual bool admits_colon() const override;
@@ -71,6 +87,7 @@ namespace xo {
              *   (done): definition complete,  pop exprstate from stack
              *
              **/
+            defexprstatetype defxs_type_;
         };
     } /*namespace scm*/
 } /*namespace xo*/

include/xo/reader/exprstate.hpp

@@ -20,12 +20,15 @@ namespace xo {
             /** toplevel of some translation unit **/
             expect_toplevel_expression_sequence,
 
+            defexpr,
+#ifdef OBSOLETE
             def_0,
             def_1,
             def_2,
             def_3,
             def_4,
             def_5,
+#endif
 
             /* lparen_0: look for expression; capture + advance to lparen_1 */
             lparen_0,
@@ -63,6 +66,8 @@ namespace xo {
         };
 #endif
 
+        class define_xs;
+
         /** state associated with a partially-parsed expression.
          **/
         class exprstate {

include/xo/reader/parser.hpp

@@ -167,6 +167,17 @@ namespace xo {
                 return exprstatetype::invalid;
             }
 
+            exprstate const * i_exstate(std::size_t i) const {
+                std::size_t z = xs_stack_.size();
+
+                if (i < z) {
+                    return xs_stack_[i].get();
+                }
+
+                /* out of bounds */
+                return nullptr;
+            }
+
             /** true iff parser contains state for an incomplete expression.
              *  For this to be true,  parser must have consumed at least one token
              *  since end of last toplevel expression