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

xo-reader2: support if-then-else expressions. + detailed utest

Browse source
This commit is contained in:
Roland Conybeare 2026-01-27 15:50:10 -05:00
commit c052c5c509
23 changed files with 1354 additions and 150 deletions
Download patch file Download diff file Expand all files Collapse all files

4
xo-reader2/src/reader2/CMakeLists.txt
View file

@ -25,6 +25,10 @@ set(SELF_SRCS
ISyntaxStateMachine_DDefineSsm.cpp
IPrintable_DDefineSsm.cpp
DIfElseSsm.cpp
ISyntaxStateMachine_DIfElseSsm.cpp
IPrintable_DIfElseSsm.cpp
DExpectSymbolSsm.cpp
ISyntaxStateMachine_DExpectSymbolSsm.cpp
IPrintable_DExpectSymbolSsm.cpp

132
xo-reader2/src/reader2/DExpectExprSsm.cpp
View file

@ -11,8 +11,14 @@
#include "syntaxstatetype.hpp"
#include <xo/expression2/DConstant.hpp>
#include <xo/expression2/detail/IExpression_DConstant.hpp>
#include <xo/object2/DBoolean.hpp>
#include <xo/object2/boolean/IGCObject_DBoolean.hpp>
#include <xo/object2/DInteger.hpp>
#include <xo/object2/number/IGCObject_DInteger.hpp>
#include <xo/object2/DFloat.hpp>
#include <xo/object2/number/IGCObject_DFloat.hpp>
#include <xo/object2/DString.hpp>
#include <xo/object2/string/IGCObject_DString.hpp>
#include <xo/gc/GCObject.hpp>
#include <xo/facet/facet_implementation.hpp>
@ -233,12 +239,21 @@ namespace xo {
}
void
DExpectExprSsm::on_string_token(const Token & tk,
ParserStateMachine * p_psm)
DExpectExprSsm::on_bool_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectExprSsm::on_string_token",
tk,
this->get_expect_str());
auto flag = DBoolean::box<AGCObject>(p_psm->expr_alloc(),
tk.bool_value());
auto expr = DConstant::make(p_psm->expr_alloc(), flag);
// DProgressSsm responsible for resolving cases like
// true;
// true && false;
DProgressSsm::start(p_psm->parser_alloc(),
expr,
p_psm);
}
void
@ -268,18 +283,48 @@ namespace xo {
DExpectExprSsm::on_i64_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectExprSsm::on_i64_token",
tk,
this->get_expect_str());
auto i64o = DInteger::box<AGCObject>(p_psm->expr_alloc(),
tk.i64_value());
auto expr = DConstant::make(p_psm->expr_alloc(), i64o);
// DProgressSsm responsible for resolving cases like
// 1,
// 1;
// 1 + 2;
// 1 + 2 .. // could be followed by infix
// 1 + 2 * 3;
// 1 + 2 * 3 .. // could be followed by infix
// 1 * (2 + 3)
DProgressSsm::start(p_psm->parser_alloc(),
expr,
p_psm);
}
void
DExpectExprSsm::on_bool_token(const Token & tk,
ParserStateMachine * p_psm)
DExpectExprSsm::on_string_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectExprSsm::on_bool_token",
tk,
this->get_expect_str());
auto str = DString::from_str(p_psm->expr_alloc(),
tk.text());
auto str_o = obj<AGCObject,DString>(str);
auto expr = DConstant::make(p_psm->expr_alloc(), str_o);
/* e.g.
* def msg = "hello, world";
* \----tk----/
*
* DProgressSsm responsible for operators that apply to string
* "foo";
* "foo" <= "bar"
* "foo" + ", she said";
*/
DProgressSsm::start(p_psm->parser_alloc(),
expr,
p_psm);
}
void
@ -313,9 +358,8 @@ namespace xo {
DExpectExprSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
p_psm->illegal_parsed_expression("DExpectExprSsm::on_parsed_expression",
expr,
this->get_expect_str());
p_psm->pop_ssm();
p_psm->on_parsed_expression(expr);
}
void
@ -464,62 +508,6 @@ namespace xo {
return;
}
void
expect_expr_xs::on_bool_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
progress_xs::start
(Constant<bool>::make(tk.bool_value()),
p_psm);
}
void
expect_expr_xs::on_i64_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()),
xtag("tk", tk),
xtag("do", "push progress xs w/ tk value"));
progress_xs::start
(Constant<int64_t>::make(tk.i64_value()),
p_psm);
}
void
expect_expr_xs::on_f64_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
//constexpr const char * self_name = "exprstate::on_f64_token";
/* e.g.
* def pi = 3.14159265;
* \---tk---/
*/
progress_xs::start
(Constant<double>::make(tk.f64_value()),
p_psm);
}
void
expect_expr_xs::on_string_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
/* e.g.
* def msg = "hello, world";
* \----tk----/
*/
progress_xs::start
(Constant<std::string>::make(tk.text()),
p_psm);
}
void
expect_expr_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)

17
xo-reader2/src/reader2/DExprSeqState.cpp
View file

@ -7,6 +7,7 @@
#include "DDefineSsm.hpp"
#include "ssm/ISyntaxStateMachine_DExprSeqState.hpp"
#include <xo/reader2/DProgressSsm.hpp>
#include <xo/reader2/DIfElseSsm.hpp>
#include <xo/expression2/DConstant.hpp>
#include <xo/expression2/detail/IExpression_DConstant.hpp>
#include <xo/object2/DString.hpp>
@ -246,20 +247,20 @@ namespace xo {
{
switch (seqtype_) {
case exprseqtype::toplevel_interactive:
p_psm->illegal_input_on_token("DExprSeqState::on_if_token",
tk,
this->get_expect_str());
//assert(false); // DfElseState::start(p_psm);
break;
DIfElseSsm::start(p_psm->parser_alloc(),
p_psm->expr_alloc(),
p_psm);
return;
case exprseqtype::toplevel_batch:
p_psm->illegal_input_on_token("DExprSeqState::on_if_token",
tk,
this->get_expect_str());
break;
case exprseqtype::N:
assert(false); // unreachable
break;
}
p_psm->illegal_input_on_token("DExprSeqState::on_if_token",
tk,
this->get_expect_str());
}
void

530
xo-reader2/src/reader2/DIfElseSsm.cpp Normal file
View file

@ -0,0 +1,530 @@
/** @file DIfElseSsm.cpp
*
* @author Roland Conybeare, Jul 2025
**/
#include "DIfElseSsm.hpp"
#include "ssm/ISyntaxStateMachine_DIfElseSsm.hpp"
#include "ssm/IPrintable_DDefineSsm.hpp"
#include "DExpectExprSsm.hpp"
#include <xo/expression2/detail/IPrintable_DIfElseExpr.hpp>
#include <xo/printable2/Printable.hpp>
#include <xo/facet/FacetRegistry.hpp>
//#include "exprstatestack.hpp"
//#include "parserstatemachine.hpp"
//#include "expect_expr_xs.hpp"
//#include "xo/indentlog/print/ppdetail_atomic.hpp"
namespace xo {
using xo::print::APrintable;
using xo::facet::FacetRegistry;
using xo::facet::with_facet;
using xo::reflect::typeseq;
namespace scm {
// ----- ifexprstatetype -----
const char *
ifexprstatetype_descr(ifexprstatetype x) {
switch (x) {
case ifexprstatetype::invalid: return "invalid";
case ifexprstatetype::if_0: return "if_0";
case ifexprstatetype::if_1: return "if_1";
case ifexprstatetype::if_2: return "if_2";
case ifexprstatetype::if_3: return "if_3";
case ifexprstatetype::if_4: return "if_4";
case ifexprstatetype::if_5: return "if_5";
case ifexprstatetype::if_6: return "if_6";
case ifexprstatetype::N: break;
}
return "ifexprstatetype?";
}
std::ostream &
operator<<(std::ostream & os, ifexprstatetype x) {
os << ifexprstatetype_descr(x);
return os;
}
// ----- DIfElseSsm -----
DIfElseSsm::DIfElseSsm(DIfElseExpr * ifelse_expr) : ifstate_{ifexprstatetype::if_0},
if_expr_{ifelse_expr}
{}
DIfElseSsm *
DIfElseSsm::_make(DArena & mm,
DIfElseExpr * ifelse_expr)
{
void * mem = mm.alloc(typeseq::id<DIfElseSsm>(),
sizeof(DIfElseSsm));
return new (mem) DIfElseSsm(ifelse_expr);
}
void
DIfElseSsm::start(DArena & parser_mm,
obj<AAllocator> expr_mm,
ParserStateMachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
DIfElseExpr * if_expr = DIfElseExpr::_make_empty(expr_mm);
DIfElseSsm * if_ssm = DIfElseSsm::_make(parser_mm, if_expr);
obj<ASyntaxStateMachine> ssm
= with_facet<ASyntaxStateMachine>::mkobj(if_ssm);
p_psm->push_ssm(ssm);
// note: triggers poly dispatch
p_psm->on_token(Token::if_token());
}
syntaxstatetype
DIfElseSsm::ssm_type() const noexcept
{
return syntaxstatetype::ifelseexpr;
}
std::string_view
DIfElseSsm::get_expect_str() const noexcept
{
/**
* if test-expr then then-expr else else-expr ;
* ^ ^ ^ ^ ^ ^ ^
* | | | | | | |
* | if_1 if_2 if_3 if_4 if_5 if_6
* if_0
*
* if_0 --on_if_token()--> if_1
* if_1 --on_expr()--> if_2
* if_2 --on_then_token()--> if_3
* if_3 --on_expr()--> if_4
* if_4 --on_else_token()--> if_5
* --on_semicolon_token()--> (done)
* if_5 --on_expr()-->if_6
* if_6 --on_semicolon_token()--> (done)
**/
switch (this->ifstate_) {
case ifexprstatetype::invalid:
case ifexprstatetype::N:
assert(false); // unreachable
break;
case ifexprstatetype::if_0:
return "if";
case ifexprstatetype::if_1:
return "expression";
case ifexprstatetype::if_2:
return "then";
case ifexprstatetype::if_3:
return "expression";
case ifexprstatetype::if_4:
return "else|semicolon";
case ifexprstatetype::if_5:
return "expression";
case ifexprstatetype::if_6:
return "semicolon";
}
return "?expect";
}
void
DIfElseSsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()), xtag("tk", tk));
switch (tk.tk_type()) {
case tokentype::tk_symbol:
case tokentype::tk_def:
break;
case tokentype::tk_if:
this->on_if_token(tk, p_psm);
return;
case tokentype::tk_then:
this->on_then_token(tk, p_psm);
return;
case tokentype::tk_else:
this->on_else_token(tk, p_psm);
return;
case tokentype::tk_colon:
case tokentype::tk_singleassign:
case tokentype::tk_string:
case tokentype::tk_f64:
case tokentype::tk_i64:
case tokentype::tk_bool:
case tokentype::tk_semicolon:
case tokentype::tk_invalid:
case tokentype::tk_leftparen:
case tokentype::tk_rightparen:
case tokentype::tk_leftbracket:
case tokentype::tk_rightbracket:
case tokentype::tk_leftbrace:
case tokentype::tk_rightbrace:
case tokentype::tk_leftangle:
case tokentype::tk_rightangle:
case tokentype::tk_lessequal:
case tokentype::tk_greatequal:
case tokentype::tk_dot:
case tokentype::tk_comma:
case tokentype::tk_doublecolon:
case tokentype::tk_assign:
case tokentype::tk_yields:
case tokentype::tk_plus:
case tokentype::tk_minus:
case tokentype::tk_star:
case tokentype::tk_slash:
case tokentype::tk_cmpeq:
case tokentype::tk_cmpne:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
p_psm->illegal_input_on_token("DIfElseSsm::on_token",
tk,
this->get_expect_str());
}
#ifdef NOT_YET
// ----- if_else_xs -----
if_else_xs::if_else_xs(rp<IfExprAccess> if_expr)
: exprstate(exprstatetype::ifexpr),
ifxs_type_{ifexprstatetype::if_0},
if_expr_{std::move(if_expr)}
{}
#endif
void
DIfElseSsm::on_if_token(const Token & tk,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log("ifstate", ifstate_);
if (ifstate_ == ifexprstatetype::if_0) {
this->ifstate_ = ifexprstatetype::if_1;
DExpectExprSsm::start(p_psm->parser_alloc(),
p_psm);
return;
}
p_psm->illegal_input_on_token("DIfElseSsm::on_if_token",
tk,
this->get_expect_str());
}
void
DIfElseSsm::on_then_token(const Token & tk,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log("ifstate", ifstate_);
if (ifstate_ == ifexprstatetype::if_2) {
this->ifstate_ = ifexprstatetype::if_3;
DExpectExprSsm::start(p_psm->parser_alloc(), p_psm);
return;
}
p_psm->illegal_input_on_token("DIfElseSsm::on_then_token",
tk,
this->get_expect_str());
}
#ifdef NOT_YET
void
if_else_xs::on_else_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log("ifxs_type", ifxs_type_);
if (this->ifxs_type_ == ifexprstatetype::if_4) {
this->ifxs_type_ = ifexprstatetype::if_5;
expect_expr_xs::start(p_psm);
return;
}
constexpr const char * c_self_name = "if_else_xs::on_else_token";
const char * exp = this->get_expect_str();
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
}
#endif
void
DIfElseSsm::on_else_token(const Token & tk,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log("ifstate", ifstate_);
if (ifstate_ == ifexprstatetype::if_4) {
this->ifstate_ = ifexprstatetype::if_5;
DExpectExprSsm::start(p_psm->parser_alloc(), p_psm);
return;
}
p_psm->illegal_input_on_token("DIfElseSsm::on_else_token",
tk,
this->get_expect_str());
}
#ifdef NOT_YET
void
if_else_xs::finish_and_continue(parserstatemachine * p_psm)
{
rp<IfExprAccess> if_expr = this->if_expr_;
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
if (this->ifxs_type_ == ifexprstatetype::if_4) {
/* if no else-branch, then if-expr can't have valuetype */
if_expr->assign_valuetype(nullptr);
}
p_psm->top_exprstate().on_expr(if_expr, p_psm);
}
#endif
void
DIfElseSsm::finish_and_continue(ParserStateMachine * p_psm)
{
p_psm->pop_ssm();
// rp<IfExprAccess> if_expr = this->if_expr_;
// std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
p_psm->on_parsed_expression(if_expr_);
}
#ifdef NOT_YET
void
if_else_xs::on_rightbrace_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
this->finish_and_continue(p_psm);
p_psm->on_rightbrace_token(tk);
}
void
if_else_xs::on_semicolon_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log("ifxs_type", ifxs_type_);
const char * c_self_name = "if_else_xs::on_semicolon_token";
switch (this->ifxs_type_) {
case ifexprstatetype::invalid:
case ifexprstatetype::if_0:
case ifexprstatetype::n_ifexprstatetype:
// unreachable
assert(false);
break;
case ifexprstatetype::if_1:
case ifexprstatetype::if_2:
case ifexprstatetype::if_3:
case ifexprstatetype::if_5:
this->illegal_input_on_token(c_self_name, tk, get_expect_str(), p_psm);
break;
case ifexprstatetype::if_4:
case ifexprstatetype::if_6: {
this->finish_and_continue(p_psm);
break;
}
}
}
#endif
void
DIfElseSsm::on_semicolon_token(const Token & tk,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log("ifstate", ifstate_);
switch (ifstate_) {
case ifexprstatetype::invalid:
case ifexprstatetype::N:
// unreachable
assert(false);
break;
case ifexprstatetype::if_0:
case ifexprstatetype::if_1:
case ifexprstatetype::if_2:
case ifexprstatetype::if_3:
case ifexprstatetype::if_5:
break;
case ifexprstatetype::if_4:
case ifexprstatetype::if_6:
this->finish_and_continue(p_psm);
return;
}
p_psm->illegal_input_on_token("DIfElseSsm::on_semicolon_token",
tk, this->get_expect_str());
}
#ifdef NOT_YET
void
if_else_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log(xtag("ifxs_type", ifxs_type_));
switch (this->ifxs_type_) {
case ifexprstatetype::invalid:
case ifexprstatetype::if_0:
case ifexprstatetype::n_ifexprstatetype:
assert(false); // unreachable
return;
case ifexprstatetype::if_1:
if_expr_->assign_test(expr.promote());
ifxs_type_ = ifexprstatetype::if_2;
return;
case ifexprstatetype::if_2:
/** error: expecting 'then' **/
break;
case ifexprstatetype::if_3:
if_expr_->assign_when_true(expr.promote());
ifxs_type_ = ifexprstatetype::if_4;
return;
case ifexprstatetype::if_4:
/** error: expecting 'else' or ';' **/
break;
case ifexprstatetype::if_5:
if_expr_->assign_when_false(expr.promote());
ifxs_type_ = ifexprstatetype::if_6;
return;
case ifexprstatetype::if_6:
/** error: expecting ';' **/
break;
}
constexpr const char* c_self_name = "if_else_xs::on_expr";
const char * exp = get_expect_str();
this->illegal_input_on_expr(c_self_name, expr, exp, p_psm);
}
#endif
void
DIfElseSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log(xtag("ifstate", ifstate_));
// if (ifstate_ == ...) { .... return; }
switch (ifstate_) {
case ifexprstatetype::invalid:
case ifexprstatetype::N:
assert(false);
break;
case ifexprstatetype::if_0:
// should be unreachable
break;
case ifexprstatetype::if_1:
if_expr_.data()->assign_test(expr);
this->ifstate_ = ifexprstatetype::if_2;
return;
case ifexprstatetype::if_2:
// error: expecting "then" token here
break;
case ifexprstatetype::if_3:
if_expr_.data()->assign_when_true(expr);
this->ifstate_ = ifexprstatetype::if_4;
return;
case ifexprstatetype::if_4:
// error: expecting "else" or ";"
break;
case ifexprstatetype::if_5:
if_expr_.data()->assign_when_false(expr);
this->ifstate_ = ifexprstatetype::if_6;
return;
case ifexprstatetype::if_6:
// error: expecting ";"
break;
}
p_psm->illegal_parsed_expression("DIfElseSsm::on_parsed_expression",
expr,
this->get_expect_str());
}
void
DIfElseSsm::on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
this->on_parsed_expression(expr, p_psm);
this->on_semicolon_token(Token::semicolon_token(), p_psm);
}
void
DIfElseSsm::on_parsed_symbol(std::string_view sym,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_symbol("DIfElseSsm::on_parsed_symbol",
sym,
this->get_expect_str());
}
void
DIfElseSsm::on_parsed_typedescr(TypeDescr td,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_typedescr("DIfElseSsm::on_parsed_typedescr",
td,
this->get_expect_str());
}
bool
DIfElseSsm::pretty(const ppindentinfo & ppii) const
{
auto expr
= FacetRegistry::instance().variant<APrintable,
AExpression>(if_expr_);
assert(expr.data());
(void)expr;
return ppii.pps()->pretty_struct
(ppii,
"DIfElseSsm",
refrtag("ifstate", ifstate_),
refrtag("if_expr", expr));
}
} /*namespace scm*/
} /*namespace xo*/

73
xo-reader2/src/reader2/DProgressSsm.cpp
View file

@ -230,6 +230,14 @@ namespace xo {
this->on_if_token(tk, p_psm);
return;
case tokentype::tk_then:
this->on_then_token(tk, p_psm);
return;
case tokentype::tk_else:
this->on_else_token(tk, p_psm);
return;
case tokentype::tk_colon:
this->on_colon_token(tk, p_psm);
return;
@ -288,8 +296,7 @@ namespace xo {
case tokentype::tk_cmpne:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_then:
case tokentype::tk_else:
break;
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
@ -329,6 +336,42 @@ namespace xo {
this->get_expect_str());
}
void
DProgressSsm::on_then_token(const Token & tk,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
(void)tk;
obj<AExpression> expr = this->assemble_expr(p_psm);
p_psm->pop_ssm(); // completes self
// TODO: perhaps need to generalize on_parsed_expression_with_semicolon() ..?
p_psm->on_parsed_expression(expr);
p_psm->on_token(tk);
}
void
DProgressSsm::on_else_token(const Token & tk,
ParserStateMachine * p_psm)
{
// note: common with .on_then_token()
scope log(XO_DEBUG(p_psm->debug_flag()));
(void)tk;
obj<AExpression> expr = this->assemble_expr(p_psm);
p_psm->pop_ssm(); // completes self
// TODO: perhaps need to generalize on_parsed_expression_with_semicolon() ..?
p_psm->on_parsed_expression(expr);
p_psm->on_token(tk);
}
void
DProgressSsm::on_colon_token(const Token & tk,
ParserStateMachine * p_psm)
@ -466,9 +509,7 @@ namespace xo {
{
obj<APrintable> expr_pr = FacetRegistry::instance().variant<APrintable,AExpression>(expr);
assert(expr_pr);
log && log(xtag("expr", expr_pr));
}
@ -979,28 +1020,6 @@ namespace xo {
p_psm->top_exprstate().on_rightparen_token(tk, p_psm);
}
void
progress_xs::on_then_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
rp<Expression> expr = this->assemble_expr(p_psm);
log && log(xtag("assembled-expr", expr));
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
p_psm->on_expr(expr);
p_psm->on_then_token(tk);
/* control here on input like:
*
* if a > b then..
*
*/
}
void
progress_xs::on_else_token(const token_type & tk,
parserstatemachine * p_psm)
@ -1120,7 +1139,7 @@ namespace xo {
bool
DProgressSsm::pretty(const xo::print::ppindentinfo & ppii) const
{
scope log(XO_DEBUG(true));
scope log(XO_DEBUG(false));
log && log(xtag("lhs_.tseq", lhs_._typeseq()));
log && log(xtag("rhs_.tseq", rhs_._typeseq()));

28
xo-reader2/src/reader2/IPrintable_DIfElseSsm.cpp Normal file
View file

@ -0,0 +1,28 @@
/** @file IPrintable_DIfElseSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [/home/roland/proj/xo-umbrella2-claude1/xo-facet/codegen/genfacet]
* arguments:
* --input [idl/IPrintable_DIfElseSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/IPrintable_DIfElseSsm.json5]
**/
#include "ssm/IPrintable_DIfElseSsm.hpp"
namespace xo {
namespace scm {
auto
IPrintable_DIfElseSsm::pretty(const DIfElseSsm & self, const ppindentinfo & ppii) -> bool
{
return self.pretty(ppii);
}
} /*namespace scm*/
} /*namespace xo*/
/* end IPrintable_DIfElseSsm.cpp */

59
xo-reader2/src/reader2/ISyntaxStateMachine_DIfElseSsm.cpp Normal file
View file

@ -0,0 +1,59 @@
/** @file ISyntaxStateMachine_DIfElseSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [/home/roland/proj/xo-umbrella2-claude1/xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DIfElseSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DIfElseSsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DIfElseSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DIfElseSsm::ssm_type(const DIfElseSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DIfElseSsm::get_expect_str(const DIfElseSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DIfElseSsm::on_token(DIfElseSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DIfElseSsm::on_parsed_symbol(DIfElseSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DIfElseSsm::on_parsed_typedescr(DIfElseSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DIfElseSsm::on_parsed_expression(DIfElseSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DIfElseSsm::on_parsed_expression_with_semicolon(DIfElseSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_semicolon(expr, p_psm);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DIfElseSsm.cpp */

7
xo-reader2/src/reader2/reader2_register_facets.cpp
View file

@ -11,6 +11,9 @@
#include <xo/reader2/ssm/ISyntaxStateMachine_DDefineSsm.hpp>
#include <xo/reader2/ssm/IPrintable_DDefineSsm.hpp>
#include <xo/reader2/ssm/ISyntaxStateMachine_DIfElseSsm.hpp>
#include <xo/reader2/ssm/IPrintable_DIfElseSsm.hpp>
#include <xo/reader2/ssm/ISyntaxStateMachine_DExpectSymbolSsm.hpp>
#include <xo/reader2/ssm/IPrintable_DExpectSymbolSsm.hpp>
@ -45,6 +48,9 @@ namespace xo {
FacetRegistry::register_impl<ASyntaxStateMachine, DDefineSsm>();
FacetRegistry::register_impl<APrintable, DDefineSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DIfElseSsm>();
FacetRegistry::register_impl<APrintable, DIfElseSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DExpectSymbolSsm>();
FacetRegistry::register_impl<APrintable, DExpectSymbolSsm>();
@ -59,6 +65,7 @@ namespace xo {
log && log(xtag("DExprSeqState.tseq", typeseq::id<DExprSeqState>()));
log && log(xtag("DDefineSsm.tseq", typeseq::id<DDefineSsm>()));
log && log(xtag("DIfElseSsm.tseq", typeseq::id<DIfElseSsm>()));
log && log(xtag("DExpectSymbolSsm.tseq", typeseq::id<DExpectSymbolSsm>()));
log && log(xtag("DExpectTypeSsm.tseq", typeseq::id<DExpectTypeSsm>()));
log && log(xtag("DExpectExprSsm.tseq", typeseq::id<DExpectExprSsm>()));

2
xo-reader2/src/reader2/syntaxstatetype.cpp
View file

@ -23,6 +23,8 @@ namespace xo {
return "expect-rhs-expression";
case syntaxstatetype::defexpr:
return "defexpr";
case syntaxstatetype::ifelseexpr:
return "ifelseexpr";
case syntaxstatetype::progress:
return "progress";
case syntaxstatetype::N: