xo-reader: + DDefineSsm + utest

src/reader2/CMakeLists.txt

@@ -15,6 +15,7 @@ set(SELF_SRCS
     ISyntaxStateMachine_DExprSeqState.cpp
 
     DDefineSsm.cpp
+    ISyntaxStateMachine_DDefineSsm.cpp
 
     reader2_register_facets.cpp
     reader2_register_types.cpp

src/reader2/DDefineSsm.cpp

@@ -4,6 +4,8 @@
  **/
 
 #include "DDefineSsm.hpp"
+#include "ssm/ISyntaxStateMachine_DDefineSsm.hpp"
+
 #ifdef NOT_YET
 #include "parserstatemachine.hpp"
 #include "expect_symbol_xs.hpp"
@@ -13,6 +15,9 @@
 #endif
 
 namespace xo {
+    using xo::facet::with_facet;
+    using xo::facet::typeseq;
+
     namespace scm {
         // ----- defexprstatetype -----
 
@@ -46,16 +51,11 @@ namespace xo {
         define_xs::make() {
             return std::make_unique<define_xs>(define_xs(DefineExprAccess::make_empty()));
         }
+#endif
 
-        void
-        define_xs::start(parserstatemachine * p_psm)
-        {
-            scope log(XO_DEBUG(p_psm->debug_flag()));
-
-            p_psm->push_exprstate(define_xs::make());
-            p_psm->top_exprstate().on_def_token(token_type::def(), p_psm);
-        }
+        // DDefineSsm::start
 
+#ifdef NOT_YET
         define_xs::define_xs(rp<DefineExprAccess> def_expr)
             : exprstate(exprstatetype::defexpr),
               defxs_type_{defexprstatetype::def_0},
@@ -333,6 +333,36 @@ namespace xo {
 
         ////////////////////////////////////////////////////////////////
 
+        DDefineSsm::DDefineSsm()
+            : defstate_{defexprstatetype::def_0}
+        {}
+
+        DDefineSsm *
+        DDefineSsm::make(DArena & mm)
+        {
+            void * mem = mm.alloc(typeseq::id<DDefineSsm>(),
+                                  sizeof(DDefineSsm));
+
+            return new (mem) DDefineSsm();
+        }
+
+        void
+        DDefineSsm::start(DArena & mm,
+                          ParserStateMachine * p_psm)
+        {
+            //scope log(XO_DEBUG(p_psm->debug_flag()));
+
+            assert(p_psm->stack());
+
+            DDefineSsm * define_ssm = DDefineSsm::make(mm);
+
+            obj<ASyntaxStateMachine> ssm
+                = with_facet<ASyntaxStateMachine>::mkobj(define_ssm);
+
+            p_psm->push_ssm(ssm);
+            p_psm->on_def_token(Token::def_token());
+        }
+
         syntaxstatetype
         DDefineSsm::ssm_type() const noexcept
         {
@@ -380,6 +410,21 @@ namespace xo {
             return "?expect";
         }
 
+        void
+        DDefineSsm::on_def_token(const Token & tk,
+                                 ParserStateMachine * p_psm)
+        {
+            if (this->defstate_ == defexprstatetype::def_0) {
+                this->defstate_ = defexprstatetype::def_1;
+
+                // expect_symbol_xs::start(p_psm->parser_alloc(), p_psm);
+            }
+
+            p_psm->illegal_input_on_token("DDefineSsm::on_define_token",
+                                          tk,
+                                          this->get_expect_str());
+        }
+
         void
         DDefineSsm::on_if_token(const Token & tk,
                                 ParserStateMachine * p_psm)

src/reader2/DExprSeqState.cpp

@@ -4,6 +4,7 @@
  **/
 
 #include "DExprSeqState.hpp"
+#include "DDefineSsm.hpp"
 #include "ssm/ISyntaxStateMachine_DExprSeqState.hpp"
 
 namespace xo {
@@ -73,13 +74,30 @@ namespace xo {
             return "impossible-DExprSeqState::get_expr_str";
         }
 
+        void
+        DExprSeqState::on_def_token(const Token & tk,
+                                    ParserStateMachine * p_psm)
+        {
+            (void)tk;
+
+            DDefineSsm::start(p_psm->parser_alloc(), p_psm);
+
+            /* keyword 'def' introduces a definition:
+             *   def pi : f64 = 3.14159265
+             *   def sq(x : f64) -> f64 { (x * x) }
+             */
+        }
+
         void
         DExprSeqState::on_if_token(const Token & tk,
                                    ParserStateMachine * p_psm)
         {
             switch (seqtype_) {
             case exprseqtype::toplevel_interactive:
-                assert(false); // DfElseState::start(p_psm);
+                p_psm->illegal_input_on_token("DExprSeqState::on_if_token",
+                                              tk,
+                                              this->get_expect_str());
+                //assert(false); // DfElseState::start(p_psm);
                 break;
             case exprseqtype::toplevel_batch:
                 p_psm->illegal_input_on_token("DExprSeqState::on_if_token",

src/reader2/ISyntaxStateMachine_Any.cpp

@@ -34,6 +34,12 @@ ISyntaxStateMachine_Any::_valid
 
 // nonconst methods
 
+auto
+ISyntaxStateMachine_Any::on_def_token(Opaque, const Token &, ParserStateMachine *)  -> void
+{
+    _fatal();
+}
+
 auto
 ISyntaxStateMachine_Any::on_if_token(Opaque, const Token &, ParserStateMachine *)  -> void
 {

src/reader2/ISyntaxStateMachine_DExprSeqState.cpp

@@ -2,7 +2,7 @@
  *
  *  Generated automagically from ingredients:
  *  1. code generator:
- *       [/home/roland/proj/xo-umbrella2-claude1/xo-facet/codegen/genfacet]
+ *       [/Users/roland/proj/xo-umbrella2/xo-facet/codegen/genfacet]
  *     arguments:
  *       --input [idl/ISyntaxStateMachine_DExprSeqState.json5]
  *  2. jinja2 template for abstract facet .hpp file:
@@ -28,7 +28,16 @@ namespace xo {
         }
 
         auto
-        ISyntaxStateMachine_DExprSeqState::on_if_token(DExprSeqState & self, const Token & tk, ParserStateMachine * p_psm) -> void
+        ISyntaxStateMachine_DExprSeqState::on_def_token(DExprSeqState & self,
+                                                        const Token & tk,
+                                                        ParserStateMachine * p_psm) -> void
+        {
+            self.on_def_token(tk, p_psm);
+        }
+        auto
+        ISyntaxStateMachine_DExprSeqState::on_if_token(DExprSeqState & self,
+                                                       const Token & tk,
+                                                       ParserStateMachine * p_psm) -> void
         {
             self.on_if_token(tk, p_psm);
         }
@@ -36,4 +45,4 @@ namespace xo {
     } /*namespace scm*/
 } /*namespace xo*/
 
-/* end ISyntaxStateMachine_DExprSeqState.cpp */
+/* end ISyntaxStateMachine_DExprSeqState.cpp */

src/reader2/ParserStateMachine.cpp

@@ -48,8 +48,7 @@ namespace xo {
 
             auto alloc = with_facet<AAllocator>::mkobj(&parser_alloc_);
 
-            this->stack_ = ParserStack::push(nullptr /*stack*/,
-                                             alloc, ssm);
+            this->stack_ = ParserStack::push(nullptr /*stack*/, alloc, ssm);
             this->parser_alloc_ckp_ = parser_alloc_.checkpoint();
         }
 
@@ -96,11 +95,14 @@ namespace xo {
             }
 
             switch (tk.tk_type()) {
+            case tokentype::tk_def:
+                this->on_def_token(tk);
+                break;
+
             case tokentype::tk_if:
                 this->on_if_token(tk);
                 break;
 
-
             // all the not-yet handled cases
             case tokentype::tk_invalid:
             case tokentype::tk_bool:
@@ -133,7 +135,6 @@ namespace xo {
             case tokentype::tk_cmpeq:
             case tokentype::tk_cmpne:
             case tokentype::tk_type:
-            case tokentype::tk_def:
             case tokentype::tk_lambda:
             case tokentype::tk_then:
             case tokentype::tk_else:
@@ -141,12 +142,21 @@ namespace xo {
             case tokentype::tk_in:
             case tokentype::tk_end:
             case tokentype::N:
-                throw std::runtime_error(tostr("NOT IMPLEMENTED",
+                throw std::runtime_error(tostr("ParserStateMachin::on_token:",
+                                               "NOT IMPLEMENTED",
                                                xtag("token", tk)));
 
             }
         }
 
+        void
+        ParserStateMachine::on_def_token(const Token & tk)
+        {
+            scope log(XO_DEBUG(debug_flag_), xtag("tk", tk));
+
+            stack_->top().on_def_token(tk, this);
+        }
+
         void
         ParserStateMachine::on_if_token(const Token & tk)
         {

src/reader2/SchematikaParser.cpp

@@ -43,7 +43,7 @@ namespace xo {
         }
 
         void
-        SchematikaParser::begin_translation_unit() {
+        SchematikaParser::begin_batch_session() {
             DExprSeqState::establish_batch(*(psm_.expr_alloc()), &psm_);
         }