roland/xo-umbrella2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

xo-reader2: use DUniqueString* to report parsed formal

Browse source
This commit is contained in:
Roland Conybeare 2026-01-29 12:24:46 -05:00
commit 35a49810e4
50 changed files with 377 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

10
idl/SyntaxStateMachine.json5
View file

@ -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"],

7
include/xo/reader2/DDefineSsm.hpp
View file

@ -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
**/

7
include/xo/reader2/DExpectExprSsm.hpp
View file

@ -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
**/

13
include/xo/reader2/DExpectFormalArgSsm.hpp
View file

@ -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*/

10
include/xo/reader2/DExpectFormalArglistSsm.hpp
View file

@ -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,

7
include/xo/reader2/DExpectSymbolSsm.hpp
View file

@ -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)

7
include/xo/reader2/DExpectTypeSsm.hpp
View file

@ -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)

7
include/xo/reader2/DExprSeqState.hpp
View file

@ -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

27
include/xo/reader2/DIfElseSsm.hpp
View file

@ -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,
* overall parser state in @p p_psm.
/** update state for this syntax after parsing a symbol @p sym,
* with overall parser state in @p p_psm
**/
void on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm);
void on_parsed_symbol(std::string_view sym,
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 **/
///@{

37
include/xo/reader2/DLambdaSsm.hpp
View file

@ -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,

3
include/xo/reader2/DProgressSsm.hpp
View file

@ -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,

15
include/xo/reader2/ParserStateMachine.hpp
View file

@ -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

2
include/xo/reader2/ssm/ASyntaxStateMachine.hpp
View file

@ -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 **/

2
include/xo/reader2/ssm/IPrintable_DLambdaSsm.hpp
View file

@ -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:

1
include/xo/reader2/ssm/ISyntaxStateMachine_Any.hpp
View file

@ -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;

2
include/xo/reader2/ssm/ISyntaxStateMachine_DDefineSsm.hpp
View file

@ -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 **/

2
include/xo/reader2/ssm/ISyntaxStateMachine_DExpectExprSsm.hpp
View file

@ -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 **/

2
include/xo/reader2/ssm/ISyntaxStateMachine_DExpectFormalArgSsm.hpp
View file

@ -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 **/

2
include/xo/reader2/ssm/ISyntaxStateMachine_DExpectFormalArglistSsm.hpp
View file

@ -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 **/

2
include/xo/reader2/ssm/ISyntaxStateMachine_DExpectSymbolSsm.hpp
View file

@ -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 **/

2
include/xo/reader2/ssm/ISyntaxStateMachine_DExpectTypeSsm.hpp
View file

@ -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 **/

2
include/xo/reader2/ssm/ISyntaxStateMachine_DExprSeqState.hpp
View file

@ -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 **/

2
include/xo/reader2/ssm/ISyntaxStateMachine_DIfElseSsm.hpp
View file

@ -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 **/

4
include/xo/reader2/ssm/ISyntaxStateMachine_DLambdaSsm.hpp
View file

@ -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 **/

2
include/xo/reader2/ssm/ISyntaxStateMachine_DProgressSsm.hpp
View file

@ -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 **/

3
include/xo/reader2/ssm/ISyntaxStateMachine_Xfer.hpp
View file

@ -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);
}

3
include/xo/reader2/ssm/RSyntaxStateMachine.hpp
View file

@ -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);
}

11
src/reader2/DDefineSsm.cpp
View file

@ -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)

15
src/reader2/DExpectExprSsm.cpp
View file

@ -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)

27
src/reader2/DExpectFormalArgSsm.cpp
View file

@ -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)

11
src/reader2/DExpectFormalArglistSsm.cpp
View file

@ -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)

11
src/reader2/DExpectSymbolSsm.cpp
View file

@ -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)

17
src/reader2/DExpectTypeSsm.cpp
View file

@ -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)

11
src/reader2/DExprSeqState.cpp
View file

@ -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)

11
src/reader2/DIfElseSsm.cpp
View file

@ -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
{

35
src/reader2/DLambdaSsm.cpp
View file

@ -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,
ParserStateMachine * p_psm)
DLambdaSsm::on_parsed_formal(const DUniqueString * param_name,
TypeDescr param_type,
ParserStateMachine * p_psm)
{
p_psm->illegal_parsed_expression
("DLambdaSsm::on_parsed_expression_with_semicolon",
expr,
this->get_expect_str());
p_psm->illegal_parsed_formal("DLambdaSsm::on_parsed_formal",
param_name,
param_type,
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,

11
src/reader2/DProgressSsm.cpp
View file

@ -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)

2
src/reader2/IPrintable_DLambdaSsm.cpp
View file

@ -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:

6
src/reader2/ISyntaxStateMachine_Any.cpp
View file

@ -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
{

5
src/reader2/ISyntaxStateMachine_DDefineSsm.cpp
View file

@ -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);

5
src/reader2/ISyntaxStateMachine_DExpectExprSsm.cpp
View file

@ -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);

5
src/reader2/ISyntaxStateMachine_DExpectFormalArgSsm.cpp
View file

@ -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);

5
src/reader2/ISyntaxStateMachine_DExpectFormalArglistSsm.cpp
View file

@ -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);

5
src/reader2/ISyntaxStateMachine_DExpectSymbolSsm.cpp
View file

@ -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);

5
src/reader2/ISyntaxStateMachine_DExpectTypeSsm.cpp
View file

@ -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);

5
src/reader2/ISyntaxStateMachine_DExprSeqState.cpp
View file

@ -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);

5
src/reader2/ISyntaxStateMachine_DIfElseSsm.cpp
View file

@ -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);

10
src/reader2/ISyntaxStateMachine_DLambdaSsm.cpp
View file

@ -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 */

5
src/reader2/ISyntaxStateMachine_DProgressSsm.cpp
View file

@ -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);

36
src/reader2/ParserStateMachine.cpp
View file

@ -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,