xo-reader2: use DUniqueString* to report parsed formal

xo-reader2/idl/SyntaxStateMachine.json5

@@ -72,6 +72,16 @@
                 {type: "ParserStateMachine *", name: "p_psm"},
             ],
         },
+        {
+            name: "on_parsed_formal",
+            doc: ["operate state machine for formal emitted by nested ssm"],
+            return_type: "void",
+            args: [
+                {type: "const DUniqueString *", name: "param_name"},
+                {type: "TypeDescr", name: "param_type"},
+                {type: "ParserStateMachine *", name: "p_psm"},
+            ],
+        },
         {
             name: "on_parsed_expression",
             doc: ["update state machine for incoming parsed expression @p expr"],

xo-reader2/include/xo/reader2/DDefineSsm.hpp

@@ -195,6 +195,13 @@ namespace xo {
             void on_parsed_typedescr(TypeDescr td,
                                      ParserStateMachine * p_psm);
 
+            /** update state for this ssm to consume param (name,value)
+             *  emitted by nested @p_psm
+             **/
+            void on_parsed_formal(const DUniqueString * param_name,
+                                  TypeDescr param_type,
+                                  ParserStateMachine * p_psm);
+
             /** update state for this syntax after parsing an expression @p expr,
              *  overall parser state in @p p_psm
              **/

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

@@ -135,6 +135,13 @@ namespace xo {
             void on_parsed_typedescr(TypeDescr td,
                                      ParserStateMachine * p_psm);
 
+            /** update state to consume parsed formal (name, value) from nested ssm,
+             *  with overall parser state in @p p_psm
+             **/
+            void on_parsed_formal(const DUniqueString * param_name,
+                                  TypeDescr param_type,
+                                  ParserStateMachine * p_psm);
+
             /** update state for this syntax after parsing an expression @p expr,
              *  overall parser state in @p p_psm
              **/

xo-reader2/include/xo/reader2/DExpectFormalArgSsm.hpp

@@ -104,6 +104,14 @@ namespace xo {
             void on_parsed_typedescr(TypeDescr td,
                                      ParserStateMachine * p_psm);
 
+            /** consume parsed formal (name,type) = (@p sym, @p td) from nested ssm
+             *  with overall parser state in @p p_psm.
+             *  (In practice not reachable)
+             **/
+            void on_parsed_formal(const DUniqueString * sym,
+                                  TypeDescr td,
+                                  ParserStateMachine * p_psm);
+
             /** update state on parsed expression emitted by nested ssm
              *  with overall parser state in @p p_psm
              **/
@@ -151,11 +159,6 @@ namespace xo {
 
             /** formal parameter name **/
             const DUniqueString * name_ = nullptr;
-
-#ifdef NOT_YET
-            /** formal parameter type (if specified) **/
-            TypeDescr td_ = nullptr;
-#endif
         };
     } /*namespace scm*/
 } /*namespace xo*/

xo-reader2/include/xo/reader2/DExpectFormalArglistSsm.hpp

@@ -103,6 +103,13 @@ namespace xo {
             void on_parsed_typedescr(TypeDescr td,
                                      ParserStateMachine * p_psm);
 
+            /** update state to consume parsed param (name,type) emitted by
+             *  nested ssm, with overall parser state in @p p_psm
+             **/
+            void on_parsed_formal(const DUniqueString * param_name,
+                                  TypeDescr param_type,
+                                  ParserStateMachine * p_psm);
+
             /** update state on parsed expression emitted by nested ssm
              *  with overall parser state in @p p_psm
              **/
@@ -116,9 +123,6 @@ namespace xo {
                                                      ParserStateMachine * p_psm);
 
 #ifdef NOT_YET
-
-            virtual void on_formal(const rp<Variable> & formal,
-                                   parserstatemachine * p_psm) override;
             virtual void on_comma_token(const token_type & tk,
                                         parserstatemachine * p_psm) override;
             virtual void on_rightparen_token(const token_type & tk,

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

@@ -78,6 +78,13 @@ namespace xo {
             void on_parsed_typedescr(TypeDescr td,
                                      ParserStateMachine * p_psm);
 
+            /** update state to consume param (name, value) emitted
+             *  by nested ssm
+             **/
+            void on_parsed_formal(const DUniqueString * param_name,
+                                  TypeDescr param_type,
+                                  ParserStateMachine * p_psm);
+
             /** update state for this syntax after parsing an expression @p expr
              *  in nested state machine.
              *  (provided to satisfy ASyntaxStateMachine api. not reachable)

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

@@ -129,6 +129,13 @@ namespace xo {
             void on_parsed_typedescr(TypeDescr td,
                                      ParserStateMachine * p_psm);
 
+            /** operate state machine to consume formal param (name,value)
+             *  emitted by nested ssm
+             **/
+            void on_parsed_formal(const DUniqueString * param_name,
+                                  TypeDescr param_type,
+                                  ParserStateMachine * p_psm);
+
             /** operate state machine for this syntax on receiving expression
              *  from nested parser.
              *  (provided to satisfy ASyntaxStateMachine api. not reachable)

xo-reader2/include/xo/reader2/DExprSeqState.hpp

@@ -138,6 +138,13 @@ namespace xo {
              **/
             void on_parsed_typedescr(TypeDescr td, ParserStateMachine * p_psm);
 
+            /** update this ssm to consume parsed formal param (name, value)
+             *  emitted by nested ssm, with overall parser state in @p p_psm
+             **/
+            void on_parsed_formal(const DUniqueString * param_name,
+                                  TypeDescr param_type,
+                                  ParserStateMachine * p_psm);
+
             /** update state for this syntax on parsed expression @p expr
              *  from nested ssm.
              *  overall parser state in @p p_psm

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

@@ -140,11 +140,11 @@ namespace xo {
             void on_semicolon_token(const Token & tk,
                                     ParserStateMachine * p_psm);
 
-            /** update state for this syntax after parsing an expression @p expr,
+            /** update state for this syntax after parsing a symbol @p sym,
-             *  overall parser state in @p p_psm.
+             *  with overall parser state in @p p_psm
              **/
-            void on_parsed_expression(obj<AExpression> expr,
+            void on_parsed_symbol(std::string_view sym,
-                                      ParserStateMachine * p_psm);
+                                  ParserStateMachine * p_psm);
 
             /** update state for this syntax after parsing a type description @p td;
              *  overall parser state in @p p_psm
@@ -152,6 +152,19 @@ namespace xo {
             void on_parsed_typedescr(TypeDescr td,
                                      ParserStateMachine * p_psm);
 
+            /** update state to consume formal param (name,value)
+             *  from nested ssm
+             **/
+            void on_parsed_formal(const DUniqueString * param_name,
+                                  TypeDescr param_type,
+                                  ParserStateMachine * p_psm);
+
+            /** update state for this syntax after parsing an expression @p expr,
+             *  overall parser state in @p p_psm.
+             **/
+            void on_parsed_expression(obj<AExpression> expr,
+                                      ParserStateMachine * p_psm);
+
             /** update state for this syntax after parsing an expression @p expr,
              *  followed by semicolon,
              *  with overall parser state in @p p_psm.
@@ -159,12 +172,6 @@ namespace xo {
             void on_parsed_expression_with_semicolon(obj<AExpression> expr,
                                                      ParserStateMachine * p_psm);
 
-            /** update state for this syntax after parsing a symbol @p sym,
-             *  with overall parser state in @p p_psm
-             **/
-            void on_parsed_symbol(std::string_view sym,
-                                  ParserStateMachine * p_psm);
-
             ///@}
             /** @defgroup scm-ifelsessm-printable-facet printable facet methods **/
             ///@{

xo-reader2/include/xo/reader2/DLambdaSsm.hpp

@@ -104,18 +104,6 @@ namespace xo {
             void on_token(const Token & tk,
                           ParserStateMachine * p_psm);
 
-            /** update this ssm when nested parser
-             *  emits expression @p expr
-             **/
-            void on_parsed_expression_with_semicolon(obj<AExpression> expr,
-                                                     ParserStateMachine * p_psm);
-
-            /** update this ssm when nested parser
-             *  emits expression @p expr
-             **/
-            void on_parsed_expression(obj<AExpression> expr,
-                                      ParserStateMachine * p_psm);
-
             /** update this ssm when nested parser
              *  emits @p td.
              **/
@@ -128,17 +116,30 @@ namespace xo {
             void on_parsed_typedescr(TypeDescr td,
                                      ParserStateMachine * p_psm);
 
+            /** update this ssm to consume parsed formal (name,value)
+             *  from nested (and now expired) ssm
+             **/
+            void on_parsed_formal(const DUniqueString * sym,
+                                  TypeDescr td,
+                                  ParserStateMachine * p_psm);
+
+            /** update this ssm when nested parser
+             *  emits expression @p expr
+             **/
+            void on_parsed_expression(obj<AExpression> expr,
+                                      ParserStateMachine * p_psm);
+
+            /** update this ssm when nested parser
+             *  emits expression @p expr
+             **/
+            void on_parsed_expression_with_semicolon(obj<AExpression> expr,
+                                                     ParserStateMachine * p_psm);
+
 #ifdef NOT_YET
             virtual const char * get_expect_str() const override;
 
-            virtual void on_typedescr(TypeDescr td,
-                                      parserstatemachine * p_psm) override;
             virtual void on_formal_arglist(const std::vector<rp<Variable>> & argl,
                                            parserstatemachine * p_psm) override;
-            virtual void on_expr(bp<Expression> expr,
-                                 parserstatemachine * p_psm) override;
-            virtual void on_expr_with_semicolon(bp<Expression> expr,
-                                                parserstatemachine * p_psm) override;
             virtual void on_leftbrace_token(const token_type & tk,
                                             parserstatemachine * p_psm) override;
             virtual void on_colon_token(const token_type & tk,

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

@@ -170,6 +170,9 @@ namespace xo {
                                   ParserStateMachine * p_psm);
             void on_parsed_typedescr(TypeDescr td,
                                      ParserStateMachine * p_psm);
+            void on_parsed_formal(const DUniqueString * param_name,
+                                  TypeDescr param_type,
+                                  ParserStateMachine * p_psm);
             void on_parsed_expression(obj<AExpression>,
                                       ParserStateMachine * p_psm);
             void on_parsed_expression_with_semicolon(obj<AExpression> expr,

xo-reader2/include/xo/reader2/ParserStateMachine.hpp

@@ -102,6 +102,12 @@ namespace xo {
              **/
             void on_parsed_typedescr(TypeDescr td);
 
+            /** update state to consume param (name, value) emitted by
+             *  nested (but not popped) parsing state
+             **/
+            void on_parsed_formal(const DUniqueString * param_name,
+                                  TypeDescr param_type);
+
             /** update state to respond to parsed expression @p expr
              *  (from nested parsing state)
              **/
@@ -163,6 +169,15 @@ namespace xo {
                                             TypeDescr td,
                                             std::string_view expect_str);
 
+            /** report illegal parsed formal (param_name, param_type) from nested ssm.
+             *  Introducing as placeholder; not expected to be reachable in
+             *  full parser
+             **/
+            void illegal_parsed_formal(std::string_view ssm_name,
+                                       const DUniqueString * param_name,
+                                       TypeDescr param_type,
+                                       std::string_view expect_str);
+
             /** report illegal parsed expression from nested ssm.
              *  Introducing as placeholder; not clear if this will be reachable
              *  in full parser

xo-reader2/include/xo/reader2/ssm/ASyntaxStateMachine.hpp

@@ -63,6 +63,8 @@ public:
     virtual void on_parsed_symbol(Opaque data, std::string_view sym, ParserStateMachine * p_psm)  = 0;
     /** operate state machine for incoming type description @p td **/
     virtual void on_parsed_typedescr(Opaque data, TypeDescr td, ParserStateMachine * p_psm)  = 0;
+    /** operate state machine for formal emitted by nested ssm **/
+    virtual void on_parsed_formal(Opaque data, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm)  = 0;
     /** update state machine for incoming parsed expression @p expr **/
     virtual void on_parsed_expression(Opaque data, obj<AExpression> expr, ParserStateMachine * p_psm)  = 0;
     /** update state machine for incoming parsed expression @p expr followed by semicolon **/

xo-reader2/include/xo/reader2/ssm/IPrintable_DLambdaSsm.hpp

@@ -2,7 +2,7 @@
  *
  *  Generated automagically from ingredients:
  *  1. code generator:
- *       [/Users/roland/proj/xo-umbrella2/xo-facet/codegen/genfacet]
+ *       [/home/roland/proj/xo-umbrella2-claude1/xo-facet/codegen/genfacet]
  *     arguments:
  *       --input [idl/IPrintable_DLambdaSsm.json5]
  *  2. jinja2 template for abstract facet .hpp file:

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_Any.hpp

@@ -63,6 +63,7 @@ namespace scm {
         [[noreturn]] void on_token(Opaque, const Token &, ParserStateMachine *)  override;
         [[noreturn]] void on_parsed_symbol(Opaque, std::string_view, ParserStateMachine *)  override;
         [[noreturn]] void on_parsed_typedescr(Opaque, TypeDescr, ParserStateMachine *)  override;
+        [[noreturn]] void on_parsed_formal(Opaque, const DUniqueString *, TypeDescr, ParserStateMachine *)  override;
         [[noreturn]] void on_parsed_expression(Opaque, obj<AExpression>, ParserStateMachine *)  override;
         [[noreturn]] void on_parsed_expression_with_semicolon(Opaque, obj<AExpression>, ParserStateMachine *)  override;
 

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DDefineSsm.hpp

@@ -60,6 +60,8 @@ namespace xo {
             static void on_parsed_symbol(DDefineSsm & self, std::string_view sym, ParserStateMachine * p_psm);
             /** operate state machine for incoming type description @p td **/
             static void on_parsed_typedescr(DDefineSsm & self, TypeDescr td, ParserStateMachine * p_psm);
+            /** operate state machine for formal emitted by nested ssm **/
+            static void on_parsed_formal(DDefineSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr **/
             static void on_parsed_expression(DDefineSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr followed by semicolon **/

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectExprSsm.hpp

@@ -60,6 +60,8 @@ namespace xo {
             static void on_parsed_symbol(DExpectExprSsm & self, std::string_view sym, ParserStateMachine * p_psm);
             /** operate state machine for incoming type description @p td **/
             static void on_parsed_typedescr(DExpectExprSsm & self, TypeDescr td, ParserStateMachine * p_psm);
+            /** operate state machine for formal emitted by nested ssm **/
+            static void on_parsed_formal(DExpectExprSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr **/
             static void on_parsed_expression(DExpectExprSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr followed by semicolon **/

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectFormalArgSsm.hpp

@@ -60,6 +60,8 @@ namespace xo {
             static void on_parsed_symbol(DExpectFormalArgSsm & self, std::string_view sym, ParserStateMachine * p_psm);
             /** operate state machine for incoming type description @p td **/
             static void on_parsed_typedescr(DExpectFormalArgSsm & self, TypeDescr td, ParserStateMachine * p_psm);
+            /** operate state machine for formal emitted by nested ssm **/
+            static void on_parsed_formal(DExpectFormalArgSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr **/
             static void on_parsed_expression(DExpectFormalArgSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr followed by semicolon **/

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectFormalArglistSsm.hpp

@@ -60,6 +60,8 @@ namespace xo {
             static void on_parsed_symbol(DExpectFormalArglistSsm & self, std::string_view sym, ParserStateMachine * p_psm);
             /** operate state machine for incoming type description @p td **/
             static void on_parsed_typedescr(DExpectFormalArglistSsm & self, TypeDescr td, ParserStateMachine * p_psm);
+            /** operate state machine for formal emitted by nested ssm **/
+            static void on_parsed_formal(DExpectFormalArglistSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr **/
             static void on_parsed_expression(DExpectFormalArglistSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr followed by semicolon **/

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectSymbolSsm.hpp

@@ -60,6 +60,8 @@ namespace xo {
             static void on_parsed_symbol(DExpectSymbolSsm & self, std::string_view sym, ParserStateMachine * p_psm);
             /** operate state machine for incoming type description @p td **/
             static void on_parsed_typedescr(DExpectSymbolSsm & self, TypeDescr td, ParserStateMachine * p_psm);
+            /** operate state machine for formal emitted by nested ssm **/
+            static void on_parsed_formal(DExpectSymbolSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr **/
             static void on_parsed_expression(DExpectSymbolSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr followed by semicolon **/

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectTypeSsm.hpp

@@ -60,6 +60,8 @@ namespace xo {
             static void on_parsed_symbol(DExpectTypeSsm & self, std::string_view sym, ParserStateMachine * p_psm);
             /** operate state machine for incoming type description @p td **/
             static void on_parsed_typedescr(DExpectTypeSsm & self, TypeDescr td, ParserStateMachine * p_psm);
+            /** operate state machine for formal emitted by nested ssm **/
+            static void on_parsed_formal(DExpectTypeSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr **/
             static void on_parsed_expression(DExpectTypeSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr followed by semicolon **/

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExprSeqState.hpp

@@ -60,6 +60,8 @@ namespace xo {
             static void on_parsed_symbol(DExprSeqState & self, std::string_view sym, ParserStateMachine * p_psm);
             /** operate state machine for incoming type description @p td **/
             static void on_parsed_typedescr(DExprSeqState & self, TypeDescr td, ParserStateMachine * p_psm);
+            /** operate state machine for formal emitted by nested ssm **/
+            static void on_parsed_formal(DExprSeqState & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr **/
             static void on_parsed_expression(DExprSeqState & self, obj<AExpression> expr, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr followed by semicolon **/

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DIfElseSsm.hpp

@@ -60,6 +60,8 @@ namespace xo {
             static void on_parsed_symbol(DIfElseSsm & self, std::string_view sym, ParserStateMachine * p_psm);
             /** operate state machine for incoming type description @p td **/
             static void on_parsed_typedescr(DIfElseSsm & self, TypeDescr td, ParserStateMachine * p_psm);
+            /** operate state machine for formal emitted by nested ssm **/
+            static void on_parsed_formal(DIfElseSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr **/
             static void on_parsed_expression(DIfElseSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr followed by semicolon **/

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DLambdaSsm.hpp

@@ -2,7 +2,7 @@
  *
  *  Generated automagically from ingredients:
  *  1. code generator:
- *       [/Users/roland/proj/xo-umbrella2/xo-facet/codegen/genfacet]
+ *       [/home/roland/proj/xo-umbrella2-claude1/xo-facet/codegen/genfacet]
  *     arguments:
  *       --input [idl/ISyntaxStateMachine_DLambdaSsm.json5]
  *  2. jinja2 template for abstract facet .hpp file:
@@ -60,6 +60,8 @@ namespace xo {
             static void on_parsed_symbol(DLambdaSsm & self, std::string_view sym, ParserStateMachine * p_psm);
             /** operate state machine for incoming type description @p td **/
             static void on_parsed_typedescr(DLambdaSsm & self, TypeDescr td, ParserStateMachine * p_psm);
+            /** operate state machine for formal emitted by nested ssm **/
+            static void on_parsed_formal(DLambdaSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr **/
             static void on_parsed_expression(DLambdaSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr followed by semicolon **/

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DProgressSsm.hpp

@@ -60,6 +60,8 @@ namespace xo {
             static void on_parsed_symbol(DProgressSsm & self, std::string_view sym, ParserStateMachine * p_psm);
             /** operate state machine for incoming type description @p td **/
             static void on_parsed_typedescr(DProgressSsm & self, TypeDescr td, ParserStateMachine * p_psm);
+            /** operate state machine for formal emitted by nested ssm **/
+            static void on_parsed_formal(DProgressSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr **/
             static void on_parsed_expression(DProgressSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
             /** update state machine for incoming parsed expression @p expr followed by semicolon **/

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_Xfer.hpp

@@ -61,6 +61,9 @@ namespace scm {
         void on_parsed_typedescr(Opaque data, TypeDescr td, ParserStateMachine * p_psm)  override {
             return I::on_parsed_typedescr(_dcast(data), td, p_psm);
         }
+        void on_parsed_formal(Opaque data, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm)  override {
+            return I::on_parsed_formal(_dcast(data), param_name, param_type, p_psm);
+        }
         void on_parsed_expression(Opaque data, obj<AExpression> expr, ParserStateMachine * p_psm)  override {
             return I::on_parsed_expression(_dcast(data), expr, p_psm);
         }

xo-reader2/include/xo/reader2/ssm/RSyntaxStateMachine.hpp

@@ -65,6 +65,9 @@ public:
     void on_parsed_typedescr(TypeDescr td, ParserStateMachine * p_psm)  {
         return O::iface()->on_parsed_typedescr(O::data(), td, p_psm);
     }
+    void on_parsed_formal(const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm)  {
+        return O::iface()->on_parsed_formal(O::data(), param_name, param_type, p_psm);
+    }
     void on_parsed_expression(obj<AExpression> expr, ParserStateMachine * p_psm)  {
         return O::iface()->on_parsed_expression(O::data(), expr, p_psm);
     }

xo-reader2/src/reader2/DDefineSsm.cpp

@@ -704,6 +704,17 @@ namespace xo {
                                           this->get_expect_str());
         }
 
+        void
+        DDefineSsm::on_parsed_formal(const DUniqueString * param_name,
+                                     TypeDescr param_type,
+                                     ParserStateMachine * p_psm)
+        {
+            p_psm->illegal_parsed_formal("DDefineSsm::on_parsed_formal",
+                                         param_name,
+                                         param_type,
+                                         this->get_expect_str());
+        }
+
         void
         DDefineSsm::on_parsed_expression(obj<AExpression> expr,
                                          ParserStateMachine * p_psm)

xo-reader2/src/reader2/DExpectExprSsm.cpp

@@ -340,7 +340,7 @@ namespace xo {
         DExpectExprSsm::on_parsed_symbol(std::string_view sym,
                                          ParserStateMachine * p_psm)
         {
-            p_psm->illegal_input_on_symbol("DExpectExprSsm",
+            p_psm->illegal_input_on_symbol("DExpectExprSsm::on_parsed_symbol",
                                            sym,
                                            this->get_expect_str());
         }
@@ -349,11 +349,22 @@ namespace xo {
         DExpectExprSsm::on_parsed_typedescr(TypeDescr td,
                                             ParserStateMachine * p_psm)
         {
-            p_psm->illegal_input_on_typedescr("DExpectExprSsm",
+            p_psm->illegal_input_on_typedescr("DExpectExprSsm::on_parsed_typedescr",
                                               td,
                                               this->get_expect_str());
         }
 
+        void
+        DExpectExprSsm::on_parsed_formal(const DUniqueString * param_name,
+                                         TypeDescr param_type,
+                                         ParserStateMachine * p_psm)
+        {
+            p_psm->illegal_parsed_formal("DExpectExprSsm::on_parsed_formal",
+                                         param_name,
+                                         param_type,
+                                         this->get_expect_str());
+        }
+
         void
         DExpectExprSsm::on_parsed_expression(obj<AExpression> expr,
                                              ParserStateMachine * p_psm)

xo-reader2/src/reader2/DExpectFormalArgSsm.cpp

@@ -166,6 +166,10 @@ namespace xo {
                                               ParserStateMachine * p_psm)
         {
             if (fstate_ == formalstatetype::formal_0) {
+                // parsed symbol @c sym is stored in tokenizer memory;
+                // must be copied to storage with expression lifetime,
+                // hence call to intern_string()
+
                 this->fstate_ = formalstatetype::formal_1;
                 this->name_ = p_psm->intern_string(sym);
                 return;
@@ -180,11 +184,34 @@ namespace xo {
         DExpectFormalArgSsm::on_parsed_typedescr(TypeDescr td,
                                                  ParserStateMachine * p_psm)
         {
+            if (fstate_ == formalstatetype::formal_2) {
+                assert(name_);
+
+                p_psm->pop_ssm();
+                p_psm->on_parsed_formal(name_, td);
+
+                return;
+            }
+
             p_psm->illegal_input_on_typedescr("DExpectFormalArgSsm::on_parsed_typedescr",
                                               td,
                                               this->get_expect_str());
         }
 
+        void
+        DExpectFormalArgSsm::on_parsed_formal(const DUniqueString * param_name,
+                                              TypeDescr param_type,
+                                              ParserStateMachine * p_psm)
+        {
+            // NOTE: (param_name,param_type) *produced* by this SSM,
+            //       but never *consumed*
+
+            p_psm->illegal_parsed_formal("DExpectFormalArgSsm::on_parsed_formal",
+                                         param_name,
+                                         param_type,
+                                         this->get_expect_str());
+        }
+
         void
         DExpectFormalArgSsm::on_parsed_expression(obj<AExpression> expr,
                                                   ParserStateMachine * p_psm)

xo-reader2/src/reader2/DExpectFormalArglistSsm.cpp

@@ -186,6 +186,17 @@ namespace xo {
                                               this->get_expect_str());
         }
 
+        void
+        DExpectFormalArglistSsm::on_parsed_formal(const DUniqueString * param_name,
+                                                  TypeDescr param_type,
+                                                  ParserStateMachine * p_psm)
+        {
+            p_psm->illegal_parsed_formal("DExpectFormalArglistSsm::on_parsed_formal",
+                                         param_name,
+                                         param_type,
+                                         this->get_expect_str());
+        }
+
         void
         DExpectFormalArglistSsm::on_parsed_expression(obj<AExpression> expr,
                                                      ParserStateMachine * p_psm)

xo-reader2/src/reader2/DExpectSymbolSsm.cpp

@@ -73,6 +73,17 @@ namespace xo {
                                               this->get_expect_str());
         }
 
+        void
+        DExpectSymbolSsm::on_parsed_formal(const DUniqueString * param_name,
+                                           TypeDescr param_type,
+                                           ParserStateMachine * p_psm)
+        {
+            p_psm->illegal_parsed_formal("DExpectSymbolSsm::on_parsed_formal",
+                                         param_name,
+                                         param_type,
+                                         this->get_expect_str());
+        }
+
         void
         DExpectSymbolSsm::on_parsed_expression(obj<AExpression> expr,
                                                ParserStateMachine * p_psm)

xo-reader2/src/reader2/DExpectTypeSsm.cpp

@@ -247,7 +247,7 @@ namespace xo {
                 td = Reflect::require<std::int64_t>();
 
             if (!td) {
-                p_psm->illegal_input_on_token("DExpectTypeSsm",
+                p_psm->illegal_input_on_token("DExpectTypeSsm::on_symbol_token",
                                               tk,
                                               this->get_expect_str());
             }
@@ -260,7 +260,7 @@ namespace xo {
         DExpectTypeSsm::on_parsed_symbol(std::string_view sym,
                                          ParserStateMachine * p_psm)
         {
-            p_psm->illegal_input_on_symbol("ExpectTypeSsm",
+            p_psm->illegal_input_on_symbol("ExpectTypeSsm::on_parsed_symbol",
                                            sym,
                                            this->get_expect_str());
         }
@@ -269,11 +269,22 @@ namespace xo {
         DExpectTypeSsm::on_parsed_typedescr(TypeDescr td,
                                             ParserStateMachine * p_psm)
         {
-            p_psm->illegal_input_on_typedescr("ExpectTypeSsm",
+            p_psm->illegal_input_on_typedescr("ExpectTypeSsm::on_parsed_typedescr",
                                               td,
                                               this->get_expect_str());
         }
 
+        void
+        DExpectTypeSsm::on_parsed_formal(const DUniqueString * param_name,
+                                         TypeDescr param_type,
+                                         ParserStateMachine * p_psm)
+        {
+            p_psm->illegal_parsed_formal("DExpectTypeSsm::on_parsed_formal",
+                                         param_name,
+                                         param_type,
+                                         this->get_expect_str());
+        }
+
         void
         DExpectTypeSsm::on_parsed_expression(obj<AExpression> expr,
                                              ParserStateMachine * p_psm)

xo-reader2/src/reader2/DExprSeqState.cpp

@@ -449,6 +449,17 @@ namespace xo {
                                               this->get_expect_str());
         }
 
+        void
+        DExprSeqState::on_parsed_formal(const DUniqueString * param_name,
+                                        TypeDescr param_type,
+                                        ParserStateMachine * p_psm)
+        {
+            p_psm->illegal_parsed_formal("DExprSeqState::on_parsed_formal",
+                                         param_name,
+                                         param_type,
+                                         this->get_expect_str());
+        }
+
         void
         DExprSeqState::on_parsed_expression(obj<AExpression> expr,
                                             ParserStateMachine * p_psm)

xo-reader2/src/reader2/DIfElseSsm.cpp

@@ -510,6 +510,17 @@ namespace xo {
                                               this->get_expect_str());
         }
 
+        void
+        DIfElseSsm::on_parsed_formal(const DUniqueString * param_name,
+                                     TypeDescr param_type,
+                                     ParserStateMachine * p_psm)
+        {
+            p_psm->illegal_parsed_formal("DIfElseSsm::on_parsed_formal",
+                                         param_name,
+                                         param_type,
+                                         this->get_expect_str());
+        }
+
         bool
         DIfElseSsm::pretty(const ppindentinfo & ppii) const
         {

xo-reader2/src/reader2/DLambdaSsm.cpp

@@ -192,18 +192,6 @@ namespace xo {
 
 
 #ifdef NOT_YET
-        void
-        lambda_xs::on_lambda_token(const token_type & tk,
-                                   parserstatemachine * p_psm)
-        {
-            if (lmxs_type_ == lambdastatetype::lm_0) {
-                this->lmxs_type_ = lambdastatetype::lm_1;
-                expect_formal_arglist_xs::start(p_psm);
-            } else {
-                exprstate::on_lambda_token(tk, p_psm);
-            }
-        }
-
         void
         lambda_xs::on_formal_arglist(const std::vector<rp<Variable>> & argl,
                                      parserstatemachine * p_psm)
@@ -351,13 +339,14 @@ namespace xo {
         }
 
         void
-        DLambdaSsm::on_parsed_expression_with_semicolon(obj<AExpression> expr,
+        DLambdaSsm::on_parsed_formal(const DUniqueString * param_name,
-                                                        ParserStateMachine * p_psm)
+                                     TypeDescr param_type,
+                                     ParserStateMachine * p_psm)
         {
-            p_psm->illegal_parsed_expression
+            p_psm->illegal_parsed_formal("DLambdaSsm::on_parsed_formal",
-                ("DLambdaSsm::on_parsed_expression_with_semicolon",
+                                         param_name,
-                 expr,
+                                         param_type,
-                 this->get_expect_str());
+                                         this->get_expect_str());
         }
 
         void
@@ -369,6 +358,16 @@ namespace xo {
                                              this->get_expect_str());
         }
 
+        void
+        DLambdaSsm::on_parsed_expression_with_semicolon(obj<AExpression> expr,
+                                                        ParserStateMachine * p_psm)
+        {
+            p_psm->illegal_parsed_expression
+                ("DLambdaSsm::on_parsed_expression_with_semicolon",
+                 expr,
+                 this->get_expect_str());
+        }
+
 #ifdef NOT_YET
         void
         lambda_xs::on_expr(bp<Expression> expr,

xo-reader2/src/reader2/DProgressSsm.cpp

@@ -555,6 +555,17 @@ namespace xo {
                                               this->get_expect_str());
         }
 
+        void
+        DProgressSsm::on_parsed_formal(const DUniqueString * param_name,
+                                       TypeDescr param_type,
+                                       ParserStateMachine * p_psm)
+        {
+            p_psm->illegal_parsed_formal("DProgressSsm::on_parsed_formal",
+                                         param_name,
+                                         param_type,
+                                         this->get_expect_str());
+        }
+
         void
         DProgressSsm::on_parsed_expression(obj<AExpression> expr,
                                            ParserStateMachine * p_psm)

xo-reader2/src/reader2/IPrintable_DLambdaSsm.cpp

@@ -2,7 +2,7 @@
  *
  *  Generated automagically from ingredients:
  *  1. code generator:
- *       [/Users/roland/proj/xo-umbrella2/xo-facet/codegen/genfacet]
+ *       [/home/roland/proj/xo-umbrella2-claude1/xo-facet/codegen/genfacet]
  *     arguments:
  *       --input [idl/IPrintable_DLambdaSsm.json5]
  *  2. jinja2 template for abstract facet .hpp file:

xo-reader2/src/reader2/ISyntaxStateMachine_Any.cpp

@@ -52,6 +52,12 @@ ISyntaxStateMachine_Any::on_parsed_typedescr(Opaque, TypeDescr, ParserStateMachi
     _fatal();
 }
 
+auto
+ISyntaxStateMachine_Any::on_parsed_formal(Opaque, const DUniqueString *, TypeDescr, ParserStateMachine *)  -> void
+{
+    _fatal();
+}
+
 auto
 ISyntaxStateMachine_Any::on_parsed_expression(Opaque, obj<AExpression>, ParserStateMachine *)  -> void
 {

xo-reader2/src/reader2/ISyntaxStateMachine_DDefineSsm.cpp

@@ -43,6 +43,11 @@ namespace xo {
             self.on_parsed_typedescr(td, p_psm);
         }
         auto
+        ISyntaxStateMachine_DDefineSsm::on_parsed_formal(DDefineSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
+        {
+            self.on_parsed_formal(param_name, param_type, p_psm);
+        }
+        auto
         ISyntaxStateMachine_DDefineSsm::on_parsed_expression(DDefineSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
         {
             self.on_parsed_expression(expr, p_psm);

xo-reader2/src/reader2/ISyntaxStateMachine_DExpectExprSsm.cpp

@@ -43,6 +43,11 @@ namespace xo {
             self.on_parsed_typedescr(td, p_psm);
         }
         auto
+        ISyntaxStateMachine_DExpectExprSsm::on_parsed_formal(DExpectExprSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
+        {
+            self.on_parsed_formal(param_name, param_type, p_psm);
+        }
+        auto
         ISyntaxStateMachine_DExpectExprSsm::on_parsed_expression(DExpectExprSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
         {
             self.on_parsed_expression(expr, p_psm);

xo-reader2/src/reader2/ISyntaxStateMachine_DExpectFormalArgSsm.cpp

@@ -43,6 +43,11 @@ namespace xo {
             self.on_parsed_typedescr(td, p_psm);
         }
         auto
+        ISyntaxStateMachine_DExpectFormalArgSsm::on_parsed_formal(DExpectFormalArgSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
+        {
+            self.on_parsed_formal(param_name, param_type, p_psm);
+        }
+        auto
         ISyntaxStateMachine_DExpectFormalArgSsm::on_parsed_expression(DExpectFormalArgSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
         {
             self.on_parsed_expression(expr, p_psm);

xo-reader2/src/reader2/ISyntaxStateMachine_DExpectFormalArglistSsm.cpp

@@ -43,6 +43,11 @@ namespace xo {
             self.on_parsed_typedescr(td, p_psm);
         }
         auto
+        ISyntaxStateMachine_DExpectFormalArglistSsm::on_parsed_formal(DExpectFormalArglistSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
+        {
+            self.on_parsed_formal(param_name, param_type, p_psm);
+        }
+        auto
         ISyntaxStateMachine_DExpectFormalArglistSsm::on_parsed_expression(DExpectFormalArglistSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
         {
             self.on_parsed_expression(expr, p_psm);

xo-reader2/src/reader2/ISyntaxStateMachine_DExpectSymbolSsm.cpp

@@ -43,6 +43,11 @@ namespace xo {
             self.on_parsed_typedescr(td, p_psm);
         }
         auto
+        ISyntaxStateMachine_DExpectSymbolSsm::on_parsed_formal(DExpectSymbolSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
+        {
+            self.on_parsed_formal(param_name, param_type, p_psm);
+        }
+        auto
         ISyntaxStateMachine_DExpectSymbolSsm::on_parsed_expression(DExpectSymbolSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
         {
             self.on_parsed_expression(expr, p_psm);

xo-reader2/src/reader2/ISyntaxStateMachine_DExpectTypeSsm.cpp

@@ -43,6 +43,11 @@ namespace xo {
             self.on_parsed_typedescr(td, p_psm);
         }
         auto
+        ISyntaxStateMachine_DExpectTypeSsm::on_parsed_formal(DExpectTypeSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
+        {
+            self.on_parsed_formal(param_name, param_type, p_psm);
+        }
+        auto
         ISyntaxStateMachine_DExpectTypeSsm::on_parsed_expression(DExpectTypeSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
         {
             self.on_parsed_expression(expr, p_psm);

xo-reader2/src/reader2/ISyntaxStateMachine_DExprSeqState.cpp

@@ -43,6 +43,11 @@ namespace xo {
             self.on_parsed_typedescr(td, p_psm);
         }
         auto
+        ISyntaxStateMachine_DExprSeqState::on_parsed_formal(DExprSeqState & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
+        {
+            self.on_parsed_formal(param_name, param_type, p_psm);
+        }
+        auto
         ISyntaxStateMachine_DExprSeqState::on_parsed_expression(DExprSeqState & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
         {
             self.on_parsed_expression(expr, p_psm);

xo-reader2/src/reader2/ISyntaxStateMachine_DIfElseSsm.cpp

@@ -43,6 +43,11 @@ namespace xo {
             self.on_parsed_typedescr(td, p_psm);
         }
         auto
+        ISyntaxStateMachine_DIfElseSsm::on_parsed_formal(DIfElseSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
+        {
+            self.on_parsed_formal(param_name, param_type, p_psm);
+        }
+        auto
         ISyntaxStateMachine_DIfElseSsm::on_parsed_expression(DIfElseSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
         {
             self.on_parsed_expression(expr, p_psm);

xo-reader2/src/reader2/ISyntaxStateMachine_DLambdaSsm.cpp

@@ -2,7 +2,7 @@
  *
  *  Generated automagically from ingredients:
  *  1. code generator:
- *       [/Users/roland/proj/xo-umbrella2/xo-facet/codegen/genfacet]
+ *       [/home/roland/proj/xo-umbrella2-claude1/xo-facet/codegen/genfacet]
  *     arguments:
  *       --input [idl/ISyntaxStateMachine_DLambdaSsm.json5]
  *  2. jinja2 template for abstract facet .hpp file:
@@ -32,7 +32,6 @@ namespace xo {
         {
             self.on_token(tk, p_psm);
         }
-
         auto
         ISyntaxStateMachine_DLambdaSsm::on_parsed_symbol(DLambdaSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
         {
@@ -44,6 +43,11 @@ namespace xo {
             self.on_parsed_typedescr(td, p_psm);
         }
         auto
+        ISyntaxStateMachine_DLambdaSsm::on_parsed_formal(DLambdaSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
+        {
+            self.on_parsed_formal(param_name, param_type, p_psm);
+        }
+        auto
         ISyntaxStateMachine_DLambdaSsm::on_parsed_expression(DLambdaSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
         {
             self.on_parsed_expression(expr, p_psm);
@@ -57,4 +61,4 @@ namespace xo {
     } /*namespace scm*/
 } /*namespace xo*/
 
-/* end ISyntaxStateMachine_DLambdaSsm.cpp */
+/* end ISyntaxStateMachine_DLambdaSsm.cpp */

xo-reader2/src/reader2/ISyntaxStateMachine_DProgressSsm.cpp

@@ -43,6 +43,11 @@ namespace xo {
             self.on_parsed_typedescr(td, p_psm);
         }
         auto
+        ISyntaxStateMachine_DProgressSsm::on_parsed_formal(DProgressSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
+        {
+            self.on_parsed_formal(param_name, param_type, p_psm);
+        }
+        auto
         ISyntaxStateMachine_DProgressSsm::on_parsed_expression(DProgressSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
         {
             self.on_parsed_expression(expr, p_psm);

xo-reader2/src/reader2/ParserStateMachine.cpp

@@ -129,6 +129,17 @@ namespace xo {
             this->stack_->top().on_parsed_typedescr(td, this);
         }
 
+        void
+        ParserStateMachine::on_parsed_formal(const DUniqueString * sym,
+                                             TypeDescr td)
+        {
+            scope log(XO_DEBUG(debug_flag_), xtag("sym", std::string_view(*sym)), xtag("td", td));
+
+            assert(stack_);
+
+            this->stack_->top().on_parsed_formal(sym, td, this);
+        }
+
         void
         ParserStateMachine::on_parsed_expression(obj<AExpression> expr)
         {
@@ -248,6 +259,31 @@ namespace xo {
             this->capture_error(ssm_name, errmsg);
         }
 
+        void
+        ParserStateMachine::illegal_parsed_formal(std::string_view ssm_name,
+                                                  const DUniqueString * param_name,
+                                                  TypeDescr param_type,
+                                                  std::string_view expect_str)
+        {
+            // TODO:
+            // - want to write error message using DArena
+            // - need something like log_streambuf and/or tostr() that's arena-aware
+
+            auto errmsg_string = tostr("Unexpected expression",
+                                       xtag("param_name", std::string_view(*param_name)),
+                                       xtag("param_type", param_type),
+                                       xtag("expecting", expect_str),
+                                       xtag("ssm", ssm_name),
+                                       xtag("via", "ParserStateMachine::illegal_parsed_expression"));
+
+            assert(expr_alloc_);
+
+            auto errmsg = DString::from_view(expr_alloc_,
+                                             std::string_view(errmsg_string));
+
+            this->capture_error(ssm_name, errmsg);
+        }
+
         void
         ParserStateMachine::illegal_parsed_expression(std::string_view ssm_name,
                                                       obj<AExpression> expr,