xo-reader2: refactor: make() + _make() pair for each ssm

xo-reader2/include/xo/reader2/DApplySsm.hpp

@@ -88,8 +88,12 @@ namespace xo {
             /** create instance using memory from @p parser_mm.
              *  with function to be called supplied by @p fn_expr.
              **/
-            static DApplySsm * make(DArena & parser_mm,
+            static DApplySsm * _make(DArena & parser_mm,
-                                    obj<AExpression> fn_expr);
+                                     obj<AExpression> fn_expr);
+
+            /** create fop referring to new DApplySsm **/
+            static obj<ASyntaxStateMachine,DApplySsm> make(DArena & parser_mm,
+                                                           obj<AExpression> fn_expr);
 
             /**
              * Start apply. Will trigger this after input like

xo-reader2/include/xo/reader2/DExpectExprSsm.hpp

@@ -25,9 +25,14 @@ namespace xo {
             explicit DExpectExprSsm(bool allow_defs,
                                     bool cxl_on_rightparen);
 
-            static DExpectExprSsm * make(DArena & parser_mm,
+            static DExpectExprSsm * _make(DArena & parser_mm,
-                                         bool allow_defs,
+                                          bool allow_defs,
-                                         bool cxl_on_rightbrace);
+                                          bool cxl_on_rightbrace);
+
+            /** create fop referring to new DExpectExprSsm **/
+            static obj<ASyntaxStateMachine,DExpectExprSsm> make(DArena & parser_mm,
+                                                                bool allow_defs,
+                                                                bool cxl_on_rightbrace);
 
             static void start(DArena & parser_mm,
                               bool allow_defs,

xo-reader2/include/xo/reader2/DExpectSymbolSsm.hpp

@@ -29,7 +29,10 @@ namespace xo {
             DExpectSymbolSsm();
 
             /** create instance using memory from @p parser_mm **/
-            static DExpectSymbolSsm * make(DArena & parser_mm);
+            static DExpectSymbolSsm * _make(DArena & parser_mm);
+
+            /** create fop referring to new DExpectSymbolSsm **/
+            static obj<ASyntaxStateMachine,DExpectSymbolSsm> make(DArena & parser_mm);
 
             /** start nested parser expecting a symbol,
              *  on top of parser state machine @p p_psm.

xo-reader2/include/xo/reader2/DExpectTypeSsm.hpp

@@ -6,6 +6,7 @@
 #pragma once
 
 #include "DSyntaxStateMachine.hpp"
+#include <xo/facet/obj.hpp>
 #include <xo/indentlog/print/ppindentinfo.hpp>
 
 namespace xo {
@@ -31,7 +32,10 @@ namespace xo {
         public:
             DExpectTypeSsm();
 
-            static DExpectTypeSsm * make(DArena & parser_mm);
+            static DExpectTypeSsm * _make(DArena & parser_mm);
+
+            /** create fop referring to new DExpectTypeSsm **/
+            static obj<ASyntaxStateMachine,DExpectTypeSsm> make(DArena & parser_mm);
 
             static void start(ParserStateMachine * p_psm);
 

xo-reader2/include/xo/reader2/DIfElseSsm.hpp

@@ -65,20 +65,16 @@ namespace xo {
             ///@{
             explicit DIfElseSsm(DIfElseExpr * ifelse_expr);
 
-#ifdef NOT_YET
-            /** create instance using memory from @p parser_mm
-             *  with initial scaffold @p ifelse_expr
-             **/
-            static obj<AExpression,DIfElseSsm> make(DArena & parser_mm,
-                                                    DIfElseExpr * ifelse_expr);
-#endif
-
             /** create instance using memory from @p parser_mm
              *  with initial scaffold @p ifelse_expr.
              **/
             static DIfElseSsm * _make(DArena & parser_mm,
                                       DIfElseExpr * ifelse_expr);
 
+            /** create fop referring to new DIfElseSsm **/
+            static obj<ASyntaxStateMachine,DIfElseSsm> make(DArena & parser_mm,
+                                                            DIfElseExpr * ifelse_expr);
+
             /** start nested parser for an if-else expression
              *  on top of parser state machine @p p_psm.
              *  Use @p parser_mm to allocate syntax state machines

xo-reader2/include/xo/reader2/DProgressSsm.hpp

@@ -96,9 +96,14 @@ namespace xo {
         public:
             DProgressSsm(obj<AExpression> lhs, optype op);
 
-            static DProgressSsm * make(DArena & parser_mm,
+            static DProgressSsm * _make(DArena & parser_mm,
-                                       obj<AExpression> lhs,
+                                        obj<AExpression> lhs,
-                                       optype op);
+                                        optype op);
+
+            /** create fop referring to new DProgressSsm **/
+            static obj<ASyntaxStateMachine,DProgressSsm> make(DArena & parser_mm,
+                                                              obj<AExpression> lhs,
+                                                              optype op);
 
             static void start(DArena & parser_mm,
                               ParserStateMachine * p_psm);

xo-reader2/src/reader2/DApplySsm.cpp

@@ -58,8 +58,8 @@ namespace xo {
         }
 
         DApplySsm *
-        DApplySsm::make(DArena & arena,
+        DApplySsm::_make(DArena & arena,
-                        obj<AExpression> fn_expr)
+                         obj<AExpression> fn_expr)
         {
             obj<AAllocator,DArena> mm(&arena);
 
@@ -83,6 +83,13 @@ namespace xo {
             return new (mem) DApplySsm(applystate, fn_expr, args);
         }
 
+        obj<ASyntaxStateMachine,DApplySsm>
+        DApplySsm::make(DArena & arena,
+                        obj<AExpression> fn_expr)
+        {
+            return obj<ASyntaxStateMachine,DApplySsm>(_make(arena, fn_expr));
+        }
+
         void
         DApplySsm::start(obj<AExpression> fn_expr,
                          ParserStateMachine * p_psm)
@@ -91,10 +98,7 @@ namespace xo {
 
             DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
 
-            DApplySsm * apply_ssm
+            auto ssm = DApplySsm::make(p_psm->parser_alloc(), fn_expr);
-                = DApplySsm::make(p_psm->parser_alloc(), fn_expr);
-
-            obj<ASyntaxStateMachine,DApplySsm> ssm(apply_ssm);
 
             p_psm->push_ssm(ckp, ssm);
         }

xo-reader2/src/reader2/DExpectExprSsm.cpp

@@ -52,9 +52,9 @@ namespace xo {
         }
 
         DExpectExprSsm *
-        DExpectExprSsm::make(DArena & mm,
+        DExpectExprSsm::_make(DArena & mm,
-                             bool allow_defs,
+                              bool allow_defs,
-                             bool cxl_on_rightbrace)
+                              bool cxl_on_rightbrace)
         {
             void * mem = mm.alloc(typeseq::id<DExpectExprSsm>(),
                                   sizeof(DExpectExprSsm));
@@ -63,6 +63,14 @@ namespace xo {
                                             cxl_on_rightbrace);
         }
 
+        obj<ASyntaxStateMachine,DExpectExprSsm>
+        DExpectExprSsm::make(DArena & mm,
+                             bool allow_defs,
+                             bool cxl_on_rightbrace)
+        {
+            return obj<ASyntaxStateMachine,DExpectExprSsm>(_make(mm, allow_defs, cxl_on_rightbrace));
+        }
+
         void
         DExpectExprSsm::start(DArena & mm,
                               bool allow_defs,
@@ -71,12 +79,7 @@ namespace xo {
         {
             DArena::Checkpoint ckp = mm.checkpoint();
 
-            DExpectExprSsm * exp_expr
+            auto ssm = DExpectExprSsm::make(mm, allow_defs, cxl_on_rightbrace);
-                = DExpectExprSsm::make(mm,
-                                       allow_defs,
-                                       cxl_on_rightbrace);
-            obj<ASyntaxStateMachine> ssm
-                = with_facet<ASyntaxStateMachine>::mkobj(exp_expr);
 
             p_psm->push_ssm(ckp, ssm);
         }

xo-reader2/src/reader2/DExpectSymbolSsm.cpp

@@ -20,7 +20,7 @@ namespace xo {
         {}
 
         DExpectSymbolSsm *
-        DExpectSymbolSsm::make(DArena & mm)
+        DExpectSymbolSsm::_make(DArena & mm)
         {
             void * mem = mm.alloc(typeseq::id<DExpectSymbolSsm>(),
                                   sizeof(DExpectSymbolSsm));
@@ -28,19 +28,18 @@ namespace xo {
             return new (mem) DExpectSymbolSsm();
         }
 
+        obj<ASyntaxStateMachine,DExpectSymbolSsm>
+        DExpectSymbolSsm::make(DArena & mm)
+        {
+            return obj<ASyntaxStateMachine,DExpectSymbolSsm>(_make(mm));
+        }
+
         void
         DExpectSymbolSsm::start(ParserStateMachine * p_psm)
         {
             DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
 
-            DExpectSymbolSsm * sym_ssm
+            auto ssm = DExpectSymbolSsm::make(p_psm->parser_alloc());
-                = DExpectSymbolSsm::make(p_psm->parser_alloc());
-
-            // note:
-            // relying on [ISyntaxStateMachine_DExpectedSymbolSsm.hpp]
-            //
-            obj<ASyntaxStateMachine> ssm
-                = with_facet<ASyntaxStateMachine>::mkobj(sym_ssm);
 
             p_psm->push_ssm(ckp, ssm);
         }

xo-reader2/src/reader2/DExpectTypeSsm.cpp

@@ -23,7 +23,7 @@ namespace xo {
         {}
 
         DExpectTypeSsm *
-        DExpectTypeSsm::make(DArena & mm)
+        DExpectTypeSsm::_make(DArena & mm)
         {
             void * mem = mm.alloc(typeseq::id<DArena>(),
                                   sizeof(DArena));
@@ -31,16 +31,18 @@ namespace xo {
             return new (mem) DExpectTypeSsm();
         }
 
+        obj<ASyntaxStateMachine,DExpectTypeSsm>
+        DExpectTypeSsm::make(DArena & mm)
+        {
+            return obj<ASyntaxStateMachine,DExpectTypeSsm>(_make(mm));
+        }
+
         void
         DExpectTypeSsm::start(ParserStateMachine * p_psm)
         {
             DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
 
-            DExpectTypeSsm * expect_type_ssm
+            auto ssm = DExpectTypeSsm::make(p_psm->parser_alloc());
-                = DExpectTypeSsm::make(p_psm->parser_alloc());
-
-            auto ssm
-                = with_facet<ASyntaxStateMachine>::mkobj(expect_type_ssm);
 
             p_psm->push_ssm(ckp, ssm);
         }

xo-reader2/src/reader2/DIfElseSsm.cpp

@@ -63,6 +63,13 @@ namespace xo {
             return new (mem) DIfElseSsm(ifelse_expr);
         }
 
+        obj<ASyntaxStateMachine,DIfElseSsm>
+        DIfElseSsm::make(DArena & mm,
+                         DIfElseExpr * ifelse_expr)
+        {
+            return obj<ASyntaxStateMachine,DIfElseSsm>(_make(mm, ifelse_expr));
+        }
+
         void
         DIfElseSsm::start(DArena & parser_mm,
                           obj<AAllocator> expr_mm,
@@ -73,10 +80,8 @@ namespace xo {
             DArena::Checkpoint ckp = parser_mm.checkpoint();
 
             DIfElseExpr * if_expr = DIfElseExpr::_make_empty(expr_mm);
-            DIfElseSsm * if_ssm = DIfElseSsm::_make(parser_mm, if_expr);
 
-            obj<ASyntaxStateMachine> ssm
+            auto ssm = DIfElseSsm::make(parser_mm, if_expr);
-                = with_facet<ASyntaxStateMachine>::mkobj(if_ssm);
 
             p_psm->push_ssm(ckp, ssm);
 

xo-reader2/src/reader2/DProgressSsm.cpp

@@ -146,16 +146,22 @@ namespace xo {
         }
 
         DProgressSsm *
-        DProgressSsm::make(DArena & mm,
+        DProgressSsm::_make(DArena & mm,
-                           obj<AExpression> lhs,
+                            obj<AExpression> lhs,
-                           optype op)
+                            optype op)
         {
             void * mem = mm.alloc(typeseq::id<DProgressSsm>(),
                                   sizeof(DProgressSsm));
 
             return new (mem) DProgressSsm(lhs, op);
+        }
 
-            //return std::make_unique<progress_xs>(progress_xs(std::move(valex), op));
+        obj<ASyntaxStateMachine,DProgressSsm>
+        DProgressSsm::make(DArena & mm,
+                           obj<AExpression> lhs,
+                           optype op)
+        {
+            return obj<ASyntaxStateMachine,DProgressSsm>(_make(mm, lhs, op));
         }
 
         void
@@ -166,10 +172,7 @@ namespace xo {
         {
             DArena::Checkpoint ckp = parser_mm.checkpoint();
 
-            DProgressSsm * progress_ssm
+            auto ssm = DProgressSsm::make(parser_mm, lhs, op);
-                = DProgressSsm::make(parser_mm, lhs, op);
-
-            obj<ASyntaxStateMachine,DProgressSsm> ssm(progress_ssm);
 
             p_psm->push_ssm(ckp, ssm);
         }