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

xo-XXX -> .xo-XXX (prep subrepo)

Browse source
This commit is contained in:
Roland Conybeare 2026-06-06 22:00:54 -04:00
commit cf0bd4d975
2105 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,115 +0,0 @@
# reader2/CMakeLists.txt
set(SELF_LIB xo_reader2)
set(SELF_SRCS
init_reader2.cpp
SetupReader2.cpp
SchematikaReader.cpp
ReaderConfig.cpp
DSchematikaParser.cpp
facet/IGCObject_DSchematikaParser.cpp
ParserStateMachine.cpp
ParserStack.cpp
ParserResult.cpp
DGlobalEnv.cpp
facet/IGCObject_DGlobalEnv.cpp
facet/IPrintable_DGlobalEnv.cpp
syntaxstatetype.cpp
ISyntaxStateMachine_Any.cpp
DToplevelSeqSsm.cpp
ISyntaxStateMachine_DToplevelSeqSsm.cpp
IPrintable_DToplevelSeqSsm.cpp
DDefineSsm.cpp
facet/ISyntaxStateMachine_DDefineSsm.cpp
facet/IPrintable_DDefineSsm.cpp
DDeftypeSsm.cpp
facet/ISyntaxStateMachine_DDeftypeSsm.cpp
facet/IPrintable_DDeftypeSsm.cpp
DIfElseSsm.cpp
facet/ISyntaxStateMachine_DIfElseSsm.cpp
facet/IPrintable_DIfElseSsm.cpp
DSequenceSsm.cpp
ISyntaxStateMachine_DSequenceSsm.cpp
IPrintable_DSequenceSsm.cpp
DLambdaSsm.cpp
facet/ISyntaxStateMachine_DLambdaSsm.cpp
facet/IPrintable_DLambdaSsm.cpp
DApplySsm.cpp
facet/ISyntaxStateMachine_DApplySsm.cpp
facet/IPrintable_DApplySsm.cpp
DParenSsm.cpp
ISyntaxStateMachine_DParenSsm.cpp
IPrintable_DParenSsm.cpp
DExpectFormalArglistSsm.cpp
ISyntaxStateMachine_DExpectFormalArglistSsm.cpp
IPrintable_DExpectFormalArglistSsm.cpp
DExpectFormalArgSsm.cpp
facet/ISyntaxStateMachine_DExpectFormalArgSsm.cpp
facet/IPrintable_DExpectFormalArgSsm.cpp
DExpectSymbolSsm.cpp
ISyntaxStateMachine_DExpectSymbolSsm.cpp
IPrintable_DExpectSymbolSsm.cpp
DExpectTypeSsm.cpp
ISyntaxStateMachine_DExpectTypeSsm.cpp
IPrintable_DExpectTypeSsm.cpp
DExpectListTypeSsm.cpp
facet/ISyntaxStateMachine_DExpectListTypeSsm.cpp
facet/IPrintable_DExpectListTypeSsm.cpp
DExpectExprSsm.cpp
ISyntaxStateMachine_DExpectExprSsm.cpp
IPrintable_DExpectExprSsm.cpp
DExpectQLiteralSsm.cpp
ISyntaxStateMachine_DExpectQLiteralSsm.cpp
IPrintable_DExpectQLiteralSsm.cpp
DExpectQListSsm.cpp
ISyntaxStateMachine_DExpectQListSsm.cpp
IPrintable_DExpectQListSsm.cpp
DExpectQArraySsm.cpp
ISyntaxStateMachine_DExpectQArraySsm.cpp
IPrintable_DExpectQArraySsm.cpp
DExpectQDictSsm.cpp
facet/ISyntaxStateMachine_DExpectQDictSsm.cpp
facet/IPrintable_DExpectQDictSsm.cpp
DProgressSsm.cpp
ISyntaxStateMachine_DProgressSsm.cpp
IPrintable_DProgressSsm.cpp
DQuoteSsm.cpp
facet/ISyntaxStateMachine_DQuoteSsm.cpp
facet/IPrintable_DQuoteSsm.cpp
)
xo_add_shared_library4(${SELF_LIB} ${PROJECT_NAME}Targets ${PROJECT_VERSION} 1 ${SELF_SRCS})
# note: deps here must also appear in cmake/xo_expression2Config.cmake.in
xo_dependency(${SELF_LIB} xo_numeric)
xo_dependency(${SELF_LIB} xo_procedure2)
xo_dependency(${SELF_LIB} xo_gc)
xo_dependency(${SELF_LIB} xo_type)
xo_dependency(${SELF_LIB} xo_tokenizer2)
xo_dependency(${SELF_LIB} xo_expression2)
xo_dependency(${SELF_LIB} subsys)

412
xo-reader2/src/reader2/DApplySsm.cpp
View file

@ -1,412 +0,0 @@
/** @file DApplySsm.cpp
*
* @author Roland Conybeare, Feb 2026
**/
#include "ApplySsm.hpp"
#include "ExpectExprSsm.hpp"
#include <xo/object2/Array.hpp>
#include <xo/alloc2/GCObject.hpp>
#include <xo/alloc2/Arena.hpp>
#include <xo/facet/FacetRegistry.hpp>
#include <xo/reflectutil/typeseq.hpp>
//#include "parserstatemachine.hpp"
//#include "expect_expr_xs.hpp"
namespace xo {
using xo::mm::ACollector;
using xo::mm::AGCObject;
using xo::print::APrintable;
using xo::reflect::typeseq;
namespace scm {
// ----- applyexprstatetype -----
const char *
applyexprstatetype_descr(applyexprstatetype x) {
switch (x) {
case applyexprstatetype::invalid: return "invalid";
case applyexprstatetype::apply_0: return "apply_0";
case applyexprstatetype::apply_1: return "apply_1";
case applyexprstatetype::apply_2: return "apply_2";
case applyexprstatetype::apply_3: return "apply_3";
case applyexprstatetype::N: break;
}
return "???applyexprstatetype";
}
std::ostream &
operator<<(std::ostream & os, applyexprstatetype x) {
os << applyexprstatetype_descr(x);
return os;
}
// ----- DApplySsm -----
DApplySsm::DApplySsm(applyexprstatetype applystate,
obj<AExpression> fn_expr,
DArray * args)
: applystate_{applystate},
fn_expr_{fn_expr},
args_expr_v_{args}
{
if (fn_expr) {
this->applystate_ = applyexprstatetype::apply_1;
}
assert(args->is_empty());
}
DApplySsm *
DApplySsm::_make(DArena & arena,
obj<AExpression> fn_expr)
{
obj<AAllocator,DArena> mm(&arena);
void * mem = arena.alloc(typeseq::id<DApplySsm>(),
sizeof(DApplySsm));
/* allocate room for 8 arguments (during parsing)
* will reallocate to expand if needed.
*
* See similar code in DExpectFormalArglistSsm::_make
*/
DArray * args = DArray::_empty(mm, 8);
applyexprstatetype applystate
= (fn_expr
? applyexprstatetype::apply_1
: applyexprstatetype::apply_0);
// TODO: revisit if we decide to use flexible array for arguments
return new (mem) DApplySsm(applystate, fn_expr, args);
}
obj<ASyntaxStateMachine,DApplySsm>
DApplySsm::make(DArena & arena,
obj<AExpression> fn_expr)
{
return obj<ASyntaxStateMachine,DApplySsm>(_make(arena, fn_expr));
}
void
DApplySsm::start(obj<AExpression> fn_expr,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
auto ssm = DApplySsm::make(p_psm->parser_alloc(), fn_expr);
p_psm->push_ssm(ckp, ssm);
}
syntaxstatetype
DApplySsm::ssm_type() const noexcept {
return syntaxstatetype::apply;
}
std::string_view
DApplySsm::get_expect_str() const noexcept
{
switch(applystate_) {
case applyexprstatetype::invalid: return "invalid";
case applyexprstatetype::apply_0: return "expr";
case applyexprstatetype::apply_1: return "lparen";
case applyexprstatetype::apply_2: return "expr|rparen";
case applyexprstatetype::apply_3: return "comma|rparen";
case applyexprstatetype::N: break;
}
return "?expect";
}
void
DApplySsm::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_leftparen:
this->on_leftparen_token(tk, p_psm);
return;
case tokentype::tk_rightparen:
this->on_rightparen_token(tk, p_psm);
return;
case tokentype::tk_symbol:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_if:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_semicolon:
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_invalid:
case tokentype::tk_quote:
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_cmple:
case tokentype::tk_cmpge:
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_nil:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::on_token(tk, p_psm);
}
void
DApplySsm::on_leftparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (applystate_ == applyexprstatetype::apply_1) {
this->applystate_ = applyexprstatetype::apply_2;
DExpectExprSsm::start(false /*!allow_defs*/,
false /*!cxl_on_rightbrace*/,
true /*cxl_on_rightparen*/,
p_psm);
return;
}
Super::on_token(tk, p_psm);
}
void
DApplySsm::on_rightparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (applystate_ == applyexprstatetype::apply_2) {
obj<AExpression> apply = this->assemble_expr(p_psm->expr_alloc());
p_psm->pop_ssm();
p_psm->on_parsed_expression(apply);
return;
}
Super::on_token(tk, p_psm);
}
void
DApplySsm::on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk,
ParserStateMachine * p_psm)
{
/* maybe we'll find control comes here also on function position?
* hasn't come up when applyssm recognized via leftparen
*/
if (applystate_ == applyexprstatetype::apply_2) {
obj<AGCObject> expr_gco = expr.to_facet<AGCObject>();
assert(expr_gco);
obj<AAllocator,DArena> mm(&(p_psm->parser_alloc()));
if (args_expr_v_->size() == args_expr_v_->capacity()) {
// need to expand .args_expr_v_ capacity.
// Could use DArena checkpoint to redo this in place,
// since argument array must be on the top of the stack.
DArray * argv_2x = DArray::_empty(mm, 2 * args_expr_v_->capacity());
for (DArray::size_type i = 0, n = args_expr_v_->size(); i < n; ++i) {
argv_2x->push_back(mm, (*args_expr_v_)[i]);
}
this->args_expr_v_ = argv_2x;
}
if (args_expr_v_->size() < args_expr_v_->capacity())
args_expr_v_->push_back(mm, expr_gco);
if (tk.tk_type() == tokentype::tk_rightparen) {
obj<AExpression> apply_ex = this->assemble_expr(p_psm->expr_alloc());
p_psm->pop_ssm();
p_psm->on_parsed_expression(apply_ex);
return;
} else if (tk.tk_type() == tokentype::tk_comma) {
// 1. want to remain in state apply_2
// 2. expr from nested ssm already incorporated
// into .args_expr_v_
DExpectExprSsm::start(p_psm);
return;
}
}
Super::on_parsed_expression_with_token(expr, tk, p_psm);
}
obj<AExpression>
DApplySsm::assemble_expr(obj<AAllocator> mm)
{
// begin assemble_expr()..
std::uint32_t n_args = args_expr_v_->size();
DApplyExpr * apply
= (DApplyExpr::scaffold
(mm,
TypeRef::dwim(TypeRef::prefix_type::from_chars("apply"),
nullptr),
fn_expr_,
n_args));
for (std::uint32_t i_arg = 0; i_arg < n_args; ++i_arg) {
auto arg_expr
= args_expr_v_->at(i_arg).to_facet<AExpression>();
apply->assign_arg(i_arg, arg_expr);
}
// ..end assemble_expr()
obj<AExpression,DApplyExpr> apply_ex(apply);
return apply_ex;
}
#ifdef NOT_YET
void
apply_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
switch (applyxs_type_) {
case applyexprstatetype::invalid:
case applyexprstatetype::n_applyexprstatetype:
// unreachable
break;
case applyexprstatetype::apply_0:
log && log("stash fn -> new state apply_1");
this->fn_expr_ = expr.promote();
this->applyxs_type_ = applyexprstatetype::apply_1;
return;
case applyexprstatetype::apply_1:
log && log("error: was expecting lparen");
// error, expecting lparen
break;
case applyexprstatetype::apply_2:
log && log(xtag("expr", expr), xtag("do", "stash expr -> new state apply_3"));
this->args_expr_v_.push_back(expr.promote());
this->applyxs_type_ = applyexprstatetype::apply_3;
return;
case applyexprstatetype::apply_3:
// error, expecting comma|rparen
break;
}
/* control here --implies-> error state */
constexpr const char * c_self_name = "apply_xs::on_expr";
const char * exp = this->get_expect_str();
this->illegal_input_on_expr(c_self_name, expr, exp, p_psm);
}
void
apply_xs::on_comma_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
if (this->applyxs_type_ == applyexprstatetype::apply_3) {
this->applyxs_type_ = applyexprstatetype::apply_2;
expect_expr_xs::start(p_psm);
} else {
constexpr const char * c_self_name = "apply_xs::on_comma_token";
const char * exp = this->get_expect_str();
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
}
}
void
apply_xs::on_rightparen_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log("applyxs_type", applyxs_type_);
if (this->applyxs_type_ == applyexprstatetype::apply_3) {
/* (done) state */
log("apply complete -> pop + send expr");
rp<Apply> apply_expr = Apply::make(this->fn_expr_, this->args_expr_v_);
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
p_psm->top_exprstate().on_expr(apply_expr, p_psm);
return;
}
constexpr const char * c_self_name = "apply_xs::on_rightparen_token";
const char * exp = this->get_expect_str();
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
}
#endif
bool
DApplySsm::pretty(const ppindentinfo & ppii) const
{
// TODO: const-correct version of obj<> template
auto fn_expr = const_cast<DApplySsm*>(this)->fn_expr_.to_facet<APrintable>();
bool fn_expr_present(fn_expr);
return ppii.pps()->pretty_struct(ppii,
"DApplySsm",
refrtag("applystate", applystate_),
refrtag("expect", this->get_expect_str()),
refrtag("fn_expr", fn_expr, fn_expr_present));
}
void
DApplySsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_poly_child(reason, &fn_expr_);
gc.visit_child(reason, &args_expr_v_);
}
} /*namespace scm*/
} /*namespace xo*/
/* end DApplySsm.cpp */

703
xo-reader2/src/reader2/DDefineSsm.cpp
View file

@ -1,703 +0,0 @@
/** @file DDefineSsm.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "DDefineSsm.hpp"
#include "DExpectSymbolSsm.hpp"
#include "DExpectTypeSsm.hpp"
#include "DExpectExprSsm.hpp"
#include "DefineSsm.hpp"
#include <xo/expression2/DefineExpr.hpp>
#include <xo/printable2/Printable.hpp>
#include <xo/facet/FacetRegistry.hpp>
namespace xo {
using xo::print::APrintable;
using xo::facet::FacetRegistry;
using xo::facet::with_facet;
using xo::facet::typeseq;
namespace scm {
// ----- defexprstatetype -----
const char *
defexprstatetype_descr(defexprstatetype x) {
switch (x) {
case defexprstatetype::invalid: return "invalid";
case defexprstatetype::def_0: return "def_0";
case defexprstatetype::def_1: return "def_1";
case defexprstatetype::def_2: return "def_2";
case defexprstatetype::def_3: return "def_3";
case defexprstatetype::def_4: return "def_4";
case defexprstatetype::def_5: return "def_5";
case defexprstatetype::def_6: return "def_6";
case defexprstatetype::n_defexprstatetype: break;
}
return "???defexprstatetype";
}
std::ostream &
operator<<(std::ostream & os, defexprstatetype x) {
os << defexprstatetype_descr(x);
return os;
}
// ----- define_xs -----
// DDefineSsm::make
// DDefineSsm::start
#ifdef NOT_YET
define_xs::define_xs(rp<DefineExprAccess> def_expr)
: exprstate(exprstatetype::defexpr),
defxs_type_{defexprstatetype::def_0},
def_expr_{std::move(def_expr)}
{}
// const char *
// define_xs::get_expect_str() const { ... }
void
define_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log(xtag("defxs_type", defxs_type_));
if (this->defxs_type_ == defexprstatetype::def_5) {
/* have all the ingredients to create an expression
* representing a definition
*
* 1. if ir_type is a symbol, interpret as variable name.
* Need to be able to locate variable by type
* 2. if ir_type is an expression, adopt as rhs
*/
rp<Expression> rhs_value = expr.promote();
if (this->cvt_expr_) {
this->cvt_expr_->assign_arg(rhs_value);
} else {
/* note: establishes .def_expr_ valuetype */
this->def_expr_->assign_rhs(rhs_value);
}
rp<Expression> def_expr = this->def_expr_;
this->defxs_type_ = defexprstatetype::def_6;
return;
}
constexpr const char * c_self_name = "define_xs::on_expr";
const char * exp = get_expect_str();
this->illegal_input_on_expr(c_self_name, expr, exp, p_psm);
}
void
define_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log(xtag("defxs_type", defxs_type_));
this->on_expr(expr, p_psm);
/* semicolon is allowed to terminate def expr */
this->on_semicolon_token(token_type::semicolon(), p_psm);
}
void
define_xs::on_symbol(const std::string & symbol_name,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log(xtag("defxs_type", defxs_type_), xtag("env_stack_size", p_psm->env_stack_size()));
if (this->defxs_type_ == defexprstatetype::def_1) {
this->defxs_type_ = defexprstatetype::def_2;
this->def_expr_->assign_lhs_name(symbol_name);
// if this is a genuine top-level define (i.e. nesting level = 0),
// then we need to upsert so we can refer to rhs later.
//
// In other contexts (e.g. body-of-lambda) will be rewriting
// {
// def y = foo(x,x);
// bar(y,y);
// }
// into something like
// {
// (lambda (y123) bar(y123,y123))(foo(x,x));
// }
//
// This works in the body of lambda, because we don't evaluate anything
// until lambda definition is complete.
//
// For interactive top-level defs we want to evaluate as we go,
// so need incremental bindings.
if (p_psm->env_stack_size() == 1) {
/* remember variable binding in lexical context,
* so we can refer to it later
*/
p_psm->upsert_var(this->def_expr_->lhs_variable());
}
return;
}
constexpr const char * c_self_name = "define_xs::on_symbol";
const char * exp = this->get_expect_str();
this->illegal_input_on_symbol(c_self_name, symbol_name, exp, p_psm);
}
void
define_xs::on_typedescr(TypeDescr td,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log("defxs_type", defxs_type_);
if (this->defxs_type_ == defexprstatetype::def_3) {
this->defxs_type_ = defexprstatetype::def_4;
this->cvt_expr_ = ConvertExprAccess::make(td /*dest_type*/,
nullptr /*source_expr*/);
/* note: establishes .def_expr_ valuetype */
this->def_expr_->assign_rhs(this->cvt_expr_);
return;
}
constexpr const char * c_self_name = "define_xs::on_symbol";
const char * exp = this->get_expect_str();
this->illegal_input_on_type(c_self_name, td, exp, p_psm);
}
void
define_xs::on_def_token(const token_type & tk,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
log && log("defxs_type", defxs_type_);
if (this->defxs_type_ == defexprstatetype::def_0) {
this->defxs_type_ = defexprstatetype::def_1;
expect_symbol_xs::start(p_psm);
return;
}
constexpr const char * c_self_name = "define_xs::on_def_token";
const char * exp = this->get_expect_str();
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
}
void
define_xs::on_colon_token(const token_type & tk,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
log && log("defxs_type", defxs_type_);
if (this->defxs_type_ == defexprstatetype::def_2) {
this->defxs_type_ = defexprstatetype::def_3;
expect_type_xs::start(p_psm);
return;
}
constexpr const char * c_self_name = "define_xs::on_symbol";
const char * exp = this->get_expect_str();
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
}
void
define_xs::on_semicolon_token(const token_type & tk,
parserstatemachine * p_psm)
{
/* def expr consumes semicolon */
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log("defxs_type", defxs_type_);
if (this->defxs_type_ == defexprstatetype::def_6) {
rp<DefineExprAccess> def_expr = this->def_expr_;
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
p_psm->top_exprstate().on_expr(def_expr, p_psm);
return;
}
constexpr const char * c_self_name = "define_xs::on_symbol";
const char * exp = this->get_expect_str();
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
}
void
define_xs::on_singleassign_token(const token_type & tk,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
log && log("defxs_type", defxs_type_);
if ((this->defxs_type_ == defexprstatetype::def_2)
|| (this->defxs_type_ == defexprstatetype::def_4))
{
this->defxs_type_ = defexprstatetype::def_5;
expect_expr_xs::start(p_psm);
return;
}
constexpr const char * c_self_name = "define_xs::on_singleassign_token";
const char * exp = get_expect_str();
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
}
void
define_xs::on_rightparen_token(const token_type & tk,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
constexpr const char * c_self_name = "define_xs::on_rightparen";
const char * exp = get_expect_str();
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
}
void
define_xs::on_i64_token(const token_type & tk,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
constexpr const char * c_self_name = "define_xs::on_i64";
const char * exp = get_expect_str();
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
}
void
define_xs::on_f64_token(const token_type & tk,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
constexpr const char * c_self_name = "define_xs::on_f64";
const char * exp = get_expect_str();
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
}
void
define_xs::print(std::ostream & os) const {
os << "<define_xs"
<< xtag("defxs_type", defxs_type_);
os << ">";
}
bool
define_xs::pretty_print(const xo::print::ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct(ppii, "define_xs",
refrtag("defxs_type", defxs_type_));
}
#endif
////////////////////////////////////////////////////////////////
DDefineSsm::DDefineSsm(DDefineExpr * def_expr)
: defstate_{defexprstatetype::def_0},
def_expr_{def_expr}
{}
DDefineSsm *
DDefineSsm::_make(DArena & mm,
DDefineExpr * def_expr)
{
void * mem = mm.alloc(typeseq::id<DDefineSsm>(),
sizeof(DDefineSsm));
return new (mem) DDefineSsm(def_expr);
}
obj<ASyntaxStateMachine,DDefineSsm>
DDefineSsm::make(DArena & mm,
DDefineExpr * def_expr)
{
return obj<ASyntaxStateMachine,DDefineSsm>(_make(mm, def_expr));
}
void
DDefineSsm::start(DArena & mm,
obj<AAllocator> expr_mm,
ParserStateMachine * p_psm)
{
//scope log(XO_DEBUG(p_psm->debug_flag()));
assert(p_psm->stack());
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
DDefineExpr * def_expr = DDefineExpr::make_empty(expr_mm);
auto define_ssm = DDefineSsm::make(mm, def_expr);
p_psm->push_ssm(ckp, define_ssm);
// note: triggers poly dispatch
p_psm->on_token(Token::def_token());
}
syntaxstatetype
DDefineSsm::ssm_type() const noexcept
{
return syntaxstatetype::defexpr;
}
std::string_view
DDefineSsm::get_expect_str() const noexcept
{
/*
* def foo = 1 ;
* def foo : f64 = 1 ;
* ^ ^ ^ ^ ^ ^ ^ ^
* | | | | | | | (done)
* | | | | | | def_6
* | | | | | def_5:expect_rhs_expression
* | | | | def_4
* | | | def_3:expect_type
* | | def_2
* | def_1:expect_symbol
* expect_toplevel_expression_sequence
*
* note that we skip from def_2 -> def_5 if '=' instead of ':'
*/
switch (this->defstate_) {
case defexprstatetype::invalid:
case defexprstatetype::def_0:
case defexprstatetype::n_defexprstatetype:
assert(false); // impossible
return "impossible!?";
case defexprstatetype::def_1:
return "symbol";
case defexprstatetype::def_2:
return "singleassign|colon";
case defexprstatetype::def_4:
return "singleassign";
case defexprstatetype::def_3:
return "type";
case defexprstatetype::def_5:
return "expression";
case defexprstatetype::def_6:
return "semicolon";
}
return "?expect";
}
void
DDefineSsm::on_parsed_symbol(std::string_view sym_name,
ParserStateMachine * p_psm)
{
if (defstate_ == defexprstatetype::def_1) {
this->defstate_ = defexprstatetype::def_2;
const DUniqueString * sym
= p_psm->intern_string(sym_name);
def_expr_.data()->assign_lhs_name(sym);
// if this is a genuine top-level define (i.e. nesting level = 0),
// then we need to upsert so we can refer to rhs later.
//
// In other contexts (e.g. body-of-lambda) will be rewriting
// {
// def y = foo(x,x);
// bar(y,y);
// }
// into something like
// {
// (lambda (y123) bar(y123,y123))(foo(x,x));
// }
//
// This works in the body of lambda, because we don't evaluate anything
// until lambda definition is complete.
//
// For interactive top-level defs we want to evaluate as we go,
// so need incremental bindings.
if (p_psm->is_at_toplevel()) {
/** remember variable binding in current lexical context **/
p_psm->upsert_var(def_expr_.data()->lhs());
}
return;
}
p_psm->illegal_input_on_symbol("DDefineSsm::on_parsed_symbol",
sym_name,
this->get_expect_str());
}
void
DDefineSsm::on_parsed_typedescr(TypeDescr td,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()), xtag("td", td));
if (defstate_ == defexprstatetype::def_3) {
this->defstate_ = defexprstatetype::def_4;
// note: not present in x0-reader/ version
def_expr_.assign_valuetype(td);
#ifdef NOT_YET
this->cvt_expr_ = ConvertExpr::make(td, nullptr);
def_expr_->assign_rhs(cvt_expr_);
#endif
log && log("STUB: ConvertExpr not implemented, TypeDescr not captured");
return;
}
p_psm->illegal_input_on_typedescr("DDefineSsm::on_parsed_typedescr",
td,
this->get_expect_str());
}
void
DDefineSsm::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:
this->on_symbol_token(tk, p_psm);
return;
case tokentype::tk_def:
this->on_def_token(tk, p_psm);
return;
case tokentype::tk_colon:
this->on_colon_token(tk, p_psm);
return;
case tokentype::tk_singleassign:
this->on_singleassign_token(tk, p_psm);
return;
case tokentype::tk_semicolon:
this->on_semicolon_token(tk, p_psm);
return;
// all the not-yet handled cases
case tokentype::tk_invalid:
case tokentype::tk_deftype:
case tokentype::tk_string:
case tokentype::tk_f64:
case tokentype::tk_i64:
case tokentype::tk_bool:
case tokentype::tk_if:
case tokentype::tk_quote:
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_cmple:
case tokentype::tk_cmpge:
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_nil:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::on_token(tk, p_psm);
}
void
DDefineSsm::on_symbol_token(const Token & tk,
ParserStateMachine * p_psm)
{
// note:
// in state def_1, DDefineSsm learns symbol via .on_parsed_symbol().
// symbol token arriving here means encountered symbol while
// in some other, which can't happen for valid Schematika input
Super::on_token(tk, p_psm);
}
void
DDefineSsm::on_def_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (defstate_ == defexprstatetype::def_0) {
this->defstate_ = defexprstatetype::def_1;
DExpectSymbolSsm::start(p_psm);
return;
}
Super::on_token(tk, p_psm);
}
void
DDefineSsm::on_colon_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (defstate_ == defexprstatetype::def_2) {
this->defstate_ = defexprstatetype::def_3;
DExpectTypeSsm::start(false /*!corrected*/, p_psm);
return;
}
Super::on_token(tk, p_psm);
}
void
DDefineSsm::on_singleassign_token(const Token & tk,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()), xtag("defstate", defstate_));
if ((defstate_ == defexprstatetype::def_2)
|| (defstate_ == defexprstatetype::def_4))
{
this->defstate_ = defexprstatetype::def_5;
DExpectExprSsm::start(p_psm);
return;
}
Super::on_token(tk, p_psm);
}
void
DDefineSsm::on_semicolon_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (defstate_ == defexprstatetype::def_6) {
p_psm->pop_ssm();
p_psm->on_parsed_expression_with_token(def_expr_, tk);
return;
}
Super::on_token(tk, p_psm);
}
void
DDefineSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
if (defstate_ == defexprstatetype::def_5)
{
this->defstate_ = defexprstatetype::def_6;
def_expr_.data()->assign_rhs(expr);
return;
}
Super::on_parsed_expression(expr, p_psm);
}
void
DDefineSsm::on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk,
ParserStateMachine * p_psm)
{
/* must end with semicolon */
if (tk.tk_type() == tokentype::tk_semicolon) {
if (defstate_ == defexprstatetype::def_5)
{
this->defstate_ = defexprstatetype::def_6;
def_expr_.data()->assign_rhs(expr);
// completes this definition syntax
this->on_semicolon_token(tk, p_psm);
return;
}
}
// error in all other cases
Super::on_parsed_expression_with_token(expr, tk, p_psm);
}
// ----- printable facet -----
bool
DDefineSsm::pretty(const ppindentinfo & ppii) const
{
auto expr
= FacetRegistry::instance().variant<APrintable,
AExpression>(def_expr_);
assert(expr.data());
return ppii.pps()->pretty_struct(ppii,
"DDefineSsm",
refrtag("defstate", defstate_),
refrtag("expect", this->get_expect_str()),
refrtag("def_expr", expr));
}
// ----- gc support -----
void
DDefineSsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_child(reason, &def_expr_.data_);
}
} /*namespace scm*/
} /*namespace xo*/
/* end DDefineSsm.cpp */

282
xo-reader2/src/reader2/DDeftypeSsm.cpp
View file

@ -1,282 +0,0 @@
/** @file DDeftypeSsm.cpp
*
* @author Roland Conybeare, Mar 2026
**/
#include "DeftypeSsm.hpp"
#include "syntaxstatetype.hpp"
#include "ExpectSymbolSsm.hpp"
#include "ExpectTypeSsm.hpp"
#include "Constant.hpp"
#include <xo/object2/Boolean.hpp>
#include <string_view>
namespace xo {
namespace scm {
extern const char *
DeftypeXst::_descr(enum DeftypeXst::code x)
{
switch (x) {
case code::invalid: return "invalid";
case code::def_0: return "def_0";
case code::def_1: return "def_1";
case code::def_2: return "def_2";
case code::def_3: return "def_3";
case code::def_4: return "def_4";
case code::N: break;
}
return "?DeftypeXst";
}
std::ostream &
operator<<(std::ostream & os, DeftypeXst x)
{
os << DeftypeXst::_descr(x.code());
return os;
}
DDeftypeSsm::DDeftypeSsm()
: deftype_xst_{DeftypeXst::code::def_0}
{}
DDeftypeSsm *
DDeftypeSsm::_make(DArena & parser_mm)
{
void * mem = parser_mm.alloc_for<DDeftypeSsm>();
return new (mem) DDeftypeSsm();
}
obj<ASyntaxStateMachine,DDeftypeSsm>
DDeftypeSsm::make(DArena & parser_mm)
{
return obj<ASyntaxStateMachine,DDeftypeSsm>(_make(parser_mm));
}
void
DDeftypeSsm::start(DArena & mm,
ParserStateMachine * p_psm)
{
assert(p_psm->stack());
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
auto deftype_ssm = DDeftypeSsm::make(mm);
p_psm->push_ssm(ckp, deftype_ssm);
}
syntaxstatetype
DDeftypeSsm::ssm_type() const noexcept
{
return syntaxstatetype::deftypeexpr;
}
std::string_view
DDeftypeSsm::get_expect_str() const noexcept
{
switch (this->deftype_xst_.code()) {
case DeftypeXst::code::invalid:
break;
case DeftypeXst::code::def_0:
return "deftype";
case DeftypeXst::code::def_1:
return "symbol";
case DeftypeXst::code::def_2:
return "doublecolon";
case DeftypeXst::code::def_3:
return "type";
case DeftypeXst::code::def_4:
return "semicolon";
case DeftypeXst::code::N:
break;
}
return "?expect";
}
void
DDeftypeSsm::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_deftype:
this->on_deftype_token(tk, p_psm);
return;
case tokentype::tk_doublecolon:
this->on_doublecolon_token(tk, p_psm);
return;
case tokentype::tk_semicolon:
this->on_semicolon_token(tk, p_psm);
return;
// all the not-yet handled cases
case tokentype::tk_symbol:
case tokentype::tk_def:
case tokentype::tk_colon:
case tokentype::tk_singleassign:
case tokentype::tk_invalid:
case tokentype::tk_string:
case tokentype::tk_f64:
case tokentype::tk_i64:
case tokentype::tk_bool:
case tokentype::tk_if:
case tokentype::tk_quote:
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_cmple:
case tokentype::tk_cmpge:
case tokentype::tk_dot:
case tokentype::tk_comma:
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_nil:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::illegal_token(tk, p_psm);
}
void
DDeftypeSsm::on_deftype_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (deftype_xst_.code() == DeftypeXst::code::def_0) {
this->deftype_xst_ = DeftypeXst(DeftypeXst::code::def_1);
DExpectSymbolSsm::start(p_psm);
/* continue in .on_parsed_symbol() */
return;
}
Super::illegal_token(tk, p_psm);
}
void
DDeftypeSsm::on_parsed_symbol(std::string_view sym_name,
ParserStateMachine * p_psm)
{
if (deftype_xst_.code() == DeftypeXst::code::def_1) {
this->deftype_xst_ = DeftypeXst(DeftypeXst::code::def_2);
this->lhs_symbol_ = p_psm->intern_string(sym_name);
return;
}
Super::illegal_parsed_symbol(sym_name, p_psm);
}
void
DDeftypeSsm::on_doublecolon_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (deftype_xst_.code() == DeftypeXst::code::def_2) {
this->deftype_xst_ = DeftypeXst(DeftypeXst::code::def_3);
DExpectTypeSsm::start(true /*corrected*/, p_psm);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DDeftypeSsm::on_parsed_type(obj<AType> type,
ParserStateMachine * p_psm)
{
if (deftype_xst_.code() == DeftypeXst::code::def_3) {
this->deftype_xst_ = DeftypeXst(DeftypeXst::code::def_4);
DLocalSymtab * local = p_psm->local_symtab();
if (local) {
local->append_type(p_psm->expr_alloc(),
lhs_symbol_,
type);
} else {
DGlobalSymtab * global = p_psm->global_symtab();
DTypename * tname = DTypename::_make(p_psm->expr_alloc(),
lhs_symbol_,
type);
global->upsert_typename(p_psm->expr_alloc(), tname);
}
return;
}
Super::illegal_type(type, p_psm);
}
void
DDeftypeSsm::on_semicolon_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (deftype_xst_.code() == DeftypeXst::code::def_4) {
p_psm->pop_ssm();
// Reporting a placeholder expression to preserve policy
// that 'every toplevel statement produces an expression'
//
auto result_expr
= DConstant::make(p_psm->expr_alloc(),
DBoolean::box<AGCObject>(p_psm->expr_alloc(),
true));
p_psm->on_parsed_expression(result_expr);
return;
}
Super::illegal_token(tk, p_psm);
}
bool
DDeftypeSsm::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct(ppii,
"DDeftypeSsm",
refrtag("deftypestate", deftype_xst_),
refrtag("expect", this->get_expect_str()));
}
void
DDeftypeSsm::visit_gco_children(VisitReason, obj<AGCObjectVisitor>) noexcept
{
static_assert(!DUniqueString::is_gc_eligible());
}
} /*namespace scm*/
} /*namespace xo*/
/* end DDeftypeSsm.cpp */

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

@ -1,637 +0,0 @@
/** @file DExpectExprSsm.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "ExpectExprSsm.hpp"
#include "ParserStateMachine.hpp"
#include "ParserStack.hpp"
#include "SyntaxStateMachine.hpp"
#include "ProgressSsm.hpp"
#include "DSequenceSsm.hpp"
#include "IfElseSsm.hpp"
#include "LambdaSsm.hpp"
#include "QuoteSsm.hpp"
#include "syntaxstatetype.hpp"
#include <xo/expression2/Variable.hpp>
#include <xo/expression2/Constant.hpp>
#include <xo/object2/Boolean.hpp>
#include <xo/object2/Integer.hpp>
#include <xo/object2/Float.hpp>
#include <xo/object2/List.hpp>
#include <xo/stringtable2/String.hpp>
#include <xo/alloc2/GCObject.hpp>
#include <xo/facet/facet_implementation.hpp>
#ifdef NOT_YET
#include "define_xs.hpp"
#include "paren_xs.hpp"
#endif
namespace xo {
using xo::scm::DFloat;
using xo::mm::AGCObject;
using xo::reflect::typeseq;
using xo::facet::with_facet;
namespace scm {
DExpectExprSsm::DExpectExprSsm(bool allow_defs,
bool cxl_on_rightbrace,
bool cxl_on_rightparen)
: allow_defs_{allow_defs},
cxl_on_rightbrace_{cxl_on_rightbrace},
cxl_on_rightparen_{cxl_on_rightparen}
{
}
DExpectExprSsm *
DExpectExprSsm::_make(DArena & mm,
bool allow_defs,
bool cxl_on_rightbrace,
bool cxl_on_rightparen)
{
void * mem = mm.alloc(typeseq::id<DExpectExprSsm>(),
sizeof(DExpectExprSsm));
return new (mem) DExpectExprSsm(allow_defs,
cxl_on_rightbrace,
cxl_on_rightparen);
}
obj<ASyntaxStateMachine,DExpectExprSsm>
DExpectExprSsm::make(DArena & mm,
bool allow_defs,
bool cxl_on_rightbrace,
bool cxl_on_rightparen)
{
return obj<ASyntaxStateMachine,DExpectExprSsm>(_make(mm, allow_defs, cxl_on_rightbrace, cxl_on_rightparen));
}
void
DExpectExprSsm::start(bool allow_defs,
bool cxl_on_rightbrace,
bool cxl_on_rightparen,
ParserStateMachine * p_psm)
{
auto & mm = p_psm->parser_alloc();
DArena::Checkpoint ckp = mm.checkpoint();
auto ssm = DExpectExprSsm::make(mm, allow_defs, cxl_on_rightbrace, cxl_on_rightparen);
p_psm->push_ssm(ckp, ssm);
}
void
DExpectExprSsm::start(ParserStateMachine * p_psm)
{
start(false /*!allow_defs*/,
false /*!cxl_on_rightbrace*/,
false /*cxl_on_rightparen*/,
p_psm);
}
syntaxstatetype
DExpectExprSsm::ssm_type() const noexcept
{
return syntaxstatetype::expect_rhs_expression;
}
std::string_view
DExpectExprSsm::get_expect_str() const noexcept
{
if (allow_defs_) {
return "def|if|lambda|lparen|lbrace|literal|var";
} else {
return "if|lambda|lparen|lbrace|literal|var";
}
}
void
DExpectExprSsm::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_leftparen:
this->on_leftparen_token(tk, p_psm);
return;
case tokentype::tk_rightparen:
this->on_rightparen_token(tk, p_psm);
return;
case tokentype::tk_leftbrace:
this->on_leftbrace_token(tk, p_psm);
return;
case tokentype::tk_symbol:
this->on_symbol_token(tk, p_psm);
return;
case tokentype::tk_def:
this->on_def_token(tk, p_psm);
return;
case tokentype::tk_quote:
this->on_quote_token(tk, p_psm);
return;
case tokentype::tk_string:
this->on_string_token(tk, p_psm);
return;
case tokentype::tk_f64:
this->on_f64_token(tk, p_psm);
return;
case tokentype::tk_i64:
this->on_i64_token(tk, p_psm);
return;
case tokentype::tk_bool:
this->on_bool_token(tk, p_psm);
return;
case tokentype::tk_nil:
this->on_nil_token(tk, p_psm);
return;
case tokentype::tk_if:
this->on_if_token(tk, p_psm);
return;
case tokentype::tk_lambda:
this->on_lambda_token(tk, p_psm);
return;
// all the not-yet handled cases
case tokentype::tk_invalid:
case tokentype::tk_deftype:
case tokentype::tk_singleassign:
case tokentype::tk_colon:
case tokentype::tk_semicolon:
case tokentype::tk_leftbracket:
case tokentype::tk_rightbracket:
case tokentype::tk_rightbrace:
case tokentype::tk_leftangle:
case tokentype::tk_rightangle:
case tokentype::tk_cmple:
case tokentype::tk_cmpge:
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_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::on_token(tk, p_psm);
}
void
DExpectExprSsm::on_leftparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
// need progress ssm here because this is allowed:
//
// if (foo) > 5 then ...
//
// Start progress ssm, delegate incoming token thereto
//
DProgressSsm::start(p_psm->parser_alloc(),
p_psm);
p_psm->on_token(tk);
}
void
DExpectExprSsm::on_rightparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (cxl_on_rightparen_) {
/* abandon expression, delegate rightparen to parent */
p_psm->pop_ssm();
p_psm->on_token(tk);
return;
}
Super::on_token(tk, p_psm);
}
void
DExpectExprSsm::on_leftbrace_token(const Token & tk,
ParserStateMachine * p_psm)
{
(void)tk;
DSequenceSsm::start(p_psm);
}
void
DExpectExprSsm::on_symbol_token(const Token & tk,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log(xtag("tk", tk));
DVarRef * var = p_psm->lookup_varref(tk.text());
if (!var) {
p_psm->error_unbound_variable(ssm_classname(),
tk.text());
}
// examples of possible continuations from symbol foo
// foo ; // (1) foo is entire rvalue expression
// foo + ... // (2) foo begin operator expression
// foo(..); // (3) foo begin apply function
//
//
DProgressSsm::start(p_psm->parser_alloc(),
obj<AExpression,DVarRef>(var),
p_psm);
}
#ifdef NOT_YET
void
expect_expr_xs::on_symbol_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log(xtag("tk", tk));
constexpr const char * c_self_name = "expect_expr_xs::on_symbol_token";
/* various possibilities when looking for rhs expression:
*
* x := y // (1)
* x := f(a) // (2)
* x := f(a,b) // (3)
*
* need lookahead token following symbol to distinguish
* between (1) (symbol completes rhs expression)
* and {(2), (3)} (symbol is function call)
*/
bp<Variable> var = p_psm->lookup_var(tk.text());
if (!var) {
this->unknown_variable_error(c_self_name, tk, p_psm);
return;
}
/* e.g.
* def pi = 3.14159265;
* def mypi = pi;
* ^
* def pi2 = pi * 2;
* ^
* def y = foo(pi2);
* ^
*/
progress_xs::start(var.promote(), p_psm);
#ifdef NOT_YET
p_stack->push_exprstate(exprstate(exprstatetype::expr_progress,
Variable::make(name, type)));
#endif
#ifdef LATER
p_psm->pop_exprstate();
p_psm->top_exprstate().on_symbol(tk.text(),
p_stack, p_emit_expr);
#endif
return;
}
#endif
#ifdef NOT_YET
void
expect_expr_xs::on_def_token(const token_type & tk,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
if (allow_defs_) {
define_xs::start(p_psm);
} else {
exprstate::on_def_token(tk, p_psm);
}
}
#endif
void
DExpectExprSsm::on_def_token(const Token & tk,
ParserStateMachine * p_psm)
{
Super::on_token(tk, p_psm);
}
void
DExpectExprSsm::on_quote_token(const Token & tk,
ParserStateMachine * p_psm)
{
(void)tk;
DProgressSsm::start(p_psm->parser_alloc(), p_psm);
DQuoteSsm::start(p_psm);
p_psm->on_token(Token::quote_token());
}
void
DExpectExprSsm::on_bool_token(const Token & tk,
ParserStateMachine * p_psm)
{
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
DExpectExprSsm::on_nil_token(const Token & tk,
ParserStateMachine * p_psm)
{
(void)tk;
auto nil = DList::nil();
auto expr = DConstant::make(p_psm->expr_alloc(), nil);
// DProgressSsm responsible for resolving cases like
// nil ++ nil;
DProgressSsm::start(p_psm->parser_alloc(),
expr,
p_psm);
}
void
DExpectExprSsm::on_f64_token(const Token & tk,
ParserStateMachine * p_psm)
{
auto f64o = DFloat::box<AGCObject>(p_psm->expr_alloc(),
tk.f64_value());
auto expr = DConstant::make(p_psm->expr_alloc(), f64o);
// DProgressSsm responsible for resolving cases like
// 1.9,
// 1.9;
// 1.9 + 2;
// 1.9 + 2 .. // could be followed by infix
// 1.9 + 2 * 3;
// 1.9 + 2 * 3 .. // could be followed by infix
// 1.9 * (2 + 3)
DProgressSsm::start(p_psm->parser_alloc(),
expr,
p_psm);
}
void
DExpectExprSsm::on_i64_token(const Token & tk,
ParserStateMachine * p_psm)
{
auto i64o = DInteger::box<AGCObject>(p_psm->expr_alloc(),
tk.i64_value());
auto expr = DConstant::make(p_psm->expr_alloc(), i64o);
// Consider parser stack, with control here at b
//
// a * b - c
// ^
//
// [1] ExpectExpr <-- this
// [0] ProgressSsm :lhs k(b) :op * :rhs _
//
// if parent is ProgressSsm [0], need to deliver k(b) to it;
// Then let that ProgressSsm [0] establish whether next token
// is operator.
//
assert((void*)p_psm->stack()->top().data() == (void*)this);
if (p_psm->stack()->parent()) {
auto parent_ssm = (obj<ASyntaxStateMachine,DProgressSsm>::from
(p_psm->stack()->parent()->top()));
if (parent_ssm) {
// parent is-a DProgressSsm instance
p_psm->pop_ssm();
p_psm->on_parsed_expression(expr);
return;
}
}
// 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_string_token(const Token & tk,
ParserStateMachine * p_psm)
{
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
DExpectExprSsm::on_if_token(const Token & tk,
ParserStateMachine * p_psm)
{
(void)tk;
DIfElseSsm::start(p_psm->parser_alloc(),
p_psm->expr_alloc(),
p_psm);
// TODO: should send if-token here
}
void
DExpectExprSsm::on_lambda_token(const Token & tk,
ParserStateMachine * p_psm)
{
(void)tk;
DLambdaSsm::start(p_psm);
}
void
DExpectExprSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
p_psm->pop_ssm();
p_psm->on_parsed_expression(expr);
}
void
DExpectExprSsm::on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk,
ParserStateMachine * p_psm)
{
// expression (reported by nested ProgressSsm)
// completes this DExpectExprSsm's assignment
p_psm->pop_ssm();
p_psm->on_parsed_expression_with_token(expr, tk);
}
#ifdef NOT_YET
void
DExpectExprSsm::on_quoted_literal(obj<AGCObject> lit,
ParserStateMachine * p_psm)
{
// note: impl here parallels .on_f64_token() .on_i64_token() etc.
auto expr = DConstant::make(p_psm->expr_alloc(), lit);
DProgressSsm::start(p_psm->parser_alloc(),
expr,
p_psm);
}
#endif
bool
DExpectExprSsm::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct
(ppii,
"DExpectExprSsm",
refrtag("allow_defs", allow_defs_),
refrtag("cxl_on_rightbrace", cxl_on_rightbrace_),
refrtag("cxl_on_rightparen", cxl_on_rightparen_),
refrtag("expect", this->get_expect_str()));
}
#ifdef NOT_YET
void
expect_expr_xs::on_if_token(const token_type & /*tk*/,
parserstatemachine * p_psm)
{
if_else_xs::start(p_psm);
}
void
expect_expr_xs::on_rightbrace_token(const token_type & tk,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
if (cxl_on_rightbrace_) {
auto self = p_psm->pop_exprstate();
/* do not call .on_expr(), since '}' cancelled */
p_psm->on_rightbrace_token(tk);
} else {
exprstate::on_rightbrace_token(tk, p_psm);
}
}
void
expect_expr_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log(xtag("exstype", this->exs_type_),
xtag("expr", expr.promote()));
log && log("pop expect_expr_xs, forward to parent");
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
p_psm->on_expr(expr);
} /*on_expr*/
void
expect_expr_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log(xtag("exstype", this->exs_type_),
xtag("expr", expr.promote()));
log && log("pop expect_expr_xs, forward to parent");
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
p_psm->on_expr_with_semicolon(expr);
} /*on_expr_with_semicolon*/
void
expect_expr_xs::print(std::ostream & os) const {
os << "<expect_expr_xs"
<< xtag("allow_defs", allow_defs_)
<< xtag("cxl_on_rightbrace", cxl_on_rightbrace_)
<< ">";
}
#endif
void
DExpectExprSsm::visit_gco_children(VisitReason,
obj<AGCObjectVisitor>) noexcept
{
// all members POD, skip
}
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectExprSsm.cpp */

278
xo-reader2/src/reader2/DExpectFormalArgSsm.cpp
View file

@ -1,278 +0,0 @@
/** @file DExpectFormalArgSsm.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "ExpectFormalArgSsm.hpp"
#include "ExpectSymbolSsm.hpp"
#include "ExpectTypeSsm.hpp"
namespace xo {
using xo::scm::DVariable;
using xo::reflect::TypeDescr;
using xo::facet::typeseq;
namespace scm {
const char *
formalstatetype_descr(formalstatetype x) {
switch (x) {
case formalstatetype::invalid:
case formalstatetype::n_formalstatetype:
return "?formalstatetype";
case formalstatetype::formal_0:
return "formal_0";
case formalstatetype::formal_1:
return "formal_1";
case formalstatetype::formal_2:
return "formal_2";
}
return "???formalstatetype";
}
DExpectFormalArgSsm::DExpectFormalArgSsm() = default;
obj<ASyntaxStateMachine,DExpectFormalArgSsm>
DExpectFormalArgSsm::make(DArena & mm)
{
return obj<ASyntaxStateMachine,DExpectFormalArgSsm>(_make(mm));
}
DExpectFormalArgSsm *
DExpectFormalArgSsm::_make(DArena & mm)
{
void * mem = mm.alloc(typeseq::id<DExpectFormalArgSsm>(), sizeof(DExpectFormalArgSsm));
return new (mem) DExpectFormalArgSsm();
}
void
DExpectFormalArgSsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
p_psm->push_ssm(ckp, DExpectFormalArgSsm::make(p_psm->parser_alloc()));
DExpectSymbolSsm::start(p_psm);
}
syntaxstatetype
DExpectFormalArgSsm::ssm_type() const noexcept {
return syntaxstatetype::expect_formal_arg;
}
std::string_view
DExpectFormalArgSsm::get_expect_str() const noexcept
{
switch(fstate_) {
case formalstatetype::invalid:
case formalstatetype::n_formalstatetype:
break;
case formalstatetype::formal_0:
return "formal-name";
case formalstatetype::formal_1:
return "colon|typename";
case formalstatetype::formal_2:
return "typename";
}
return "?expect";
}
/** update state on incoming token @p tk,
* with overall parser state in @p p_psm
**/
void
DExpectFormalArgSsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (tk.tk_type()) {
case tokentype::tk_colon:
this->on_colon_token(tk, p_psm);
return;
case tokentype::tk_rightparen:
this->on_rightparen_token(tk, p_psm);
return;
// all the not-yet-handled cases
case tokentype::tk_leftparen:
case tokentype::tk_lambda:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_if:
case tokentype::tk_symbol:
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_quote:
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_cmple:
case tokentype::tk_cmpge:
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_nil:
case tokentype::tk_type:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::on_token(tk, p_psm);
}
void
DExpectFormalArgSsm::on_colon_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (fstate_ == formalstatetype::formal_1) {
this->fstate_ = formalstatetype::formal_2;
DExpectTypeSsm::start(false /*!corrected*/, p_psm);
/* control reenters via DExpectFormalArgSsm::on_parsed_typedescr() */
return;
}
Super::on_token(tk, p_psm);
}
void
DExpectFormalArgSsm::on_rightparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (fstate_ == formalstatetype::formal_1) {
// formal with no type annotation
assert(name_);
p_psm->pop_ssm();
p_psm->on_parsed_formal_with_token(name_, nullptr, tk);
return;
}
Super::on_token(tk, p_psm);
}
void
DExpectFormalArgSsm::on_parsed_symbol(std::string_view sym,
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;
}
Super::on_parsed_symbol(sym, p_psm);
}
void
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;
}
Super::on_parsed_typedescr(td, p_psm);
}
#ifdef NOT_YET
expect_formal_xs::expect_formal_xs()
: exprstate(exprstatetype::expect_formal)
{}
void
expect_formal_xs::on_symbol(const std::string & symbol_name,
parserstatemachine * p_psm)
{
if (this->formalxs_type_ == formalstatetype::formal_0) {
this->formalxs_type_ = formalstatetype::formal_1;
this->result_.assign_name(symbol_name);
} else {
exprstate::on_symbol(symbol_name, p_psm);
}
}
void
expect_formal_xs::on_typedescr(TypeDescr td,
parserstatemachine * p_psm)
{
if (this->formalxs_type_ == formalstatetype::formal_2) {
this->result_.assign_td(td);
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
rp<Variable> var = Variable::make(result_.name(),
result_.td());
p_psm->top_exprstate().on_formal(var, p_psm);
} else {
exprstate::on_typedescr(td, p_psm);
}
}
#endif
bool
DExpectFormalArgSsm::pretty(const ppindentinfo & ppii) const {
if (name_) {
return ppii.pps()->pretty_struct
(ppii,
"DExpectFormalArgSsm",
refrtag("fstate", fstate_),
refrtag("expect", this->get_expect_str()),
refrtag("name", std::string_view(*name_)));
} else {
return ppii.pps()->pretty_struct
(ppii,
"DExpectFormalArgSsm",
refrtag("fstate", fstate_),
refrtag("expect", this->get_expect_str())
);
}
}
void
DExpectFormalArgSsm::visit_gco_children(VisitReason,
obj<AGCObjectVisitor>) noexcept
{
static_assert(!DUniqueString::is_gc_eligible());
}
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectFormalArgSsm.cpp */

372
xo-reader2/src/reader2/DExpectFormalArglistSsm.cpp
View file

@ -1,372 +0,0 @@
/* @file DExpectFormalArglistSsm.cpp
*
* @author Roland Conybeare, Jan 2026
*/
#include "ExpectFormalArglistSsm.hpp"
#include "ExpectFormalArgSsm.hpp"
#include <xo/expression2/Variable.hpp>
#include <xo/object2/Array.hpp>
#include <xo/printable2/Printable.hpp>
#include <xo/alloc2/GCObject.hpp>
#include <xo/alloc2/arena/IAllocator_DArena.hpp>
#include <xo/facet/FacetRegistry.hpp>
#include <xo/indentlog/scope.hpp>
namespace xo {
using xo::print::APrintable;
using xo::print::ppstate;
using xo::print::ppindentinfo;
using xo::mm::ACollector;
using xo::mm::AGCObject;
using xo::mm::AAllocator;
using xo::facet::FacetRegistry;
using xo::reflect::typeseq;
namespace scm {
const char *
formalarglstatetype_descr(formalarglstatetype x) {
switch (x) {
case formalarglstatetype::invalid:
return "invalid";
case formalarglstatetype::argl_0:
return "argl_0";
case formalarglstatetype::argl_1a:
return "argl_1a";
case formalarglstatetype::argl_1b:
return "argl_1b";
case formalarglstatetype::n_formalarglstatetype:
break;
}
return "?formalarglstatetype";
}
DExpectFormalArglistSsm::DExpectFormalArglistSsm(DArray * argl) : argl_{argl}
{}
DExpectFormalArglistSsm *
DExpectFormalArglistSsm::_make(DArena & arena)
{
obj<AAllocator,DArena> mm(&arena);
/* out-of-order so argl follows ssm in arena,
* consistent with any subsequent arglist realloc.
* Not a load-bearing choice however
*/
void * mem = arena.alloc(typeseq::id<DExpectFormalArglistSsm>(),
sizeof(DExpectFormalArglistSsm));
/* allocate room for 8 arguments (during parsing)
* will re-alloc to expand as needed
*/
DArray * argl = DArray::_empty(mm, 8);
return new (mem) DExpectFormalArglistSsm(argl);
}
obj<ASyntaxStateMachine,DExpectFormalArglistSsm>
DExpectFormalArglistSsm::make(DArena & arena)
{
obj<ASyntaxStateMachine,DExpectFormalArglistSsm> retval(_make(arena));
return retval;
}
void
DExpectFormalArglistSsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
p_psm->push_ssm(ckp, DExpectFormalArglistSsm::make(p_psm->parser_alloc()));
}
syntaxstatetype
DExpectFormalArglistSsm::ssm_type() const noexcept {
return syntaxstatetype::expect_formal_arglist;
}
std::string_view
DExpectFormalArglistSsm::get_expect_str() const {
switch (fastate_) {
case formalarglstatetype::invalid:
case formalarglstatetype::n_formalarglstatetype:
assert(false); // impossible
break;
case formalarglstatetype::argl_0:
return "leftparen";
case formalarglstatetype::argl_1a:
return "formal-name";
case formalarglstatetype::argl_1b:
return "comma|rightparen";
}
return "?expect";
}
void
DExpectFormalArglistSsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (tk.tk_type()) {
case tokentype::tk_leftparen:
this->on_leftparen_token(tk, p_psm);
return;
case tokentype::tk_comma:
this->on_comma_token(tk, p_psm);
return;
case tokentype::tk_rightparen:
this->on_rightparen_token(tk, p_psm);
return;
// all the not-yet-handled cases
case tokentype::tk_lambda:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_if:
case tokentype::tk_symbol:
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_quote:
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_cmple:
case tokentype::tk_cmpge:
case tokentype::tk_dot:
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_nil:
case tokentype::tk_type:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::on_token(tk, p_psm);
}
void
DExpectFormalArglistSsm::_accept_formal(obj<AAllocator> expr_alloc,
DArena & parser_alloc,
const DUniqueString * param_name,
TypeDescr param_type)
{
/* note: param_type can be nullptr */
TypeRef typeref
= TypeRef::dwim(TypeRef::prefix_type::from_chars("formal"), param_type);
DVariable * var = DVariable::make(expr_alloc,
param_name,
typeref);
// need AGCObject facet to use DArray here.
// May want to have gc feature that allows it to use
// FacetRegistry on memory that stores obj<AExpression,..>
//
// In this case doesn't matter since DExpectFormalArglistSsm not actually collected!
obj<AGCObject,DVariable> var_o(var);
if (argl_->size() == argl_->capacity()) {
// need to expand argl_ capacity.
// If DArena were to allow it (i.e. offer a realloc() feature,
// could do this in place since this SSM is at the top of the parser stack.
obj<AAllocator,DArena> mm(&parser_alloc);
DArray * argl_2x = DArray::_empty(mm, 2 * argl_->capacity());
for (DArray::size_type i = 0, n = argl_->size(); i < n; ++i) {
// TODO: prefer non-bounds-checked access here
argl_2x->push_back(mm, argl_->at(i));
}
// update in place
this->argl_ = argl_2x;
}
this->argl_->push_back(expr_alloc, var_o);
}
void
DExpectFormalArglistSsm::on_parsed_formal(const DUniqueString * param_name,
TypeDescr param_type,
ParserStateMachine * p_psm)
{
if (fastate_ == formalarglstatetype::argl_1a) {
this->fastate_ = formalarglstatetype::argl_1b;
this->_accept_formal(p_psm->expr_alloc(),
p_psm->parser_alloc(),
param_name,
param_type);
return;
}
Super::on_parsed_formal(param_name, param_type, p_psm);
}
void
DExpectFormalArglistSsm::on_parsed_formal_with_token(const DUniqueString * param_name,
TypeDescr param_type,
const Token & tk,
ParserStateMachine * p_psm)
{
if (fastate_ == formalarglstatetype::argl_1a) {
this->fastate_ = formalarglstatetype::argl_1b;
this->_accept_formal(p_psm->expr_alloc(),
p_psm->parser_alloc(),
param_name,
param_type);
this->on_token(tk, p_psm);
return;
}
Super::on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
void
DExpectFormalArglistSsm::on_leftparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (fastate_ == formalarglstatetype::argl_0) {
this->fastate_ = formalarglstatetype::argl_1a;
DExpectFormalArgSsm::start(p_psm);
return;
}
Super::on_token(tk, p_psm);
}
void
DExpectFormalArglistSsm::on_comma_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (fastate_ == formalarglstatetype::argl_1b) {
this->fastate_ = formalarglstatetype::argl_1a;
DExpectFormalArgSsm::start(p_psm);
return;
}
Super::on_token(tk, p_psm);
}
void
DExpectFormalArglistSsm::on_rightparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (fastate_ == formalarglstatetype::argl_1b) {
DArray * args = argl_;
p_psm->pop_ssm();
p_psm->on_parsed_formal_arglist(args);
return;
}
Super::on_token(tk, p_psm);
}
bool
DExpectFormalArglistSsm::pretty(const ppindentinfo & ppii) const
{
ppstate * pps = ppii.pps();
if (ppii.upto()) {
if (!pps->print_upto("<DExpectFormalArglistSsm"))
return false;
if (!pps->print_upto(xrefrtag("fastate", fastate_)))
return false;
if (!pps->print_upto(xrefrtag("expect", this->get_expect_str())))
return false;
if (!pps->print_upto(xrefrtag("n_args", argl_->size())))
return false;
for (size_type i_arg = 0; i_arg < argl_->size(); ++i_arg) {
char buf[80];
snprintf(buf, sizeof(buf), "arg[%u]", i_arg);
auto arg_gco = argl_->at(i_arg);
obj<APrintable> arg_pr
= FacetRegistry::instance().try_variant<APrintable,AGCObject>(arg_gco);
if (!pps->print_upto(xrefrtag(buf, arg_pr)))
return false;
}
pps->write(">");
return true;
} else {
pps->write("<DExpectFormalArglistSsm");
pps->newline_indent(ppii.ci1());
pps->pretty(refrtag("fastate", fastate_));
pps->newline_indent(ppii.ci1());
pps->pretty(refrtag("expect", this->get_expect_str()));
pps->newline_indent(ppii.ci1());
pps->pretty(refrtag("n_args", argl_->size()));
for (size_type i_arg = 0, n_arg = argl_->size(); i_arg < n_arg; ++i_arg) {
char buf[80];
snprintf(buf, sizeof(buf), "arg[%u]", i_arg);
auto arg_gco = argl_->at(i_arg);
obj<APrintable> arg_pr
= FacetRegistry::instance().try_variant<APrintable,AGCObject>(arg_gco);
pps->newline_indent(ppii.ci1());
pps->pretty(refrtag(buf, arg_pr));
}
pps->write(">");
return false;
}
}
void
DExpectFormalArglistSsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_child(reason, &argl_);
}
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectFormalArglistSsm.cpp */

216
xo-reader2/src/reader2/DExpectListTypeSsm.cpp
View file

@ -1,216 +0,0 @@
/** @file DExpectListTypeSsm.cpp
*
* @author Roland Conybeare, Mar 2026
**/
#include "ExpectListTypeSsm.hpp"
#include "ExpectTypeSsm.hpp"
#include "syntaxstatetype.hpp"
#include <xo/type/ListType.hpp>
#include <xo/alloc2/GCObject.hpp>
#include <string_view>
namespace xo {
namespace scm {
const char *
ListTypeXst::_descr(enum code x)
{
switch (x) {
case code::invalid: return "?invalid";
case code::type_0: return "type_0";
case code::type_1: return "type_1";
case code::type_2: return "type_2";
case code::type_3: return "type_3";
case code::N: break;
}
return "?ListTypeXst";
}
DExpectListTypeSsm::DExpectListTypeSsm() = default;
DExpectListTypeSsm *
DExpectListTypeSsm::_make(DArena & parser_mm)
{
void * mem = parser_mm.alloc_for<DExpectListTypeSsm>();
return new (mem) DExpectListTypeSsm();
}
obj<ASyntaxStateMachine, DExpectListTypeSsm>
DExpectListTypeSsm::make(DArena & parser_mm)
{
return obj<ASyntaxStateMachine,DExpectListTypeSsm>(_make(parser_mm));
}
void
DExpectListTypeSsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
p_psm->push_ssm(ckp, DExpectListTypeSsm::make(p_psm->parser_alloc()));
}
syntaxstatetype
DExpectListTypeSsm::ssm_type() const noexcept
{
return syntaxstatetype::expect_listtype;
}
std::string_view
DExpectListTypeSsm::get_expect_str() const noexcept
{
switch(state_.code()) {
case ListTypeXst::code::invalid:
case ListTypeXst::code::N:
break;
case ListTypeXst::code::type_0:
return "list";
case ListTypeXst::code::type_1:
return "leftangle";
case ListTypeXst::code::type_2:
return "type";
case ListTypeXst::code::type_3:
return "rightangle";
}
return "?ExpectListTypeSsm";
}
void
DExpectListTypeSsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (tk.tk_type()) {
case tokentype::tk_symbol:
this->on_symbol_token(tk, p_psm);
return;
case tokentype::tk_leftangle:
this->on_leftangle_token(tk, p_psm);
return;
case tokentype::tk_rightangle:
this->on_rightangle_token(tk, p_psm);
return;
// all the {not-yet-handled, illegal} cases
case tokentype::tk_leftbrace:
case tokentype::tk_rightbrace:
case tokentype::tk_quote:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_colon:
case tokentype::tk_singleassign:
case tokentype::tk_semicolon:
case tokentype::tk_invalid:
case tokentype::tk_string:
case tokentype::tk_f64:
case tokentype::tk_i64:
case tokentype::tk_bool:
case tokentype::tk_if:
case tokentype::tk_leftparen:
case tokentype::tk_rightparen:
case tokentype::tk_leftbracket:
case tokentype::tk_rightbracket:
case tokentype::tk_cmple:
case tokentype::tk_cmpge:
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_nil:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectListTypeSsm::on_symbol_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (state_.code() == ListTypeXst::code::type_0) {
this->state_ = ListTypeXst(ListTypeXst::code::type_1);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectListTypeSsm::on_leftangle_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (state_.code() == ListTypeXst::code::type_1) {
this->state_ = ListTypeXst(ListTypeXst::code::type_2);
DExpectTypeSsm::start(true /*corrected*/, p_psm);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectListTypeSsm::on_parsed_type(obj<AType> type, ParserStateMachine * p_psm)
{
if (state_.code() == ListTypeXst::code::type_2) {
this->state_ = ListTypeXst(ListTypeXst::code::type_3);
this->elt_type_ = type;
return;
}
Super::illegal_type(type, p_psm);
}
void
DExpectListTypeSsm::on_rightangle_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (state_.code() == ListTypeXst::code::type_3) {
obj<AType> result = DListType::make(p_psm->expr_alloc(),
elt_type_);
p_psm->pop_ssm();
p_psm->on_parsed_type(result);
return;
}
Super::illegal_token(tk, p_psm);
}
bool
DExpectListTypeSsm::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct
(ppii,
"DExpectListTypeSsm");
}
void
DExpectListTypeSsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_poly_child(reason, &elt_type_);
}
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectListTypeSsm.cpp */

233
xo-reader2/src/reader2/DExpectQArraySsm.cpp
View file

@ -1,233 +0,0 @@
/** @file DExpectQArraySsm.cpp
*
* @author Roland Conybeare, Mar 2026
**/
#include "ExpectQArraySsm.hpp"
#include "ExpectQLiteralSsm.hpp"
#include <xo/object2/Array.hpp>
#include <xo/alloc2/GCObject.hpp>
#include <xo/facet/FacetRegistry.hpp>
#include <xo/indentlog/print/pretty.hpp>
namespace xo {
using xo::print::APrintable;
using xo::facet::FacetRegistry;
using xo::mm::ACollector;
using xo::mm::AGCObject;
namespace scm {
const char *
QArrayXst::_descr(enum code x)
{
switch (x) {
case code::invalid: break;
case code::qarray_0: return "qarray_0";
case code::qarray_1a: return "qarray_1a";
case code::qarray_2: return "qarray_2";
case code::N: break;
}
return "?QArrayXst";
}
DExpectQArraySsm::DExpectQArraySsm() : state_{QArrayXst::code::qarray_0} {}
obj<ASyntaxStateMachine,DExpectQArraySsm>
DExpectQArraySsm::make(DArena & parser_mm)
{
return obj<ASyntaxStateMachine,DExpectQArraySsm>(_make(parser_mm));
}
DExpectQArraySsm *
DExpectQArraySsm::_make(DArena & parser_mm)
{
void * mem = parser_mm.alloc_for<DExpectQArraySsm>();
return new (mem) DExpectQArraySsm();
}
void
DExpectQArraySsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
p_psm->push_ssm(ckp, DExpectQArraySsm::make(p_psm->parser_alloc()));
}
syntaxstatetype
DExpectQArraySsm::ssm_type() const noexcept {
return syntaxstatetype::expect_qarray;
}
std::string_view
DExpectQArraySsm::get_expect_str() const {
switch (state_.code()) {
case QArrayXst::code::qarray_0:
return "leftparen";
case QArrayXst::code::qarray_1a:
return "qliteral|rightparen";
case QArrayXst::code::qarray_2:
return "(done)";
case QArrayXst::code::invalid:
case QArrayXst::code::N:
break;
}
return "?DExpectQArraySsm";
}
void
DExpectQArraySsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch(tk.tk_type())
{
case tokentype::tk_leftbracket:
this->on_leftbracket_token(tk, p_psm);
return;
case tokentype::tk_rightbracket:
this->on_rightbracket_token(tk, p_psm);
return;
case tokentype::tk_comma:
case tokentype::tk_lambda:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_if:
case tokentype::tk_symbol:
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_quote:
case tokentype::tk_leftparen:
case tokentype::tk_rightparen:
case tokentype::tk_leftbrace:
case tokentype::tk_rightbrace:
case tokentype::tk_leftangle:
case tokentype::tk_rightangle:
case tokentype::tk_cmple:
case tokentype::tk_cmpge:
case tokentype::tk_dot:
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_nil:
case tokentype::tk_type:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
}
void
DExpectQArraySsm::on_leftbracket_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (state_.code() == QArrayXst::code::qarray_0) {
this->state_ = QArrayXst(QArrayXst::code::qarray_1a);
this->array_ = DArray::_empty(p_psm->expr_alloc(),
8 /*heuristic starting capacity*/);
DExpectQLiteralSsm::start(p_psm,
false /*cxl_on_rightparen*/,
true /*cxl_on_rightbracket*/);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQArraySsm::on_rightbracket_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (state_.code() == QArrayXst::code::qarray_1a) {
this->state_ = QArrayXst(QArrayXst::code::qarray_2);
array_->shrink_to_fit();
obj<AGCObject> lit = obj<AGCObject,DArray>(array_);
p_psm->pop_ssm();
p_psm->on_quoted_literal(lit);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQArraySsm::on_quoted_literal(obj<AGCObject> lit,
ParserStateMachine * p_psm)
{
if(state_.code() == QArrayXst::code::qarray_1a) {
// append lit at the end of array_
{
assert(array_);
// ensure sufficient capacity
if (array_->size() == array_->capacity()) {
assert(array_->capacity() > 0);
/* reallocate w/ 2x capacity */
this->array_ = DArray::copy(p_psm->expr_alloc(),
array_,
2 * array_->capacity());
}
bool ok = array_->push_back(p_psm->expr_alloc(), lit);
if (!ok) assert(false);
}
// start syntax to receive next literal
DExpectQLiteralSsm::start(p_psm,
false /*cxl_on_rightparen*/,
true /*cxl_on_rightbracket*/);
return;
}
Super::illegal_quoted_literal(lit, p_psm);
}
bool
DExpectQArraySsm::pretty(const ppindentinfo & ppii) const
{
obj<AGCObject,DArray> array(array_);
auto array_pr = FacetRegistry::instance().variant<APrintable,AGCObject>(array);
return ppii.pps()->pretty_struct(ppii,
"DExpectQArraySsm",
refrtag("state", state_),
refrtag("expect", this->get_expect_str()),
refrtag("array", array_pr));
}
void
DExpectQArraySsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_child(reason, &array_);
}
}
}
/* end DExpectQArraySsm.cpp */

280
xo-reader2/src/reader2/DExpectQDictSsm.cpp
View file

@ -1,280 +0,0 @@
/** @file DExpectQDictSsm.cpp
*
* @author Roland Conybeare, Mar 2026
**/
#include "ExpectQDictSsm.hpp"
#include "ExpectQLiteralSsm.hpp"
#include <xo/stringtable2/String.hpp>
#include <xo/alloc2/GCObject.hpp>
namespace xo {
using xo::print::APrintable;
namespace scm {
const char *
QDictXst::_descr(enum code x)
{
switch (x) {
case code::invalid: break;
case code::qdict_0: return "qdict_0";
case code::qdict_1a: return "qdict_1a";
case code::qdict_1b: return "qdict_1b";
case code::qdict_1c: return "qdict_1c";
case code::qdict_1d: return "qdict_1d";
case code::qdict_2: return "qdict_2";
case code::N: break;
}
return "?QDictXst";
}
DExpectQDictSsm::DExpectQDictSsm() : state_{QDictXst::code::qdict_0} {}
obj<ASyntaxStateMachine,DExpectQDictSsm>
DExpectQDictSsm::make(DArena & parser_mm)
{
return obj<ASyntaxStateMachine,DExpectQDictSsm>(_make(parser_mm));
}
DExpectQDictSsm *
DExpectQDictSsm::_make(DArena & parser_mm)
{
void * mem = parser_mm.alloc_for<DExpectQDictSsm>();
return new (mem) DExpectQDictSsm();
}
void
DExpectQDictSsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
p_psm->push_ssm(ckp, DExpectQDictSsm::make(p_psm->parser_alloc()));
}
syntaxstatetype
DExpectQDictSsm::ssm_type() const noexcept {
return syntaxstatetype::expect_qdict;
}
std::string_view
DExpectQDictSsm::get_expect_str() const {
switch (state_.code()) {
case QDictXst::code::qdict_0:
return "leftbrace";
case QDictXst::code::qdict_1a:
return "symbol|rightbrace";
case QDictXst::code::qdict_1b:
return "colon";
case QDictXst::code::qdict_1c:
return "literal";
case QDictXst::code::qdict_1d:
return "semicolon|rightbrace";
case QDictXst::code::qdict_2:
return "(done)";
case QDictXst::code::invalid:
case QDictXst::code::N:
break;
}
return "?DExpectQDictSsm";
}
void
DExpectQDictSsm::on_leftbrace_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (state_.code() == QDictXst::code::qdict_0) {
constexpr DDictionary::size_type hint_cap = 8;
this->state_ = QDictXst(QDictXst::code::qdict_1a);
this->dict_ = DDictionary::empty(p_psm->expr_alloc(), hint_cap);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQDictSsm::on_rightbrace_token(const Token & tk,
ParserStateMachine * p_psm)
{
if ((state_.code() == QDictXst::code::qdict_1a)
|| (state_.code() == QDictXst::code::qdict_1d))
{
this->state_ = QDictXst(QDictXst::code::qdict_2);
obj<AGCObject> lit = obj<AGCObject,DDictionary>(dict_);
p_psm->pop_ssm();
p_psm->on_quoted_literal(lit);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQDictSsm::on_symbol_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (state_.code() == QDictXst::code::qdict_1a) {
this->state_ = QDictXst(QDictXst::code::qdict_1b);
this->key_ = DString::from_view(p_psm->expr_alloc(), std::string_view(tk.text()));
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQDictSsm::on_colon_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (state_.code() == QDictXst::code::qdict_1b) {
this->state_ = QDictXst(QDictXst::code::qdict_1c);
DExpectQLiteralSsm::start(p_psm,
false /*!cxl_on_rightparen*/);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQDictSsm::on_semicolon_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (state_.code() == QDictXst::code::qdict_1d) {
this->state_ = QDictXst(QDictXst::code::qdict_1a);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQDictSsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch(tk.tk_type())
{
case tokentype::tk_leftbrace:
this->on_leftbrace_token(tk, p_psm);
return;
case tokentype::tk_symbol:
this->on_symbol_token(tk, p_psm);
return;
case tokentype::tk_rightbrace:
this->on_rightbrace_token(tk, p_psm);
return;
case tokentype::tk_colon:
this->on_colon_token(tk, p_psm);
return;
case tokentype::tk_semicolon:
this->on_semicolon_token(tk, p_psm);
return;
case tokentype::tk_rightparen:
case tokentype::tk_comma:
case tokentype::tk_lambda:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_if:
case tokentype::tk_singleassign:
case tokentype::tk_string:
case tokentype::tk_f64:
case tokentype::tk_i64:
case tokentype::tk_bool:
case tokentype::tk_invalid:
case tokentype::tk_quote:
case tokentype::tk_leftparen:
case tokentype::tk_leftbracket:
case tokentype::tk_rightbracket:
case tokentype::tk_leftangle:
case tokentype::tk_rightangle:
case tokentype::tk_cmple:
case tokentype::tk_cmpge:
case tokentype::tk_dot:
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_nil:
case tokentype::tk_type:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQDictSsm::on_quoted_literal(obj<AGCObject> lit,
ParserStateMachine * p_psm)
{
if (state_.code() == QDictXst::code::qdict_1c) {
// adjoin (key,value) pair into dictionary
this->state_ = QDictXst(QDictXst::code::qdict_1d);
assert(dict_);
bool ok = dict_->upsert(p_psm->expr_alloc(), DDictionary::pair_type(key_, lit));
this->key_ = nullptr;
if (!ok) assert(false);
return;
}
Super::illegal_quoted_literal(lit, p_psm);
}
bool
DExpectQDictSsm::pretty(const ppindentinfo & ppii) const
{
obj<AGCObject,DDictionary> dict(dict_);
obj<APrintable,DDictionary> dict_pr(dict_);
return ppii.pps()->pretty_struct(ppii,
"DExpectQDictSsm",
refrtag("state", state_),
refrtag("expect", this->get_expect_str()),
refrtag("key", key_, key_),
refrtag("dict", dict_pr));
}
void
DExpectQDictSsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_child(reason, &key_);
gc.visit_child(reason, &dict_);
}
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectQDictSsm.cpp */

230
xo-reader2/src/reader2/DExpectQListSsm.cpp
View file

@ -1,230 +0,0 @@
/** @file DExpectQListSsm.cpp
*
* @author Roland Conybeare, Mar 2026
**/
#include "ExpectQListSsm.hpp"
#include "ExpectQLiteralSsm.hpp"
#include <xo/object2/List.hpp>
#include <xo/alloc2/GCObject.hpp>
#include <xo/facet/FacetRegistry.hpp>
#include <xo/indentlog/print/pretty.hpp>
namespace xo {
using xo::print::APrintable;
using xo::facet::FacetRegistry;
using xo::mm::AGCObject;
namespace scm {
const char *
QListXst::_descr(enum code x)
{
switch (x) {
case code::invalid: break;
case code::qlist_0: return "qlist_0";
case code::qlist_1a: return "qlist_1a";
case code::qlist_2: return "qlist_2";
case code::N: break;
}
return "?QListXst";
}
DExpectQListSsm::DExpectQListSsm() : state_{QListXst::code::qlist_0} {}
obj<ASyntaxStateMachine,DExpectQListSsm>
DExpectQListSsm::make(DArena & parser_mm)
{
return obj<ASyntaxStateMachine,DExpectQListSsm>(_make(parser_mm));
}
DExpectQListSsm *
DExpectQListSsm::_make(DArena & parser_mm)
{
void * mem = parser_mm.alloc_for<DExpectQListSsm>();
return new (mem) DExpectQListSsm();
}
void
DExpectQListSsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
p_psm->push_ssm(ckp, DExpectQListSsm::make(p_psm->parser_alloc()));
}
syntaxstatetype
DExpectQListSsm::ssm_type() const noexcept {
return syntaxstatetype::expect_qlist;
}
std::string_view
DExpectQListSsm::get_expect_str() const {
switch (state_.code()) {
case QListXst::code::qlist_0:
return "leftparen";
case QListXst::code::qlist_1a:
return "qliteral|rightparen";
case QListXst::code::qlist_2:
return "(done)";
case QListXst::code::invalid:
case QListXst::code::N:
break;
}
return "?DExpectQListSsm";
}
void
DExpectQListSsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch(tk.tk_type())
{
case tokentype::tk_leftparen:
this->on_leftparen_token(tk, p_psm);
return;
case tokentype::tk_rightparen:
this->on_rightparen_token(tk, p_psm);
return;
case tokentype::tk_comma:
case tokentype::tk_lambda:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_if:
case tokentype::tk_symbol:
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_quote:
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_cmple:
case tokentype::tk_cmpge:
case tokentype::tk_dot:
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_nil:
case tokentype::tk_type:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQListSsm::on_leftparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (state_.code() == QListXst::code::qlist_0) {
this->state_ = QListXst(QListXst::code::qlist_1a);
this->start_ = DList::_nil();
this->end_ = nullptr;
DExpectQLiteralSsm::start(p_psm,
true /*cxl_on_rightparen*/);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQListSsm::on_rightparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (state_.code() == QListXst::code::qlist_1a) {
this->state_ = QListXst(QListXst::code::qlist_2);
obj<AGCObject> lit = obj<AGCObject,DList>(start_);
p_psm->pop_ssm();
p_psm->on_quoted_literal(lit);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQListSsm::on_quoted_literal(obj<AGCObject> lit,
ParserStateMachine * p_psm)
{
if(state_.code() == QListXst::code::qlist_1a) {
// append lit at the end of list start_ .. end_
{
DList * new_last
= DList::_cons(p_psm->expr_alloc(), lit, DList::_nil());
if (this->end_) {
/* DExpectQListSsm owns {start_, end_} -> preserves acyclic property */
end_->_assign_rest(p_psm->expr_alloc(), new_last);
this->end_ = new_last;
} else {
this->start_ = DList::_cons(p_psm->expr_alloc(),
lit,
DList::_nil());
this->end_ = this->start_;
}
}
// start syntax to receive next literal
DExpectQLiteralSsm::start(p_psm,
true /*cxl_on_rightparen*/);
return;
}
Super::illegal_quoted_literal(lit, p_psm);
}
bool
DExpectQListSsm::pretty(const ppindentinfo & ppii) const
{
obj<AGCObject,DList> list(start_);
auto list_pr = FacetRegistry::instance().variant<APrintable,AGCObject>(list);
return ppii.pps()->pretty_struct(ppii,
"DExpectQListSsm",
refrtag("state", state_),
refrtag("expect", this->get_expect_str()),
refrtag("list", list_pr));
}
void
DExpectQListSsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_child(reason, &start_);
gc.visit_child(reason, &end_);
}
}
}
/* end DExpectQListSsm.cpp */

268
xo-reader2/src/reader2/DExpectQLiteralSsm.cpp
View file

@ -1,268 +0,0 @@
/* @file DExpectQLiteralSsm.cpp
*
* @author Roland Conybeare, Mar 2026
*/
#include "ExpectQLiteralSsm.hpp"
#include "ExpectQListSsm.hpp"
#include "ExpectQArraySsm.hpp"
#include "ExpectQDictSsm.hpp"
#include <xo/object2/Float.hpp>
#include <xo/object2/Integer.hpp>
#include <xo/stringtable2/String.hpp>
#include <xo/indentlog/scope.hpp>
namespace xo {
// using xo::print::APrintable;
// using xo::print::ppstate;
// using xo::print::ppindentinfo;
using xo::mm::AGCObject;
// using xo::mm::AAllocator;
// using xo::facet::FacetRegistry;
// using xo::reflect::typeseq;
namespace scm {
DExpectQLiteralSsm::DExpectQLiteralSsm(bool cxl_on_rightparen,
bool cxl_on_rightbracket)
: cxl_on_rightparen_{cxl_on_rightparen},
cxl_on_rightbracket_{cxl_on_rightbracket}
{}
DExpectQLiteralSsm *
DExpectQLiteralSsm::_make(DArena & arena,
bool cxl_on_rightparen,
bool cxl_on_rightbracket)
{
/* out-of-order so argl follows ssm in arena,
* consistent with any subsequent arglist realloc.
* Not a load-bearing choice however
*/
void * mem = arena.alloc_for<DExpectQLiteralSsm>();
return new (mem) DExpectQLiteralSsm(cxl_on_rightparen, cxl_on_rightbracket);
}
obj<ASyntaxStateMachine,DExpectQLiteralSsm>
DExpectQLiteralSsm::make(DArena & arena,
bool cxl_on_rightparen,
bool cxl_on_rightbracket)
{
obj<ASyntaxStateMachine,DExpectQLiteralSsm> retval(_make(arena,
cxl_on_rightparen,
cxl_on_rightbracket));
return retval;
}
void
DExpectQLiteralSsm::start(ParserStateMachine * p_psm,
bool cxl_on_rightparen,
bool cxl_on_rightbracket)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
p_psm->push_ssm(ckp, DExpectQLiteralSsm::make(p_psm->parser_alloc(),
cxl_on_rightparen,
cxl_on_rightbracket));
}
syntaxstatetype
DExpectQLiteralSsm::ssm_type() const noexcept {
return syntaxstatetype::expect_qliteral;
}
std::string_view
DExpectQLiteralSsm::get_expect_str() const
{
return "leftparen|leftbracket|leftbrace|string|f64|i64|bool";
}
void
DExpectQLiteralSsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (tk.tk_type()) {
case tokentype::tk_f64:
this->on_f64_token(tk, p_psm);
return;
case tokentype::tk_i64:
this->on_i64_token(tk, p_psm);
return;
case tokentype::tk_string:
this->on_string_token(tk, p_psm);
return;
case tokentype::tk_leftparen:
this->on_leftparen_token(tk, p_psm);
return;
case tokentype::tk_rightparen:
this->on_rightparen_token(tk, p_psm);
return;
case tokentype::tk_leftbracket:
this->on_leftbracket_token(tk, p_psm);
return;
case tokentype::tk_rightbracket:
this->on_rightbracket_token(tk, p_psm);
return;
case tokentype::tk_leftbrace:
this->on_leftbrace_token(tk, p_psm);
return;
case tokentype::tk_comma:
case tokentype::tk_lambda:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_if:
case tokentype::tk_symbol:
case tokentype::tk_colon:
case tokentype::tk_singleassign:
case tokentype::tk_bool:
case tokentype::tk_semicolon:
case tokentype::tk_invalid:
case tokentype::tk_quote:
case tokentype::tk_rightbrace:
case tokentype::tk_leftangle:
case tokentype::tk_rightangle:
case tokentype::tk_cmple:
case tokentype::tk_cmpge:
case tokentype::tk_dot:
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_nil:
case tokentype::tk_type:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::on_token(tk, p_psm);
}
void
DExpectQLiteralSsm::on_f64_token(const Token & tk,
ParserStateMachine * p_psm)
{
auto literal = DFloat::box<AGCObject>(p_psm->expr_alloc(),
tk.f64_value());
p_psm->pop_ssm();
p_psm->on_quoted_literal(literal);
}
void
DExpectQLiteralSsm::on_i64_token(const Token & tk,
ParserStateMachine * p_psm)
{
auto literal = DInteger::box<AGCObject>(p_psm->expr_alloc(),
tk.i64_value());
p_psm->pop_ssm();
p_psm->on_quoted_literal(literal);
}
void
DExpectQLiteralSsm::on_string_token(const Token & tk,
ParserStateMachine * p_psm)
{
auto literal = obj<AGCObject,DString>(DString::from_view(p_psm->expr_alloc(),
std::string_view(tk.text())));
p_psm->pop_ssm();
p_psm->on_quoted_literal(literal);
}
void
DExpectQLiteralSsm::on_leftparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
// replace self with specialized version for parsing a literal list
p_psm->pop_ssm();
DExpectQListSsm::start(p_psm);
p_psm->on_token(tk);
}
void
DExpectQLiteralSsm::on_rightparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (cxl_on_rightparen_) {
p_psm->pop_ssm();
p_psm->on_token(tk);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQLiteralSsm::on_leftbracket_token(const Token & tk,
ParserStateMachine * p_psm)
{
// replace self with specialized version for parsing a literal array
p_psm->pop_ssm();
DExpectQArraySsm::start(p_psm);
p_psm->on_token(tk);
}
void
DExpectQLiteralSsm::on_rightbracket_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (cxl_on_rightbracket_) {
p_psm->pop_ssm();
p_psm->on_token(tk);
return;
}
Super::illegal_token(tk, p_psm);
}
void
DExpectQLiteralSsm::on_leftbrace_token(const Token & tk,
ParserStateMachine * p_psm)
{
// replace self with specialized version for parsing a literal dict
p_psm->pop_ssm();
DExpectQDictSsm::start(p_psm);
p_psm->on_token(tk);
}
bool
DExpectQLiteralSsm::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct(ppii,
"DExpectQLiteralSsm",
refrtag("expect", this->get_expect_str()));
}
void
DExpectQLiteralSsm::visit_gco_children(VisitReason, obj<AGCObjectVisitor>) noexcept
{
// cxl_on_rightparen_, cxl_on_rightbracket_: POD, skip
}
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectQLiteralSsm.cpp */

158
xo-reader2/src/reader2/DExpectSymbolSsm.cpp
View file

@ -1,158 +0,0 @@
/** @file DExpectSymbolSsm.cpp
*
* @author Roland Conybeare, Aug 2024
**/
#include "DExpectSymbolSsm.hpp"
#include "ssm/ISyntaxStateMachine_DExpectSymbolSsm.hpp"
#include "SyntaxStateMachine.hpp"
#include "ParserStateMachine.hpp"
#include "syntaxstatetype.hpp"
#include <string_view>
//#include <regex>
namespace xo {
using xo::facet::with_facet;
using xo::facet::typeseq;
namespace scm {
DExpectSymbolSsm::DExpectSymbolSsm()
{}
DExpectSymbolSsm *
DExpectSymbolSsm::_make(DArena & mm)
{
void * mem = mm.alloc(typeseq::id<DExpectSymbolSsm>(),
sizeof(DExpectSymbolSsm));
return new (mem) DExpectSymbolSsm();
}
obj<ASyntaxStateMachine,DExpectSymbolSsm>
DExpectSymbolSsm::make(DArena & mm)
{
return obj<ASyntaxStateMachine,DExpectSymbolSsm>(_make(mm));
}
void
DExpectSymbolSsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
auto ssm = DExpectSymbolSsm::make(p_psm->parser_alloc());
p_psm->push_ssm(ckp, ssm);
}
syntaxstatetype
DExpectSymbolSsm::ssm_type() const noexcept
{
return syntaxstatetype::expect_symbol;
}
std::string_view
DExpectSymbolSsm::get_expect_str() const noexcept
{
return "symbol";
}
void
DExpectSymbolSsm::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:
this->on_symbol_token(tk, p_psm);
return;
// all the not-yet handled cases
case tokentype::tk_invalid:
case tokentype::tk_string:
case tokentype::tk_f64:
case tokentype::tk_i64:
case tokentype::tk_bool:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_if:
case tokentype::tk_singleassign:
case tokentype::tk_colon:
case tokentype::tk_semicolon:
case tokentype::tk_quote:
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_cmple:
case tokentype::tk_cmpge:
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_nil:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::on_token(tk, p_psm);
}
void
DExpectSymbolSsm::on_symbol_token(const Token & tk,
ParserStateMachine * p_psm)
{
#ifdef NOT_YET
constexpr bool c_debug_flag = false;
scope log(XO_DEBUG(c_debug_flag));
log && log(xtag("tk", tk));
assert(&p_psm->top_exprstate() == this);
#endif
/* have to do pop first, before sending symbol to
* the o.g. symbol-requester
*/
p_psm->pop_ssm();
p_psm->on_parsed_symbol(std::string_view(tk.text()));
}
bool
DExpectSymbolSsm::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct
(ppii,
"DExpectSymbolSsm"
//refrtag("member", member_)
);
}
void
DExpectSymbolSsm::visit_gco_children(VisitReason,
obj<AGCObjectVisitor>) noexcept
{
// no gc-aware members
}
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectSymbolSsm.cpp */

210
xo-reader2/src/reader2/DExpectTypeSsm.cpp
View file

@ -1,210 +0,0 @@
/** @file DExpectTypeSsm.cpp
*
* @author Roland Conybeare, Aug 2024
**/
#include "ExpectTypeSsm.hpp"
#include "ExpectListTypeSsm.hpp"
#include "SyntaxStateMachine.hpp"
#include <xo/type/AtomicType.hpp>
#include <xo/reflect/Reflect.hpp>
#include <xo/facet/facet_implementation.hpp>
#include <xo/reflectutil/typeseq.hpp>
#include <xo/indentlog/print/pretty.hpp>
#include <string_view>
namespace xo {
using xo::facet::with_facet;
using xo::reflect::Reflect;
using xo::reflect::TypeDescr;
using xo::reflect::typeseq;
namespace scm {
DExpectTypeSsm::DExpectTypeSsm(bool corrected)
: corrected_{corrected}
{}
DExpectTypeSsm *
DExpectTypeSsm::_make(DArena & mm, bool corrected)
{
void * mem = mm.alloc(typeseq::id<DArena>(),
sizeof(DArena));
return new (mem) DExpectTypeSsm(corrected);
}
obj<ASyntaxStateMachine,DExpectTypeSsm>
DExpectTypeSsm::make(DArena & mm, bool corrected)
{
return obj<ASyntaxStateMachine,DExpectTypeSsm>(_make(mm, corrected));
}
void
DExpectTypeSsm::start(bool corrected,
ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
auto ssm = DExpectTypeSsm::make(p_psm->parser_alloc(), corrected);
p_psm->push_ssm(ckp, ssm);
}
syntaxstatetype
DExpectTypeSsm::ssm_type() const noexcept
{
return syntaxstatetype::expect_type;
}
std::string_view
DExpectTypeSsm::get_expect_str() const noexcept
{
return "typename";
}
void
DExpectTypeSsm::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:
this->on_symbol_token(tk, p_psm);
break;
// all the not-yet handled cases
case tokentype::tk_invalid:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_if:
case tokentype::tk_f64:
case tokentype::tk_i64:
case tokentype::tk_bool:
case tokentype::tk_string:
case tokentype::tk_quote:
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_cmple:
case tokentype::tk_cmpge:
case tokentype::tk_dot:
case tokentype::tk_comma:
case tokentype::tk_colon:
case tokentype::tk_semicolon:
case tokentype::tk_doublecolon:
case tokentype::tk_assign:
case tokentype::tk_singleassign:
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_nil:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
p_psm->illegal_input_on_token("DExpectTypeSsm::on_token",
tk,
this->get_expect_str());
break;
}
}
void
DExpectTypeSsm::on_symbol_token(const Token & tk,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
if (corrected_) {
obj<AType> type;
obj mm = p_psm->expr_alloc();
if (tk.text() == "list") {
/* replace top ssm with specialized list-type ssm parser */
p_psm->pop_ssm();
DExpectListTypeSsm::start(p_psm);
p_psm->on_token(tk);
} else {
if (tk.text() == "unit")
type = DAtomicType::make(mm, Metatype::t_unit());
if (tk.text() == "bool")
type = DAtomicType::make(mm, Metatype::t_bool());
else if (tk.text() == "str")
type = DAtomicType::make(mm, Metatype::t_str());
else if (tk.text() == "f64")
type = DAtomicType::make(mm, Metatype::t_f64());
else if(tk.text() == "f32")
type = DAtomicType::make(mm, Metatype::t_f32());
else if(tk.text() == "i16")
type = DAtomicType::make(mm, Metatype::t_i16());
else if(tk.text() == "i32")
type = DAtomicType::make(mm, Metatype::t_i32());
else if(tk.text() == "i64")
type = DAtomicType::make(mm, Metatype::t_i64());
p_psm->pop_ssm();
p_psm->on_parsed_type(type);
}
} else {
TypeDescr td = nullptr;
/* TODO: replace with typetable lookup */
if (tk.text() == "bool")
td = Reflect::require<bool>();
else if (tk.text() == "str")
td = Reflect::require<std::string>();
else if (tk.text() == "f64")
td = Reflect::require<double>();
else if(tk.text() == "f32")
td = Reflect::require<float>();
else if(tk.text() == "i16")
td = Reflect::require<std::int16_t>();
else if(tk.text() == "i32")
td = Reflect::require<std::int32_t>();
else if(tk.text() == "i64")
td = Reflect::require<std::int64_t>();
if (!td) {
Super::on_token(tk, p_psm);
return;
}
p_psm->pop_ssm();
p_psm->on_parsed_typedescr(td);
}
}
bool
DExpectTypeSsm::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct
(ppii,
"DExpectTypeSsm");
}
void
DExpectTypeSsm::visit_gco_children(VisitReason,
obj<AGCObjectVisitor>) noexcept
{
// corrected_: POD, skip
}
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectTypeSsm.cpp */

140
xo-reader2/src/reader2/DGlobalEnv.cpp
View file

@ -1,140 +0,0 @@
/** @file DGlobalEnv.cpp
*
* @author Roland Conybeare, Feb 2026
**/
#include "GlobalEnv.hpp"
#include <xo/expression2/GlobalSymtab.hpp>
#include <xo/object2/Array.hpp>
namespace xo {
using xo::mm::ACollector;
using xo::mm::AAllocator;
using xo::mm::AGCObject;
namespace scm {
DGlobalEnv::DGlobalEnv(DGlobalSymtab * symtab, DArray * values)
: symtab_{symtab}, values_{values}
{}
DGlobalEnv *
DGlobalEnv::_make(obj<AAllocator> mm,
DGlobalSymtab * symtab)
{
DArray * values = DArray::_empty(mm, symtab->var_capacity());
void * mem = mm.alloc_for<DGlobalSymtab>();
return new (mem) DGlobalEnv(symtab, values);
}
obj<AGCObject>
DGlobalEnv::lookup_value(Binding ix) const noexcept
{
if (!ix.is_global()) {
assert(false);
return obj<AGCObject>();
}
if (ix.j_slot() >= static_cast<int32_t>(values_->size())) {
assert(false);
return obj<AGCObject>();
}
return (*values_)[ix.j_slot()];
}
void
DGlobalEnv::assign_value(obj<AAllocator> mm, Binding ix, obj<AGCObject> x)
{
scope log(XO_DEBUG(false),
xtag("ix.j_slot", ix.j_slot()),
xtag("values.cap", values_->capacity()));
assert(ix.is_global());
if (ix.j_slot() >= static_cast<int32_t>(values_->size())) {
// Control will come here in interpreter as new definitions are introduced.
// After seeing
// def foo = 1.2345;
// introducing new symbol foo:
// GlobalSymtab extends to include foo without this GlobalEnv
// knowing about it.
if (ix.j_slot() + 1 > static_cast<int32_t>(values_->capacity())) {
// realloc global array for more size
size_t cap_2x = 2 * values_->capacity();
while (cap_2x < static_cast<size_t>(ix.j_slot() + 1))
cap_2x = 2 * cap_2x;
DArray * values_2x = DArray::copy(mm, values_, cap_2x);
assert(values_2x);
if (values_2x) {
log && log("STUB: need write barrier for GC (also in GlobalSymtab!)");
this->values_ = values_2x;
} else {
return;
}
}
/** expand size sot that j_slot is valid **/
values_->resize(ix.j_slot() + 1);
}
values_->assign_at(mm,
ix.j_slot(),
x);
}
DVariable *
DGlobalEnv::_upsert_value(obj<AAllocator> mm,
const DUniqueString * sym,
TypeDescr td,
obj<AGCObject> value)
{
DVariable * var
= DVariable::make(mm, sym, TypeRef::resolved(td));
assert(var);
symtab_->upsert_variable(mm, var);
this->assign_value(mm, var->path(), value);
return var;
}
// ----- AGCObject facet -----
DGlobalEnv *
DGlobalEnv::gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept
{
return gc.std_move_for<DGlobalEnv>(this);
}
void
DGlobalEnv::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_child(reason, &symtab_);
gc.visit_child(reason, &values_);
}
// ----- APrintable facet -----
bool
DGlobalEnv::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct
(ppii,
"DGlobalEnv",
refrtag("n_vars", symtab_->n_vars()));
}
} /*namespace scm*/
} /*namespace xo*/
/* end DGlobalEnv.cpp */

519
xo-reader2/src/reader2/DIfElseSsm.cpp
View file

@ -1,519 +0,0 @@
/** @file DIfElseSsm.cpp
*
* @author Roland Conybeare, Jul 2025
**/
#include "ifelse/DIfElseSsm.hpp"
#include "ifelse/ISyntaxStateMachine_DIfElseSsm.hpp"
#include "DefineSsm.hpp"
//#include "define/IPrintable_DDefineSsm.hpp"
#include "DExpectExprSsm.hpp"
#include <xo/expression2/detail/IPrintable_DIfElseExpr.hpp>
#include <xo/printable2/Printable.hpp>
#include <xo/alloc2/GCObject.hpp>
#include <xo/facet/FacetRegistry.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);
}
obj<ASyntaxStateMachine,DIfElseSsm>
DIfElseSsm::make(DArena & mm,
DIfElseExpr * ifelse_expr)
{
return obj<ASyntaxStateMachine,DIfElseSsm>(_make(mm, ifelse_expr));
}
void
DIfElseSsm::start(DArena & parser_mm,
obj<AAllocator> expr_mm,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
DArena::Checkpoint ckp = parser_mm.checkpoint();
DIfElseExpr * if_expr = DIfElseExpr::_make_empty(expr_mm);
auto ssm = DIfElseSsm::make(parser_mm, if_expr);
p_psm->push_ssm(ckp, 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:
case tokentype::tk_deftype:
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_semicolon:
this->on_semicolon_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_invalid:
case tokentype::tk_quote:
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_cmple:
case tokentype::tk_cmpge:
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_nil:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
DSyntaxStateMachine<DIfElseSsm>::on_token(tk, p_psm);
}
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);
return;
}
DSyntaxStateMachine<DIfElseSsm>::on_token(tk, p_psm);
}
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);
return;
}
DSyntaxStateMachine<DIfElseSsm>::on_token(tk, p_psm);
}
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);
return;
}
DSyntaxStateMachine<DIfElseSsm>::on_token(tk, p_psm);
}
#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);
}
#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;
}
DSyntaxStateMachine<DIfElseSsm>::on_token(tk, p_psm);
}
#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;
}
DSyntaxStateMachine<DIfElseSsm>::on_parsed_expression(expr, p_psm);
}
void
DIfElseSsm::on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
// TODO: may consider allowing if-else to terminate on other particular tokens
// e.g. ')'
switch (ifstate_) {
case ifexprstatetype::invalid:
case ifexprstatetype::N:
// impossible
assert(false);
break;
case ifexprstatetype::if_0:
// also unreachable
break;
case ifexprstatetype::if_1:
// only ok if tk-type is tk_then.
if (tk.tk_type() == tokentype::tk_then) {
// advance to if_2 -then-> if_3
this->on_parsed_expression(expr, p_psm);
this->on_token(tk, p_psm);
return;
}
break;
case ifexprstatetype::if_2:
// illegal, not expecting expression
break;
case ifexprstatetype::if_3:
// incoming expr argument is sufficient to complete this if-else
// but may continue on else-token
if (tk.tk_type() == tokentype::tk_else) {
// advance to if_4 -else-> if_5
this->on_parsed_expression(expr, p_psm);
this->on_token(tk, p_psm);
return;
} else if ((tk.tk_type() == tokentype::tk_semicolon)
|| (tk.tk_type() == tokentype::tk_rightparen)
|| (tk.tk_type() == tokentype::tk_rightbrace)) {
this->on_parsed_expression(expr, p_psm);
p_psm->pop_ssm();
p_psm->on_parsed_expression_with_token(if_expr_, tk);
return;
}
break;
case ifexprstatetype::if_4:
// illegal, not expecting expression
break;
case ifexprstatetype::if_5:
// incoming expr argument completes this if-else
// advance to if_6
if ((tk.tk_type() == tokentype::tk_semicolon)
|| (tk.tk_type() == tokentype::tk_rightparen)
|| (tk.tk_type() == tokentype::tk_rightbrace))
{
// attaches expr as else- branch
this->on_parsed_expression(expr, p_psm);
p_psm->pop_ssm();
p_psm->on_parsed_expression_with_token(if_expr_, tk);
return;
}
break;
case ifexprstatetype::if_6:
// illegal, not expecting expression
break;
}
Super::on_parsed_expression_with_token(expr, tk, p_psm);
}
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));
}
void
DIfElseSsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_poly_child(reason, &if_expr_);
}
} /*namespace scm*/
} /*namespace xo*/

489
xo-reader2/src/reader2/DLambdaSsm.cpp
View file

@ -1,489 +0,0 @@
/** @file DLambdaSsm.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "LambdaSsm.hpp"
#include "ExpectFormalArglistSsm.hpp"
#include "DExpectTypeSsm.hpp"
#include "DExpectExprSsm.hpp"
#include "ParserStateMachine.hpp"
#include "syntaxstatetype.hpp"
#include <xo/expression2/detail/IExpression_DLambdaExpr.hpp>
#include <xo/expression2/Variable.hpp>
//#include <xo/expression2/symtab/ISymbolTable_DLocalSymtab.hpp>
#include <xo/printable2/Printable.hpp>
#include <xo/alloc2/GCObject.hpp>
#include <xo/facet/FacetRegistry.hpp>
#include <xo/arena/DArena.hpp>
namespace xo {
using xo::print::APrintable;
using xo::mm::AAllocator;
using xo::mm::AGCObject;
using xo::facet::FacetRegistry;
using xo::reflect::typeseq;
namespace scm {
const char *
lambdastatetype_descr(lambdastatetype x) {
switch(x) {
case lambdastatetype::invalid: return "invalid";
case lambdastatetype::lm_0: return "lm_0";
case lambdastatetype::lm_1: return "lm_1";
case lambdastatetype::lm_2: return "lm_2";
case lambdastatetype::lm_3: return "lm_3";
case lambdastatetype::lm_4: return "lm_4";
case lambdastatetype::lm_5: return "lm_5";
default: break;
}
return "???lambdastatetype";
}
// ----- lambda_xs - ----
DLambdaSsm::DLambdaSsm()
{}
obj<ASyntaxStateMachine,DLambdaSsm>
DLambdaSsm::make(DArena & parser_mm)
{
return obj<ASyntaxStateMachine,DLambdaSsm>(_make(parser_mm));
}
DLambdaSsm *
DLambdaSsm::_make(DArena & parser_mm)
{
void * mem = parser_mm.alloc(typeseq::id<DLambdaSsm>(),
sizeof(DLambdaSsm));
return new (mem) DLambdaSsm();
}
void
DLambdaSsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
p_psm->push_ssm(ckp, DLambdaSsm::make(p_psm->parser_alloc()));
p_psm->on_token(Token::lambda_token());
}
syntaxstatetype
DLambdaSsm::ssm_type() const noexcept
{
return syntaxstatetype::lambdaexpr;
}
std::string_view
DLambdaSsm::get_expect_str() const noexcept
{
/*
* lambda (x : f64) -> f64 { ... } ;
* ^ ^ ^ ^ ^ ^
* | | | | | lm_5
* | | | | lm_4:expect_expression
* | | | lm_3
* | | lm_2
* | lm_1:
* expect_expression
*/
switch (this->lmstate_) {
case lambdastatetype::invalid:
case lambdastatetype::n_lambdastatetype:
assert(false); // impossible
break;
case lambdastatetype::lm_0:
return "lambda";
case lambdastatetype::lm_1:
return "lambda-params";
case lambdastatetype::lm_2:
return "yields|lambda-body";
case lambdastatetype::lm_3:
return "type";
case lambdastatetype::lm_4:
return "lambda-body";
case lambdastatetype::lm_5:
return "semicolon";
}
return "?expect";
}
void
DLambdaSsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (tk.tk_type()) {
case tokentype::tk_lambda:
this->on_lambda_token(tk, p_psm);
return;
case tokentype::tk_yields:
this->on_yields_token(tk, p_psm);
return;
case tokentype::tk_leftbrace:
this->on_leftbrace_token(tk, p_psm);
return;
// all the not-yet-handled cases
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_if:
case tokentype::tk_symbol:
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_quote:
case tokentype::tk_leftparen:
case tokentype::tk_rightparen:
case tokentype::tk_leftbracket:
case tokentype::tk_rightbracket:
case tokentype::tk_rightbrace:
case tokentype::tk_leftangle:
case tokentype::tk_rightangle:
case tokentype::tk_cmple:
case tokentype::tk_cmpge:
case tokentype::tk_dot:
case tokentype::tk_comma:
case tokentype::tk_doublecolon:
case tokentype::tk_assign:
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_nil:
case tokentype::tk_type:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::on_token(tk, p_psm);
}
void
DLambdaSsm::on_lambda_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (lmstate_ == lambdastatetype::lm_0) {
this->lmstate_ = lambdastatetype::lm_1;
DExpectFormalArglistSsm::start(p_psm);
return;
}
Super::on_token(tk, p_psm);
}
void
DLambdaSsm::on_yields_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (lmstate_ == lambdastatetype::lm_2) {
this->lmstate_ = lambdastatetype::lm_3;
DExpectTypeSsm::start(false /*!corrected*/, p_psm);
/* control reenters via .on_parsed_typedescr() */
return;
}
Super::on_token(tk, p_psm);
}
void
DLambdaSsm::on_leftbrace_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (lmstate_ == lambdastatetype::lm_2) {
// control here when leftbrace immediately follows
// formal param list.
// Otherwise leftbrace arrives in DExpectExprSsm
// pushed via on_parsed_typedescr()
this->lmstate_ = lambdastatetype::lm_4;
DExpectExprSsm::start(p_psm);
// precharge ssm for body with leftbrace
p_psm->on_token(Token::leftbrace_token());
return;
}
Super::on_token(tk, p_psm);
}
void
DLambdaSsm::on_parsed_typedescr(TypeDescr td,
ParserStateMachine * p_psm)
{
if (lmstate_ == lambdastatetype::lm_3) {
this->lmstate_ = lambdastatetype::lm_4;
this->explicit_return_td_ = td;
this->lambda_td_ = DLambdaExpr::assemble_lambda_td(local_symtab_, td);
DExpectExprSsm::start(p_psm);
return;
}
Super::on_parsed_typedescr(td, p_psm);
}
#ifdef NOT_YET
void
lambda_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
this->on_expr(expr, p_psm);
this->on_semicolon_token(token_type::semicolon(), p_psm);
}
void
lambda_xs::on_leftbrace_token(const token_type & tk,
parserstatemachine * p_psm)
{
constexpr const char * c_self_name = "lambda_xs::on_leftbrace_token";
if (lmxs_type_ == lambdastatetype::lm_2)
this->lmxs_type_ = lambdastatetype::lm_4;
if (lmxs_type_ == lambdastatetype::lm_4) {
expect_expr_xs::start(p_psm);
/* want { to start expr sequence, that finishes on matching } */
p_psm->on_leftbrace_token(token_type::leftbrace());
} else {
this->illegal_input_on_token(c_self_name, tk, this->get_expect_str(), p_psm);
}
}
#endif
void
DLambdaSsm::on_parsed_formal_arglist(DArray * arglist,
ParserStateMachine * p_psm)
{
if (lmstate_ == lambdastatetype::lm_1) {
this->lmstate_ = lambdastatetype::lm_2;
/// something with top env frame ?
/// TODO: arena-friendly non-gc-aware vector;
// use instead of DArray for arglist.
// something like DTypedArray<T>
/// create LocalSymtab from arglist
DLocalSymtab * symtab
= DLocalSymtab::_make_empty(p_psm->expr_alloc(),
p_psm->local_symtab(),
arglist->size(),
0 /*ntypes*/);
assert(symtab);
for (DArray::size_type i = 0, n = arglist->size(); i < n; ++i) {
obj<AGCObject> param = arglist->at(i);
// TODO:
// sad! runtime poly conversion from obj<AGCObject>
// We need this because of (suboptimally) using DArray to store arglist
obj<AExpression> param_expr
= FacetRegistry::instance().variant<AExpression,AGCObject>(param);
obj<AExpression,DVariable> param_var
= obj<AExpression,DVariable>::from(param_expr);
assert(param_expr.data());
assert(param_var.data());
Binding b = symtab->append_var(p_psm->expr_alloc(),
param_var.data()->name(),
param_var.data()->typeref());
if (!b.is_local()) assert(false);
this->local_symtab_ = symtab;
}
// stash env frame: records local variables while we handle lambda body
p_psm->push_local_symtab(symtab);
// control reenters via .on_colon_token() / .on_leftbrace_token()
return;
}
Super::on_parsed_formal_arglist(arglist, p_psm);
#ifdef OBSOLETE
p_psm->illegal_parsed_formal_arglist("DLambdaSsm::on_parsed_formal_arglist",
arglist,
this->get_expect_str());
#endif
}
void
DLambdaSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
if (lmstate_ == lambdastatetype::lm_4) {
this->lmstate_ = lambdastatetype::lm_5;
this->body_ = expr;
// assemble lambda
auto prefix = TypeRef::prefix_type::from_chars("lm");
TypeRef tref = TypeRef::dwim(prefix, nullptr);
const DUniqueString * name = p_psm->gensym("lambda");
auto lm_expr = obj<AExpression,DLambdaExpr>
(DLambdaExpr::make(p_psm->expr_alloc(),
tref,
name,
local_symtab_,
body_));
p_psm->pop_ssm(); // this lambda
p_psm->on_parsed_expression(lm_expr);
return;
}
Super::on_parsed_expression(expr, p_psm);
}
void
DLambdaSsm::on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk,
ParserStateMachine * p_psm)
{
Super::on_parsed_expression_with_token(expr, tk, p_psm);
}
#ifdef NOT_YET
void
lambda_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
constexpr const char * c_self_name = "lambda_xs::on_expr";
if (lmxs_type_ == lambdastatetype::lm_4) {
this->lmxs_type_ = lambdastatetype::lm_5;
this->body_ = expr.promote();
} else {
this->illegal_input_on_expr(c_self_name, expr, this->get_expect_str(), p_psm);
}
}
void
lambda_xs::on_semicolon_token(const token_type & tk,
parserstatemachine * p_psm)
{
if (lmxs_type_ == lambdastatetype::lm_5) {
/* done! */
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
std::string name = Variable::gensym("lambda");
/* top env frame recorded arguments to this lambda */
p_psm->pop_envframe();
rp<Lambda> lm;
/* TODO: unify explicit_return_td_ with body_ */
if (lambda_td_) {
lm = Lambda::make(name, lambda_td_, local_env_, body_);
} else {
lm = Lambda::make_from_env(name, local_env_,
explicit_return_td_, body_);
}
p_psm->top_exprstate().on_expr(lm, p_psm);
p_psm->top_exprstate().on_semicolon_token(tk, p_psm);
return;
}
exprstate::on_semicolon_token(tk, p_psm);
}
void
lambda_xs::on_f64_token(const token_type & tk,
parserstatemachine * p_psm)
{
constexpr const char * c_self_name = "lambda_xs::on_f64_token";
/* f64 literal can begin lambda body, otherwise illegal.
* for example:
* def foo = lambda (x: bool) 3.14;
*/
if (lmxs_type_ == lambdastatetype::lm_2) {
/* omitting return type.
* omitting left brace.
*/
this->lmxs_type_ = lambdastatetype::lm_4;
expect_expr_xs::start(p_psm);
p_psm->on_f64_token(tk);
} else {
this->illegal_input_on_token(c_self_name, tk, this->get_expect_str(), p_psm);
}
}
// TODO: on_i64_token, on_bool token
#endif
bool
DLambdaSsm::pretty(const ppindentinfo & ppii) const
{
obj<APrintable> body
= FacetRegistry::instance().try_variant<APrintable,
AExpression>(body_);
if (body) {
return ppii.pps()->pretty_struct
(ppii,
"DLambdaSsm",
refrtag("lmstate", lmstate_),
refrtag("expect", this->get_expect_str()),
refrtag("body", body));
} else {
return ppii.pps()->pretty_struct
(ppii,
"DLambdaSsm",
refrtag("lmstate", lmstate_),
refrtag("expect", this->get_expect_str()));
}
}
void
DLambdaSsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_child(reason, &local_symtab_);
// explicit_return_td not gcobject
// lambda_td not gcobject
gc.visit_poly_child(reason, &body_);
gc.visit_poly_child(reason, &parent_symtab_);
}
} /*namespace scm*/
} /*namespace xo*/
/* end DLambdaSsm.cpp */

470
xo-reader2/src/reader2/DParenSsm.cpp
View file

@ -1,470 +0,0 @@
/** @file DParenSsm.cpp
*
* @author Roland Conybeare, Feb 2026
**/
#include "ParenSsm.hpp"
#include "ExpectExprSsm.hpp"
#include "syntaxstatetype.hpp"
#include <xo/alloc2/GCObject.hpp>
#include <string_view>
namespace xo {
using xo::facet::with_facet;
using xo::facet::typeseq;
namespace scm {
extern const char *
parenexprstatetype_descr(parenexprstatetype x)
{
switch(x) {
case parenexprstatetype::invalid: return "invalid";
case parenexprstatetype::lparen_0: return "lparen_0";
case parenexprstatetype::lparen_1: return "lparen_1";
case parenexprstatetype::lparen_2: return "lparen_2";
case parenexprstatetype::N: break;
}
return "???parenexprstatetype";
}
std::ostream &
operator<<(std::ostream & os, parenexprstatetype x) {
os << parenexprstatetype_descr(x);
return os;
}
DParenSsm::DParenSsm()
: parenstate_(parenexprstatetype::lparen_0),
expr_{}
{}
DParenSsm *
DParenSsm::_make(DArena & mm)
{
void * mem = mm.alloc(typeseq::id<DParenSsm>(),
sizeof(DParenSsm));
return new (mem) DParenSsm();
}
obj<ASyntaxStateMachine,DParenSsm>
DParenSsm::make(DArena & mm)
{
return obj<ASyntaxStateMachine,DParenSsm>(_make(mm));
}
void
DParenSsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
auto paren_ssm = DParenSsm::make(p_psm->parser_alloc());
p_psm->push_ssm(ckp, paren_ssm);
}
syntaxstatetype
DParenSsm::ssm_type() const noexcept
{
return syntaxstatetype::paren;
}
std::string_view
DParenSsm::get_expect_str() const noexcept
{
switch (this->parenstate_) {
case parenexprstatetype::invalid:
case parenexprstatetype::N:
break;
case parenexprstatetype::lparen_0: return "leftparen";
case parenexprstatetype::lparen_1: return "expression";
case parenexprstatetype::lparen_2: return "rightparen";
}
return "???parenexprstatetype";
}
void
DParenSsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (tk.tk_type()) {
case tokentype::tk_leftparen:
this->on_leftparen_token(tk, p_psm);
return;
case tokentype::tk_rightparen:
this->on_rightparen_token(tk, p_psm);
return;
// all the not-yet handled cases
case tokentype::tk_symbol:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_colon:
case tokentype::tk_singleassign:
case tokentype::tk_semicolon:
case tokentype::tk_invalid:
case tokentype::tk_string:
case tokentype::tk_f64:
case tokentype::tk_i64:
case tokentype::tk_bool:
case tokentype::tk_if:
case tokentype::tk_quote:
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_cmple:
case tokentype::tk_cmpge:
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_nil:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::on_token(tk, p_psm);
}
void
DParenSsm::on_leftparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (parenstate_ == parenexprstatetype::lparen_0) {
this->parenstate_ = parenexprstatetype::lparen_1;
/** 1. allow_defs=false not allowing definitions immediately
* within a parenthesized expression.
* e.g.
* (def y : i64 = 4; x + y) // nope
* 2. cxl_on_rightparen=false expression _must_ be followed
* by rightparen. empty parentheses '()'
* do not denote anything, in expression context
**/
DExpectExprSsm::start(p_psm);
return;
}
Super::on_token(tk, p_psm);
}
#ifdef OBSOLETE
void
paren_xs::start(parserstatemachine * p_psm)
{
p_psm->push_exprstate(paren_xs::make());
expect_expr_xs::start(p_psm);
}
bool
paren_xs::admits_rightparen() const {
switch (parenxs_type_) {
case parenexprstatetype::lparen_0:
/* unreachable */
assert(false);
return false;
case parenexprstatetype::lparen_1:
return true;
case parenexprstatetype::invalid:
case parenexprstatetype::n_parenexprstatetype:
/* unreachable */
assert(false);
return false;
}
return false;
}
bool
paren_xs::admits_f64() const {
switch (parenxs_type_) {
case parenexprstatetype::lparen_0:
return true;
case parenexprstatetype::lparen_1:
return false;
case parenexprstatetype::invalid:
case parenexprstatetype::n_parenexprstatetype:
/* unreachable */
assert(false);
return false;
}
return false;
}
void
paren_xs::on_def_token(const token_type & tk,
parserstatemachine * /*p_psm*/)
{
constexpr const char * c_self_name = "paren_xs::on_def";
this->illegal_input_error(c_self_name, tk);
}
void
paren_xs::on_symbol_token(const token_type & /*tk*/,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
log && log(xtag("exstype", p_psm->top_exprstate().exs_type()));
//constexpr const char * self_name = "paren_xs::on_symbol";
/* TODO: lparen_0: treat as variable reference */
assert(false);
}
void
paren_xs::on_typedescr(TypeDescr /*td*/,
parserstatemachine * /*p_psm*/)
{
assert(false);
return;
}
void
paren_xs::on_colon_token(const token_type & tk,
parserstatemachine * /*p_psm*/)
{
constexpr const char * c_self_name = "paren_xs::on_colon";
this->illegal_input_error(c_self_name, tk);
}
void
paren_xs::on_semicolon_token(const token_type & tk,
parserstatemachine * /*p_psm*/)
{
constexpr const char * c_self_name = "paren_xs::on_semicolon";
this->illegal_input_error(c_self_name, tk);
}
void
paren_xs::on_singleassign_token(const token_type & tk,
parserstatemachine * /*p_psm*/)
{
constexpr const char * c_self_name = "paren_xs::on_singleassign";
this->illegal_input_error(c_self_name, tk);
}
void
paren_xs::on_leftparen_token(const token_type & tk,
parserstatemachine * /*p_psm*/)
{
constexpr const char * c_self_name = "paren_xs::on_leftparen";
this->illegal_input_error(c_self_name, tk);
}
#endif
void
DParenSsm::on_rightparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (this->parenstate_ == parenexprstatetype::lparen_2) {
// parenthesized expression successfully parsed
p_psm->pop_ssm();
p_psm->on_parsed_expression(this->expr_);
return;
}
Super::on_token(tk, p_psm);
}
#ifdef NOT_YET
void
paren_xs::on_rightparen_token(const token_type & tk,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
constexpr const char * c_self_name = "paren_xs::on_rightparen";
if (!this->admits_rightparen())
{
this->illegal_input_error(c_self_name, tk);
}
if (this->parenxs_type_ == parenexprstatetype::lparen_1) {
rp<Expression> expr = this->gen_expr_;
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
p_psm->top_exprstate().on_expr(expr, p_psm);
}
}
void
paren_xs::on_i64_token(const token_type & tk,
parserstatemachine * /*p_psm*/)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
constexpr const char * c_self_name = "paren_xs::on_i64";
this->illegal_input_error(c_self_name, tk);
}
void
paren_xs::on_f64_token(const token_type & tk,
parserstatemachine * /*p_psm*/)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
constexpr const char * c_self_name = "paren_xs::on_f64";
this->illegal_input_error(c_self_name, tk);
}
#endif
void
DParenSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
if (parenstate_ == parenexprstatetype::lparen_1) {
this->parenstate_ = parenexprstatetype::lparen_2;
this->expr_ = expr;
return;
}
Super::on_parsed_expression(expr, p_psm);
}
void
DParenSsm::on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk,
ParserStateMachine * p_psm)
{
if (parenstate_ == parenexprstatetype::lparen_1) {
this->parenstate_ = parenexprstatetype::lparen_2;
this->expr_ = expr;
this->on_token(tk, p_psm);
return;
}
Super::on_parsed_expression(expr, p_psm);
}
#ifdef NOT_YET
void
paren_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
log && log(xtag("exstype", this->exs_type_),
xtag("expr", expr));
switch (this->parenxs_type_) {
case parenexprstatetype::lparen_0: {
this->parenxs_type_ = parenexprstatetype::lparen_1; /* wants on_rightparen */
progress_xs::start(expr.promote(), p_psm);
return;
}
case parenexprstatetype::lparen_1: {
this->gen_expr_ = expr.promote();
/* expect immediate incoming call, this time to on_rightparen() */
return;
}
default:
/* unreachable */
assert(false);
return;
}
} /*on_expr*/
void
paren_xs::on_symbol(const std::string & /*symbol_name*/,
parserstatemachine * /*p_psm*/)
{
switch(this->parenxs_type_) {
case parenexprstatetype::lparen_0:
case parenexprstatetype::lparen_1:
/* NOT IMPLEMENTED */
assert(false);
return;
default:
/* unreachable */
assert(false);
return;
}
}
void
paren_xs::print(std::ostream & os) const {
os << "<paren_xs"
<< xtag("this", (void*)this)
//<< xtag("type", exs_type_);
<< xtag("parenxs_type", parenxs_type_);
if (gen_expr_)
os << xtag("gen_expr", gen_expr_);
os << ">";
}
#endif
bool
DParenSsm::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct(ppii,
"DParenSsm",
refrtag("parenstate", parenstate_),
refrtag("expect", this->get_expect_str()));
}
void
DParenSsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_poly_child(reason, &expr_);
}
} /*namespace scm*/
} /*namespace xo*/
/* end DParenSsm.cpp */

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

File diff suppressed because it is too large Load diff

224
xo-reader2/src/reader2/DQuoteSsm.cpp
View file

@ -1,224 +0,0 @@
/** @file DQuoterSsm.cpp
*
* @author Roland Conybeare, Mar 2026
**/
#include "QuoteSsm.hpp"
#include "ExpectQLiteralSsm.hpp"
#include "syntaxstatetype.hpp"
#include <xo/expression2/Constant.hpp>
//#include <string_view>
namespace xo {
using xo::facet::with_facet;
using xo::facet::typeseq;
namespace scm {
extern const char *
QuoteXst::_descr(enum QuoteXst::code x)
{
switch (x) {
case code::invalid: return "invalid";
case code::quote_0: return "quote_0";
case code::quote_1: return "quote_1";
case code::quote_2: return "quote_2";
case code::quote_3: return "quote_3";
case code::N: break;
}
return "?QuoteXst";
}
DQuoteSsm::DQuoteSsm()
: quote_xst_(QuoteXst::code::quote_0),
expr_{}
{}
DQuoteSsm *
DQuoteSsm::_make(DArena & mm)
{
void * mem = mm.alloc_for<DQuoteSsm>();
return new (mem) DQuoteSsm();
}
obj<ASyntaxStateMachine,DQuoteSsm>
DQuoteSsm::make(DArena & mm)
{
return obj<ASyntaxStateMachine,DQuoteSsm>(_make(mm));
}
void
DQuoteSsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
auto paren_ssm = DQuoteSsm::make(p_psm->parser_alloc());
p_psm->push_ssm(ckp, paren_ssm);
}
syntaxstatetype
DQuoteSsm::ssm_type() const noexcept
{
return syntaxstatetype::paren;
}
std::string_view
DQuoteSsm::get_expect_str() const noexcept
{
switch (this->quote_xst_.code()) {
case QuoteXst::code::invalid:
case QuoteXst::code::N:
break;
case QuoteXst::code::quote_0: return "#q";
case QuoteXst::code::quote_1: return "leftbrace";
case QuoteXst::code::quote_2: return "qliteral";
case QuoteXst::code::quote_3: return "rightbrace";
}
assert(false);
return "?quotexst";
}
void
DQuoteSsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (tk.tk_type()) {
case tokentype::tk_quote:
this->on_quote_token(tk, p_psm);
return;
case tokentype::tk_leftbrace:
this->on_leftbrace_token(tk, p_psm);
return;
case tokentype::tk_rightbrace:
this->on_rightbrace_token(tk, p_psm);
return;
// all the not-yet handled cases
case tokentype::tk_symbol:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_colon:
case tokentype::tk_singleassign:
case tokentype::tk_semicolon:
case tokentype::tk_invalid:
case tokentype::tk_string:
case tokentype::tk_f64:
case tokentype::tk_i64:
case tokentype::tk_bool:
case tokentype::tk_if:
case tokentype::tk_leftparen:
case tokentype::tk_rightparen:
case tokentype::tk_leftbracket:
case tokentype::tk_rightbracket:
case tokentype::tk_leftangle:
case tokentype::tk_rightangle:
case tokentype::tk_cmple:
case tokentype::tk_cmpge:
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_nil:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
Super::on_token(tk, p_psm);
}
void
DQuoteSsm::on_quote_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (quote_xst_.code() == QuoteXst::code::quote_0) {
this->quote_xst_ = QuoteXst(QuoteXst::code::quote_1);
return;
}
Super::on_token(tk, p_psm);
}
void
DQuoteSsm::on_leftbrace_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (quote_xst_.code() == QuoteXst::code::quote_1) {
this->quote_xst_ = QuoteXst(QuoteXst::code::quote_2);
DExpectQLiteralSsm::start(p_psm);
return;
}
Super::on_token(tk, p_psm);
}
void
DQuoteSsm::on_rightbrace_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (quote_xst_.code() == QuoteXst::code::quote_3) {
// quoted literal (reported as constant expr) successfully parsed
p_psm->pop_ssm();
p_psm->on_parsed_expression(this->expr_);
return;
}
Super::on_token(tk, p_psm);
}
void
DQuoteSsm::on_quoted_literal(obj<AGCObject> literal,
ParserStateMachine * p_psm)
{
if (quote_xst_.code() == QuoteXst::code::quote_2) {
this->quote_xst_ = QuoteXst(QuoteXst::code::quote_3);
this->expr_ = DConstant::make(p_psm->expr_alloc(), literal);
return;
}
Super::illegal_quoted_literal(literal, p_psm);
}
bool
DQuoteSsm::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct(ppii,
"DQuoteSsm",
refrtag("quote_xst", quote_xst_),
refrtag("expect", this->get_expect_str()));
}
void
DQuoteSsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_poly_child(reason, &expr_);
}
} /*namespace scm*/
} /*namespace xo*/
/* end DQuoteSsm.cpp */

209
xo-reader2/src/reader2/DSchematikaParser.cpp
View file

@ -1,209 +0,0 @@
/** @file DSchematikaParser.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "SchematikaParser.hpp"
#include "ParserStateMachine.hpp"
#include "ParserStack.hpp"
#include "DToplevelSeqSsm.hpp"
#include <cstddef>
#include <xo/indentlog/scope.hpp>
#include <stdexcept>
namespace xo {
using xo::mm::ACollector;
using xo::mm::AAllocator;
using xo::mm::AGCObject;
using xo::mm::MemorySizeInfo;
using xo::tostr;
using xo::xtag;
namespace scm {
// ----- SchematikaParser -----
DSchematikaParser::DSchematikaParser(const ParserConfig & cfg,
obj<AAllocator> expr_alloc,
obj<AAllocator> aux_alloc)
: psm_{
cfg.parser_arena_config_,
cfg.symtab_var_config_,
cfg.symtab_types_config_,
cfg.max_stringtable_capacity_,
cfg.pm_install_flags_,
expr_alloc,
aux_alloc
},
debug_flag_{cfg.debug_flag_}
{
}
DSchematikaParser *
DSchematikaParser::_make(obj<AAllocator> mm,
const ParserConfig & cfg,
obj<AAllocator> expr_alloc,
obj<AAllocator> aux_alloc)
{
void * mem = mm.alloc_for<DSchematikaParser>();
return new (mem) DSchematikaParser(cfg, expr_alloc, aux_alloc);
}
obj<AGCObject,DSchematikaParser>
DSchematikaParser::make(obj<AAllocator> mm,
const ParserConfig & cfg,
obj<AAllocator> expr_alloc,
obj<AAllocator> aux_alloc)
{
return obj<AGCObject,DSchematikaParser>(_make(mm, cfg, expr_alloc, aux_alloc));
}
DGlobalSymtab *
DSchematikaParser::global_symtab() const noexcept
{
return psm_.global_symtab();
}
DGlobalEnv *
DSchematikaParser::global_env() const noexcept
{
return psm_.global_env();
}
bool
DSchematikaParser::is_at_toplevel() const
{
return psm_.is_at_toplevel();
}
bool
DSchematikaParser::has_incomplete_expr() const
{
return psm_.has_incomplete_expr();
}
obj<ASyntaxStateMachine>
DSchematikaParser::top_ssm() const
{
return psm_.top_ssm();
}
const ParserResult &
DSchematikaParser::result() const
{
return psm_.result();
}
void
DSchematikaParser::visit_pools(const MemorySizeVisitor & visitor) const
{
return psm_.visit_pools(visitor);
}
void
DSchematikaParser::begin_interactive_session()
{
DToplevelSeqSsm::establish_interactive(psm_.parser_alloc(), &psm_);
}
void
DSchematikaParser::begin_batch_session()
{
DToplevelSeqSsm::establish_batch(psm_.parser_alloc(), &psm_);
}
const DUniqueString *
DSchematikaParser::intern_string(std::string_view str)
{
return psm_.intern_string(str);
}
const ParserResult &
DSchematikaParser::on_token(const token_type & tk)
{
scope log(XO_DEBUG(debug_flag_), xtag("tk", tk));
if (psm_.stack() == nullptr) {
throw std::runtime_error(tostr("DSchematikaParser::include_token",
": parser not expecting input"
"(call parser.begin_translation_unit()..?)",
xtag("token", tk)));
}
/* stack is non-empty */
psm_.on_token(tk);
log && log(xtag("parser", this));
log && log(xtag("result", psm_.result()));
return psm_.result();
} /*include_token*/
void
DSchematikaParser::reset_result()
{
psm_.reset_result();
}
void
DSchematikaParser::reset_to_idle_toplevel()
{
psm_.clear_error_reset();
} /*reset_to_idle_toplevel*/
void
DSchematikaParser::print(std::ostream & os) const {
os << "<SchematikaParser"
<< xtag("debug", debug_flag_)
<< xtag("has_stack", (psm_.stack() != nullptr))
<< ">" << std::endl;
}
bool
DSchematikaParser::pretty(const ppindentinfo & ppii) const {
auto * pps = ppii.pps();
if (ppii.upto())
return false;
// TODO: consider printing:
// psm.stringtable_
// psm.parser_alloc_
// psm.parser_alloc_ckp_
// psm.expr_alloc_
// psm.result_
// psm.debug_flag_
//
return pps->pretty_struct
(ppii,
"SchematikaParser",
refrtag("stack", psm_.stack())
);
}
DSchematikaParser *
DSchematikaParser::gco_shallow_move(obj<AGCObjectVisitor> gc) noexcept
{
(void)gc;
/** TODO: may be feasible to use gc.std_move_for(this)
* if/when DSchematikaParser is moveable
**/
assert(false);
return nullptr;
}
void
DSchematikaParser::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
psm_.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end SchematikaParser.cpp */

271
xo-reader2/src/reader2/DSequenceSsm.cpp
View file

@ -1,271 +0,0 @@
/* @file DSequenceSsm.cpp */
#include "DSequenceSsm.hpp"
#include "ssm/ISyntaxStateMachine_DSequenceSsm.hpp"
#include "DExpectExprSsm.hpp"
#include <xo/expression2/SequenceExpr.hpp>
#include <xo/alloc2/GCObject.hpp>
#ifdef NOT_YET
#include "expect_expr_xs.hpp"
#include "let1_xs.hpp"
#include "xo/expression/DefineExpr.hpp"
#include "xo/expression/pretty_expression.hpp"
#endif
namespace xo {
#ifdef NOT_YET
using xo::scm::DDefineExpr;
#endif
using xo::facet::typeseq;
namespace scm {
void
DSequenceSsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
p_psm->push_ssm(ckp, DSequenceSsm::make(p_psm->parser_alloc(),
p_psm->expr_alloc()));
/* want to accept anything that starts an expression,
* except that rightbrace '}' ends it
*/
DExpectExprSsm::start(true /*allow_defs*/,
true /*cxl_on_rightbrace*/,
false /*!cxl_on_rightparen*/,
p_psm);
}
obj<ASyntaxStateMachine,DSequenceSsm>
DSequenceSsm::make(DArena & mm,
obj<AAllocator> expr_mm)
{
return obj<ASyntaxStateMachine,DSequenceSsm>(_make(mm, expr_mm));
}
DSequenceSsm *
DSequenceSsm::_make(DArena & mm,
obj<AAllocator> expr_mm)
{
void * mem = mm.alloc(typeseq::id<DSequenceSsm>(),
sizeof(DSequenceSsm));
DSequenceExpr * seq_expr = DSequenceExpr::_make_empty(expr_mm);
return new (mem) DSequenceSsm(seq_expr);
}
DSequenceSsm::DSequenceSsm(DSequenceExpr * seq_expr) : seq_expr_{seq_expr}
{}
syntaxstatetype
DSequenceSsm::ssm_type() const noexcept
{
return syntaxstatetype::sequence;
}
std::string_view
DSequenceSsm::get_expect_str() const noexcept
{
return "expr|semicolon|rightbrace";
}
void
DSequenceSsm::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_rightbrace:
this->on_rightbrace_token(tk, p_psm);
return;
case tokentype::tk_symbol:
case tokentype::tk_def:
case tokentype::tk_deftype:
case tokentype::tk_if:
case tokentype::tk_then:
case tokentype::tk_else:
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_quote:
case tokentype::tk_leftparen:
case tokentype::tk_rightparen:
case tokentype::tk_leftbracket:
case tokentype::tk_rightbracket:
case tokentype::tk_leftbrace:
case tokentype::tk_leftangle:
case tokentype::tk_rightangle:
case tokentype::tk_cmple:
case tokentype::tk_cmpge:
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_nil:
case tokentype::tk_type:
case tokentype::tk_lambda:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
// default = illegal token error
DSyntaxStateMachine<DSequenceSsm>::on_token(tk, p_psm);
}
void
DSequenceSsm::on_rightbrace_token(const Token & tk,
ParserStateMachine * p_psm)
{
(void)tk;
/** rightbrace ends DSequenceSsm **/
obj<AExpression,DSequenceExpr> expr(seq_expr_);
p_psm->pop_ssm();
/* make sequence from expressions seen at this level,
* and report it to parent
*/
p_psm->top_ssm().on_parsed_expression(expr, p_psm);
}
void
DSequenceSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
// TODO: switch to printable facet
log && log(xtag("expr", expr));
#ifdef NOT_YET
/* TODO: if expr is a DefineExpr,
* then need to rewrite...
*
* ...prefix
* DefineExpr(lhs_name, rhs)
* rest...
*
* becomes:
*
* /-- .outer_seq_expr_
* v
* Sequence(
* ...prefix,
*
* /-- .inner_lm_expr_
* v
* Apply(Lambda(gen999,
* [Variable(lhs_name, type(rhs))],
* /-- .expr_v_
* v
* sequencify(rest...)),
* rhs))
*
* so amongst other things,
* helpful to have nested seequence_xs that propagates '}'
* instead of swallowing it.
*/
bp<DefineExpr> def_expr = DefineExpr::from(expr);
if (def_expr) {
/** nested_start: control returns via
* .on_expr(x)
* with x something like:
* Apply(Lambda(gensym(),
* [Variable(def_expr->lhs_name(),
* def_expr->valuetype())],
* body...))
* followed immediately by
* .on_rightbrace_token()
**/
let1_xs::start(def_expr->lhs_name(),
def_expr->rhs(),
p_psm);
} else {
this->expr_v_.push_back(expr.promote());
expect_expr_xs::start(true /*allow_defs*/,
true /*cxl_on_rightbrace*/,
p_psm);
}
#endif
this->seq_expr_->push_back(p_psm->expr_alloc(), expr);
}
void
DSequenceSsm::on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk,
ParserStateMachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
if (tk.tk_type() == tokentype::tk_semicolon) {
// keep sequence on stack, consuming semicolon
this->seq_expr_->push_back(p_psm->expr_alloc(),
expr);
return;
} else if (tk.tk_type() == tokentype::tk_rightbrace) {
// rightbrace ends sequence
this->seq_expr_->push_back(p_psm->expr_alloc(), expr);
this->on_rightbrace_token(tk, p_psm);
return;
}
Super::on_parsed_expression_with_token(expr, tk, p_psm);
}
#ifdef NOT_YET
void
sequence_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
/* sequence continues until right brace */
this->on_expr(expr, p_psm);
}
#endif
bool
DSequenceSsm::pretty(const xo::print::ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct
(ppii,
"DSequenceSsm",
refrtag("seq_expr.size", seq_expr_->size()),
refrtag("expect", this->get_expect_str()));
}
void
DSequenceSsm::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_child(reason, &seq_expr_);
}
} /*namespace scm*/
} /*namespace xo*/
/* end DSequenceSsm.cpp */

529
xo-reader2/src/reader2/DToplevelSeqSsm.cpp
View file

@ -1,529 +0,0 @@
/** @file DToplevelSeqSsm.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "DToplevelSeqSsm.hpp"
#include "ssm/ISyntaxStateMachine_DToplevelSeqSsm.hpp"
#include "DDefineSsm.hpp"
#include "DeftypeSsm.hpp"
#include "LambdaSsm.hpp"
#include "ProgressSsm.hpp"
#include "IfElseSsm.hpp"
#include "QuoteSsm.hpp"
#include "ParenSsm.hpp"
#include "ExpectExprSsm.hpp"
#include "VarRef.hpp"
#include <xo/expression2/Constant.hpp>
#include <xo/stringtable2/String.hpp>
#include <xo/object2/List.hpp>
#include <xo/object2/Float.hpp>
#include <xo/object2/Integer.hpp>
#include <xo/object2/Boolean.hpp>
#include <xo/alloc2/GCObject.hpp>
namespace xo {
//using xo::scm::DProgressSsm;
using xo::scm::DConstant;
//using xo::scm::DFloat;
using xo::mm::AGCObject;
//using xo::mm::AAllocator;
using xo::mm::DArena;
//using xo::facet::with_facet;
using xo::reflect::typeseq;
namespace scm {
const char *
exprseqtype_descr(exprseqtype x)
{
switch (x) {
case exprseqtype::toplevel_interactive:
return "toplevel-interactive";
case exprseqtype::toplevel_batch:
return "toplevel-batch";
case exprseqtype::N:
break;
}
return "exprseqtype?";
}
DToplevelSeqSsm::DToplevelSeqSsm(exprseqtype ty) : seqtype_{ty}
{}
namespace {
obj<ASyntaxStateMachine>
make_exprseq_ssm(DArena & mm,
exprseqtype seqtype)
{
void * mem = mm.alloc(typeseq::id<DToplevelSeqSsm>(),
sizeof(DToplevelSeqSsm));
DToplevelSeqSsm * ssm = new (mem) DToplevelSeqSsm(seqtype);
return obj<ASyntaxStateMachine,DToplevelSeqSsm>(ssm);
}
}
void
DToplevelSeqSsm::establish_interactive(DArena & mm,
ParserStateMachine * p_psm)
{
p_psm->establish_toplevel_ssm(make_exprseq_ssm
(mm,
exprseqtype::toplevel_interactive));
}
void
DToplevelSeqSsm::establish_batch(DArena & mm,
ParserStateMachine * p_psm)
{
p_psm->establish_toplevel_ssm(make_exprseq_ssm
(mm,
exprseqtype::toplevel_batch));
}
// SyntaxStateMachine facet methods
syntaxstatetype
DToplevelSeqSsm::ssm_type() const noexcept
{
return syntaxstatetype::expect_toplevel_expression_sequence;
}
std::string_view
DToplevelSeqSsm::get_expect_str() const noexcept
{
// TODO: provisional. Will expand as more syntax implemented
switch (seqtype_) {
case exprseqtype::toplevel_interactive:
return "def|expression|...";
case exprseqtype::toplevel_batch:
return "def|...";
case exprseqtype::N:
break;
}
assert(false);
return "impossible-DToplevelSeqSsm::get_expr_str";
}
void
DToplevelSeqSsm::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:
this->on_symbol_token(tk, p_psm);
return;
case tokentype::tk_def:
this->on_def_token(tk, p_psm);
return;
case tokentype::tk_deftype:
this->on_deftype_token(tk, p_psm);
return;
case tokentype::tk_lambda:
this->on_lambda_token(tk, p_psm);
return;
case tokentype::tk_if:
this->on_if_token(tk, p_psm);
return;
case tokentype::tk_string:
this->on_string_token(tk, p_psm);
return;
case tokentype::tk_f64:
this->on_f64_token(tk, p_psm);
return;
case tokentype::tk_i64:
this->on_i64_token(tk, p_psm);
return;
case tokentype::tk_bool:
this->on_bool_token(tk, p_psm);
return;
case tokentype::tk_nil:
this->on_nil_token(tk, p_psm);
return;
case tokentype::tk_leftparen:
this->on_leftparen_token(tk, p_psm);
return;
case tokentype::tk_quote:
this->on_quote_token(tk, p_psm);
return;
// all the not-yet handled cases
case tokentype::tk_invalid:
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_cmple:
case tokentype::tk_cmpge:
case tokentype::tk_dot:
case tokentype::tk_comma:
case tokentype::tk_colon:
break;
case tokentype::tk_semicolon:
assert(false);
break;
case tokentype::tk_doublecolon:
case tokentype::tk_singleassign:
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_then:
case tokentype::tk_else:
case tokentype::tk_let:
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
break;
}
p_psm->illegal_input_on_token("DToplevelSeqSsm::on_token",
tk,
this->get_expect_str());
}
void
DToplevelSeqSsm::on_symbol_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (seqtype_) {
case exprseqtype::toplevel_interactive:
{
auto varref = obj<AExpression,DVarRef>(p_psm->lookup_varref(tk.text()));
if (varref) {
DProgressSsm::start(p_psm->parser_alloc(),
varref,
p_psm);
return;
} else {
p_psm->error_unbound_variable("DToplevelSeqSsm",
tk.text());
return;
}
}
break;
case exprseqtype::toplevel_batch:
break;
case exprseqtype::N:
assert(false); // unreachable
break;
}
Super::on_token(tk, p_psm);
}
void
DToplevelSeqSsm::on_def_token(const Token & tk,
ParserStateMachine * p_psm)
{
(void)tk;
DDefineSsm::start(p_psm->parser_alloc(),
p_psm->expr_alloc(),
p_psm);
/* keyword 'def' introduces a definition:
* def pi : f64 = 3.14159265
* def sq(x : f64) -> f64 { (x * x) }
*/
}
void
DToplevelSeqSsm::on_deftype_token(const Token & tk,
ParserStateMachine * p_psm)
{
(void)tk;
DDeftypeSsm::start(p_psm->parser_alloc(),
p_psm);
p_psm->on_token(Token::deftype_token());
}
void
DToplevelSeqSsm::on_lambda_token(const Token & tk,
ParserStateMachine * p_psm)
{
(void)tk;
switch (seqtype_) {
case exprseqtype::toplevel_interactive:
DLambdaSsm::start(p_psm);
return;
case exprseqtype::toplevel_batch:
/* lambda not allowed at top-level in batch mode */
break;
case exprseqtype::N:
assert(false); // unreachable
break;
}
Super::on_token(tk, p_psm);
}
void
DToplevelSeqSsm::on_if_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (seqtype_) {
case exprseqtype::toplevel_interactive:
DIfElseSsm::start(p_psm->parser_alloc(),
p_psm->expr_alloc(),
p_psm);
return;
case exprseqtype::toplevel_batch:
break;
case exprseqtype::N:
assert(false); // unreachable
break;
}
Super::on_token(tk, p_psm);
}
void
DToplevelSeqSsm::on_string_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (seqtype_) {
case exprseqtype::toplevel_interactive:
{
DString * dstr = DString::from_cstr(p_psm->expr_alloc(),
tk.text().c_str());
obj<AGCObject,DString> str(dstr);
obj<AExpression,DConstant> expr = DConstant::make(p_psm->expr_alloc(), str);
DProgressSsm::start(p_psm->parser_alloc(),
expr,
p_psm);
return;
}
case exprseqtype::toplevel_batch:
break;
case exprseqtype::N:
assert(false); // unreachable
break;
}
Super::on_token(tk, p_psm);
}
void
DToplevelSeqSsm::on_f64_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (seqtype_) {
case exprseqtype::toplevel_interactive:
{
auto f64o = DFloat::box<AGCObject>(p_psm->expr_alloc(),
tk.f64_value());
auto expr = DConstant::make(p_psm->expr_alloc(), f64o);
DProgressSsm::start(p_psm->parser_alloc(),
expr,
p_psm);
return;
}
case exprseqtype::toplevel_batch:
break;
case exprseqtype::N:
assert(false); // unreachable
break;
}
Super::on_token(tk, p_psm);
}
void
DToplevelSeqSsm::on_i64_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (seqtype_) {
case exprseqtype::toplevel_interactive:
{
auto i64o = DInteger::box<AGCObject>(p_psm->expr_alloc(),
tk.i64_value());
auto expr = DConstant::make(p_psm->expr_alloc(), i64o);
DProgressSsm::start(p_psm->parser_alloc(),
expr,
p_psm);
return;
}
case exprseqtype::toplevel_batch:
break;
case exprseqtype::N:
assert(false); // unreachable
break;
}
Super::illegal_token(tk, p_psm);
}
void
DToplevelSeqSsm::on_bool_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (seqtype_) {
case exprseqtype::toplevel_interactive:
{
auto dvalue = DBoolean::box<AGCObject>(p_psm->expr_alloc(),
tk.bool_value());
auto expr = DConstant::make(p_psm->expr_alloc(), dvalue);
DProgressSsm::start(p_psm->parser_alloc(),
expr,
p_psm);
return;
}
case exprseqtype::toplevel_batch:
break;
case exprseqtype::N:
assert(false); // unreachable
break;
}
Super::illegal_token(tk, p_psm);
}
void
DToplevelSeqSsm::on_nil_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (seqtype_) {
case exprseqtype::toplevel_interactive:
{
auto dvalue = DList::nil();
auto expr = DConstant::make(p_psm->expr_alloc(), dvalue);
DProgressSsm::start(p_psm->parser_alloc(),
expr,
p_psm);
return;
}
case exprseqtype::toplevel_batch:
break;
case exprseqtype::N:
assert(false);
break;
}
Super::illegal_token(tk, p_psm);
}
void
DToplevelSeqSsm::on_leftparen_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (seqtype_) {
case exprseqtype::toplevel_interactive: {
// not sufficient to just start a paren-ssm here.
// we want to parse toplevel input like
// (getfunction())();
// just as C would.
// To wait for token following right paren, use a progress-ssm
DProgressSsm::start(p_psm->parser_alloc(), p_psm);
p_psm->on_token(Token::leftparen_token());
return;
}
case exprseqtype::toplevel_batch:
break;
case exprseqtype::N:
assert(false); // unreachable
break;
}
Super::illegal_token(tk, p_psm);
}
void
DToplevelSeqSsm::on_quote_token(const Token & tk,
ParserStateMachine * p_psm)
{
switch (seqtype_) {
case exprseqtype::toplevel_interactive: {
DProgressSsm::start(p_psm->parser_alloc(),
p_psm);
DQuoteSsm::start(p_psm);
p_psm->on_token(Token::quote_token());
return;
}
case exprseqtype::toplevel_batch:
break;
case exprseqtype::N:
assert(false); // unreachable
break;
}
Super::illegal_token(tk, p_psm);
}
void
DToplevelSeqSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
// toplevel expr sequence accepts an arbitrary number of expressions.
p_psm->capture_result("DToplevelSeqSsm::on_parsed_expression", expr);
}
void
DToplevelSeqSsm::on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk,
ParserStateMachine * p_psm)
{
if (tk.tk_type() == tokentype::tk_semicolon) {
p_psm->capture_result("DToplevelSeqSsm::on_parsed_expression_with_token", expr);
return;
}
Super::on_parsed_expression_with_token(expr, tk, p_psm);
}
bool
DToplevelSeqSsm::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct
(ppii,
"DToplevelSeqSsm",
refrtag("seqtype", seqtype_));
}
void
DToplevelSeqSsm::visit_gco_children(VisitReason, obj<AGCObjectVisitor>) noexcept
{
// seqtype_: POD, skip
}
} /*namespace scm*/
} /*namespace xo*/
/* end DToplevelSeqSsm.cpp */

28
xo-reader2/src/reader2/IPrintable_DExpectExprSsm.cpp
View file

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

28
xo-reader2/src/reader2/IPrintable_DExpectFormalArglistSsm.cpp
View file

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

28
xo-reader2/src/reader2/IPrintable_DExpectQArraySsm.cpp
View file

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

28
xo-reader2/src/reader2/IPrintable_DExpectQListSsm.cpp
View file

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

28
xo-reader2/src/reader2/IPrintable_DExpectQLiteralSsm.cpp
View file

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

28
xo-reader2/src/reader2/IPrintable_DExpectSymbolSsm.cpp
View file

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

28
xo-reader2/src/reader2/IPrintable_DExpectTypeSsm.cpp
View file

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

28
xo-reader2/src/reader2/IPrintable_DParenSsm.cpp
View file

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

28
xo-reader2/src/reader2/IPrintable_DProgressSsm.cpp
View file

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

28
xo-reader2/src/reader2/IPrintable_DSequenceSsm.cpp
View file

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

28
xo-reader2/src/reader2/IPrintable_DToplevelSeqSsm.cpp
View file

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

108
xo-reader2/src/reader2/ISyntaxStateMachine_Any.cpp
View file

@ -1,108 +0,0 @@
/** @file ISyntaxStateMachine_Any.cpp
*
**/
#include "ssm/ISyntaxStateMachine_Any.hpp"
#include <iostream>
#include <exception>
namespace xo {
namespace scm {
using xo::facet::DVariantPlaceholder;
using xo::facet::typeseq;
using xo::facet::valid_facet_implementation;
void
ISyntaxStateMachine_Any::_fatal()
{
/* control here on uninitialized IAllocator_Any.
* Initialized instance will have specific implementation type
*/
std::cerr << "fatal"
<< ": attempt to call uninitialized"
<< " ISyntaxStateMachine_Any method"
<< std::endl;
std::terminate();
}
typeseq
ISyntaxStateMachine_Any::s_typeseq = typeseq::id<DVariantPlaceholder>();
bool
ISyntaxStateMachine_Any::_valid
= valid_facet_implementation<ASyntaxStateMachine, ISyntaxStateMachine_Any>();
// nonconst methods
auto
ISyntaxStateMachine_Any::on_token(Opaque, const Token &, ParserStateMachine *) -> void
{
_fatal();
}
auto
ISyntaxStateMachine_Any::on_parsed_symbol(Opaque, std::string_view, ParserStateMachine *) -> void
{
_fatal();
}
auto
ISyntaxStateMachine_Any::on_parsed_typedescr(Opaque, TypeDescr, ParserStateMachine *) -> void
{
_fatal();
}
auto
ISyntaxStateMachine_Any::on_parsed_type(Opaque, obj<AType>, ParserStateMachine *) -> void
{
_fatal();
}
auto
ISyntaxStateMachine_Any::on_parsed_formal(Opaque, const DUniqueString *, TypeDescr, ParserStateMachine *) -> void
{
_fatal();
}
auto
ISyntaxStateMachine_Any::on_parsed_formal_with_token(Opaque, const DUniqueString *, TypeDescr, const Token &, ParserStateMachine *) -> void
{
_fatal();
}
auto
ISyntaxStateMachine_Any::on_parsed_formal_arglist(Opaque, DArray *, ParserStateMachine *) -> void
{
_fatal();
}
auto
ISyntaxStateMachine_Any::on_parsed_expression(Opaque, obj<AExpression>, ParserStateMachine *) -> void
{
_fatal();
}
auto
ISyntaxStateMachine_Any::on_parsed_expression_with_token(Opaque, obj<AExpression>, const Token &, ParserStateMachine *) -> void
{
_fatal();
}
auto
ISyntaxStateMachine_Any::on_quoted_literal(Opaque, obj<AGCObject>, ParserStateMachine *) -> void
{
_fatal();
}
auto
ISyntaxStateMachine_Any::visit_gco_children(Opaque, VisitReason, obj<AGCObjectVisitor>) -> void
{
_fatal();
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_Any.cpp */

89
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectExprSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DExpectExprSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DExpectExprSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DExpectExprSsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DExpectExprSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DExpectExprSsm::ssm_type(const DExpectExprSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DExpectExprSsm::get_expect_str(const DExpectExprSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DExpectExprSsm::on_token(DExpectExprSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectExprSsm::on_parsed_symbol(DExpectExprSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExpectExprSsm::on_parsed_typedescr(DExpectExprSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DExpectExprSsm::on_parsed_type(DExpectExprSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, 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_formal_with_token(DExpectExprSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectExprSsm::on_parsed_formal_arglist(DExpectExprSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DExpectExprSsm::on_parsed_expression(DExpectExprSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectExprSsm::on_parsed_expression_with_token(DExpectExprSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectExprSsm::on_quoted_literal(DExpectExprSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DExpectExprSsm::visit_gco_children(DExpectExprSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectExprSsm.cpp */

89
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectFormalArglistSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DExpectFormalArglistSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DExpectFormalArglistSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DExpectFormalArglistSsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DExpectFormalArglistSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DExpectFormalArglistSsm::ssm_type(const DExpectFormalArglistSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DExpectFormalArglistSsm::get_expect_str(const DExpectFormalArglistSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DExpectFormalArglistSsm::on_token(DExpectFormalArglistSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArglistSsm::on_parsed_symbol(DExpectFormalArglistSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArglistSsm::on_parsed_typedescr(DExpectFormalArglistSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArglistSsm::on_parsed_type(DExpectFormalArglistSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, 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_formal_with_token(DExpectFormalArglistSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArglistSsm::on_parsed_formal_arglist(DExpectFormalArglistSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArglistSsm::on_parsed_expression(DExpectFormalArglistSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArglistSsm::on_parsed_expression_with_token(DExpectFormalArglistSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArglistSsm::on_quoted_literal(DExpectFormalArglistSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArglistSsm::visit_gco_children(DExpectFormalArglistSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectFormalArglistSsm.cpp */

89
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectQArraySsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DExpectQArraySsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DExpectQArraySsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DExpectQArraySsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DExpectQArraySsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DExpectQArraySsm::ssm_type(const DExpectQArraySsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DExpectQArraySsm::get_expect_str(const DExpectQArraySsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DExpectQArraySsm::on_token(DExpectQArraySsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQArraySsm::on_parsed_symbol(DExpectQArraySsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExpectQArraySsm::on_parsed_typedescr(DExpectQArraySsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DExpectQArraySsm::on_parsed_type(DExpectQArraySsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, p_psm);
}
auto
ISyntaxStateMachine_DExpectQArraySsm::on_parsed_formal(DExpectQArraySsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal(param_name, param_type, p_psm);
}
auto
ISyntaxStateMachine_DExpectQArraySsm::on_parsed_formal_with_token(DExpectQArraySsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQArraySsm::on_parsed_formal_arglist(DExpectQArraySsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DExpectQArraySsm::on_parsed_expression(DExpectQArraySsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectQArraySsm::on_parsed_expression_with_token(DExpectQArraySsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQArraySsm::on_quoted_literal(DExpectQArraySsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DExpectQArraySsm::visit_gco_children(DExpectQArraySsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectQArraySsm.cpp */

89
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectQListSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DExpectQListSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DExpectQListSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DExpectQListSsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DExpectQListSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DExpectQListSsm::ssm_type(const DExpectQListSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DExpectQListSsm::get_expect_str(const DExpectQListSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DExpectQListSsm::on_token(DExpectQListSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQListSsm::on_parsed_symbol(DExpectQListSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExpectQListSsm::on_parsed_typedescr(DExpectQListSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DExpectQListSsm::on_parsed_type(DExpectQListSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, p_psm);
}
auto
ISyntaxStateMachine_DExpectQListSsm::on_parsed_formal(DExpectQListSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal(param_name, param_type, p_psm);
}
auto
ISyntaxStateMachine_DExpectQListSsm::on_parsed_formal_with_token(DExpectQListSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQListSsm::on_parsed_formal_arglist(DExpectQListSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DExpectQListSsm::on_parsed_expression(DExpectQListSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectQListSsm::on_parsed_expression_with_token(DExpectQListSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQListSsm::on_quoted_literal(DExpectQListSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DExpectQListSsm::visit_gco_children(DExpectQListSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectQListSsm.cpp */

89
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectQLiteralSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DExpectQLiteralSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DExpectQLiteralSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DExpectQLiteralSsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DExpectQLiteralSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DExpectQLiteralSsm::ssm_type(const DExpectQLiteralSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::get_expect_str(const DExpectQLiteralSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::on_token(DExpectQLiteralSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::on_parsed_symbol(DExpectQLiteralSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::on_parsed_typedescr(DExpectQLiteralSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::on_parsed_type(DExpectQLiteralSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, p_psm);
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::on_parsed_formal(DExpectQLiteralSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal(param_name, param_type, p_psm);
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::on_parsed_formal_with_token(DExpectQLiteralSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::on_parsed_formal_arglist(DExpectQLiteralSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::on_parsed_expression(DExpectQLiteralSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::on_parsed_expression_with_token(DExpectQLiteralSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::on_quoted_literal(DExpectQLiteralSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DExpectQLiteralSsm::visit_gco_children(DExpectQLiteralSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectQLiteralSsm.cpp */

89
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectSymbolSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DExpectSymbolSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DExpectSymbolSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DExpectSymbolSsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DExpectSymbolSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DExpectSymbolSsm::ssm_type(const DExpectSymbolSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::get_expect_str(const DExpectSymbolSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::on_token(DExpectSymbolSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::on_parsed_symbol(DExpectSymbolSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::on_parsed_typedescr(DExpectSymbolSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::on_parsed_type(DExpectSymbolSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, 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_formal_with_token(DExpectSymbolSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::on_parsed_formal_arglist(DExpectSymbolSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::on_parsed_expression(DExpectSymbolSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::on_parsed_expression_with_token(DExpectSymbolSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::on_quoted_literal(DExpectSymbolSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::visit_gco_children(DExpectSymbolSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectSymbolSsm.cpp */

89
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectTypeSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DExpectTypeSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DExpectTypeSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DExpectTypeSsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DExpectTypeSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DExpectTypeSsm::ssm_type(const DExpectTypeSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DExpectTypeSsm::get_expect_str(const DExpectTypeSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DExpectTypeSsm::on_token(DExpectTypeSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectTypeSsm::on_parsed_symbol(DExpectTypeSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExpectTypeSsm::on_parsed_typedescr(DExpectTypeSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DExpectTypeSsm::on_parsed_type(DExpectTypeSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, 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_formal_with_token(DExpectTypeSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectTypeSsm::on_parsed_formal_arglist(DExpectTypeSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DExpectTypeSsm::on_parsed_expression(DExpectTypeSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectTypeSsm::on_parsed_expression_with_token(DExpectTypeSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectTypeSsm::on_quoted_literal(DExpectTypeSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DExpectTypeSsm::visit_gco_children(DExpectTypeSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectTypeSsm.cpp */

89
xo-reader2/src/reader2/ISyntaxStateMachine_DParenSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DParenSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DParenSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DParenSsm.json5]
**/
#include "paren/ISyntaxStateMachine_DParenSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DParenSsm::ssm_type(const DParenSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DParenSsm::get_expect_str(const DParenSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DParenSsm::on_token(DParenSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DParenSsm::on_parsed_symbol(DParenSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DParenSsm::on_parsed_typedescr(DParenSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DParenSsm::on_parsed_type(DParenSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, p_psm);
}
auto
ISyntaxStateMachine_DParenSsm::on_parsed_formal(DParenSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal(param_name, param_type, p_psm);
}
auto
ISyntaxStateMachine_DParenSsm::on_parsed_formal_with_token(DParenSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DParenSsm::on_parsed_formal_arglist(DParenSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DParenSsm::on_parsed_expression(DParenSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DParenSsm::on_parsed_expression_with_token(DParenSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DParenSsm::on_quoted_literal(DParenSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DParenSsm::visit_gco_children(DParenSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DParenSsm.cpp */

89
xo-reader2/src/reader2/ISyntaxStateMachine_DProgressSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DProgressSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DProgressSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DProgressSsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DProgressSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DProgressSsm::ssm_type(const DProgressSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DProgressSsm::get_expect_str(const DProgressSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DProgressSsm::on_token(DProgressSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DProgressSsm::on_parsed_symbol(DProgressSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DProgressSsm::on_parsed_typedescr(DProgressSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DProgressSsm::on_parsed_type(DProgressSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, 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_formal_with_token(DProgressSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DProgressSsm::on_parsed_formal_arglist(DProgressSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DProgressSsm::on_parsed_expression(DProgressSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DProgressSsm::on_parsed_expression_with_token(DProgressSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DProgressSsm::on_quoted_literal(DProgressSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DProgressSsm::visit_gco_children(DProgressSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DProgressSsm.cpp */

89
xo-reader2/src/reader2/ISyntaxStateMachine_DSequenceSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DSequenceSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DSequenceSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DSequenceSsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DSequenceSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DSequenceSsm::ssm_type(const DSequenceSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DSequenceSsm::get_expect_str(const DSequenceSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DSequenceSsm::on_token(DSequenceSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DSequenceSsm::on_parsed_symbol(DSequenceSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DSequenceSsm::on_parsed_typedescr(DSequenceSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DSequenceSsm::on_parsed_type(DSequenceSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, p_psm);
}
auto
ISyntaxStateMachine_DSequenceSsm::on_parsed_formal(DSequenceSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal(param_name, param_type, p_psm);
}
auto
ISyntaxStateMachine_DSequenceSsm::on_parsed_formal_with_token(DSequenceSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DSequenceSsm::on_parsed_formal_arglist(DSequenceSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DSequenceSsm::on_parsed_expression(DSequenceSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DSequenceSsm::on_parsed_expression_with_token(DSequenceSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DSequenceSsm::on_quoted_literal(DSequenceSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DSequenceSsm::visit_gco_children(DSequenceSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DSequenceSsm.cpp */

89
xo-reader2/src/reader2/ISyntaxStateMachine_DToplevelSeqSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DToplevelSeqSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DToplevelSeqSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DToplevelSeqSsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DToplevelSeqSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DToplevelSeqSsm::ssm_type(const DToplevelSeqSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::get_expect_str(const DToplevelSeqSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::on_token(DToplevelSeqSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::on_parsed_symbol(DToplevelSeqSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::on_parsed_typedescr(DToplevelSeqSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::on_parsed_type(DToplevelSeqSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, p_psm);
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::on_parsed_formal(DToplevelSeqSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal(param_name, param_type, p_psm);
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::on_parsed_formal_with_token(DToplevelSeqSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::on_parsed_formal_arglist(DToplevelSeqSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::on_parsed_expression(DToplevelSeqSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::on_parsed_expression_with_token(DToplevelSeqSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::on_quoted_literal(DToplevelSeqSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DToplevelSeqSsm::visit_gco_children(DToplevelSeqSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DToplevelSeqSsm.cpp */

120
xo-reader2/src/reader2/ParserResult.cpp
View file

@ -1,120 +0,0 @@
/** @file ParserResult.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "ParserResult.hpp"
#include <xo/stringtable2/String.hpp>
#include <xo/printable2/Printable.hpp>
#include <xo/alloc2/GCObject.hpp>
#include <xo/facet/FacetRegistry.hpp>
namespace xo {
using xo::print::APrintable;
using xo::facet::FacetRegistry;
namespace scm {
const char *
parser_result_type_descr(parser_result_type x)
{
switch (x) {
case parser_result_type::none: return "none";
case parser_result_type::expression: return "expression";
case parser_result_type::error: return "error";
case parser_result_type::N: break;
}
return "parser_result_type?";
}
ParserResult::ParserResult(parser_result_type type,
obj<AExpression> expr,
std::string_view error_src_fn,
const DString * error_description)
: result_type_{type},
result_expr_{expr},
error_src_fn_{error_src_fn},
error_description_{error_description}
{}
ParserResult
ParserResult::expression(std::string_view ssm_name,
obj<AExpression> expr)
{
return ParserResult(parser_result_type::expression,
expr,
ssm_name,
nullptr);
}
ParserResult
ParserResult::error(std::string_view ssm_name,
const DString * errmsg)
{
return ParserResult(parser_result_type::error,
obj<AExpression>(),
ssm_name,
errmsg);
}
void
ParserResult::print(std::ostream & os) const
{
os << "<ParserResult" ;
os << xtag("type", result_type_);
os << xtag("expr", result_expr_);
os << xtag("src_fn", error_src_fn_);
if (error_description_)
os << xtag("error", error_description_);
os << ">";
}
bool
ParserResult::pretty(const ppindentinfo & ppii) const
{
switch (result_type_) {
case parser_result_type::none:
return ppii.pps()->pretty_struct
(ppii,
"ParserResult",
refrtag("type", result_type_));
case parser_result_type::expression:
{
auto expr = FacetRegistry::instance().variant<APrintable,AExpression>(result_expr_);
return ppii.pps()->pretty_struct
(ppii,
"ParserResult",
refrtag("type", result_type_),
refrtag("expr", expr));
}
break;
case parser_result_type::error:
return ppii.pps()->pretty_struct
(ppii,
"ParserResult",
refrtag("type", result_type_),
refrtag("src_fn", error_src_fn_),
refrtag("error", error_description_));
case parser_result_type::N:
assert(false);
break;
}
return false;
}
void
ParserResult::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
// {result_type_, error_src_fn_}: pod, ignore
gc.visit_poly_child(reason, &result_expr_);
gc.visit_child(reason, &error_description_);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ParserResult.cpp */

108
xo-reader2/src/reader2/ParserStack.cpp
View file

@ -1,108 +0,0 @@
/** @file ParserStack.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "ParserStack.hpp"
#include "SyntaxStateMachine.hpp"
#include <xo/printable2/Printable.hpp>
#include <xo/facet/FacetRegistry.hpp>
namespace xo {
using xo::print::APrintable;
using xo::facet::FacetRegistry;
using xo::facet::typeseq;
namespace scm {
ParserStack::ParserStack(DArena::Checkpoint ckp,
obj<ASyntaxStateMachine> ssm,
ParserStack * parent)
: ckp_{ckp}, ssm_{ssm}, parent_{parent}
{}
ParserStack *
ParserStack::push(ParserStack * stack,
DArena::Checkpoint ckp,
DArena & mm,
obj<ASyntaxStateMachine> ssm)
{
//DArena::Checkpoint ckp = mm.checkpoint(); // wrong, must precede allocation of ssm
void * mem = mm.alloc(typeseq::id<ParserStack>(),
sizeof(ParserStack));
return new (mem) ParserStack(ckp, ssm, stack);
}
ParserStack *
ParserStack::pop(ParserStack * stack,
DArena & mm)
{
assert(stack);
mm.restore(stack->ckp());
return stack->parent();
}
void
ParserStack::print(std::ostream & os) const
{
os << "<ParserStack>";
os << xtag("ssm", "*placeholder*");
os << xtag("parent", "*placeholder*");
os << ">";
}
bool
ParserStack::pretty(const ppindentinfo & ppii) const
{
auto * pps = ppii.pps();
/* always use multiple lines */
if (ppii.upto())
return false;
pps->write("<ParserStack");
const ParserStack * frame = this;
std::size_t i_frame = 0;
while (frame) {
char buf[32];
snprintf(buf, sizeof(buf), "[%lu]", i_frame);
auto ssm = (FacetRegistry::instance().variant
<APrintable, ASyntaxStateMachine> (frame->top()));
assert(ssm.data());
pps->newline_pretty_tag(ppii.ci1(), buf, ssm);
++i_frame;
frame = frame->parent_;
}
pps->write(">");
return false;
}
void
ParserStack::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
for (ParserStack * target = this; target; target = target->parent_) {
// ParserStack::ckp: skip, POD
if (target->ssm_)
target->ssm_.visit_gco_children(reason, gc);
}
}
} /*namespace scm*/
} /*namespace xo*/
/* end ParserStack.cpp */

942
xo-reader2/src/reader2/ParserStateMachine.cpp
View file

@ -1,942 +0,0 @@
/** @file ParserStateMachine.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "ParserStateMachine.hpp"
#include "ParserStack.hpp"
#include "SyntaxStateMachine.hpp"
#include "ToplevelSeqSsm.hpp"
#include "DefineSsm.hpp"
#include <xo/numeric/NumericPrimitives.hpp>
#include <xo/procedure2/PrimitiveRegistry.hpp>
#include <xo/procedure2/SimpleRcx.hpp>
#include <xo/object2/array/IPrintable_DArray.hpp>
#include <xo/printable2/Printable.hpp>
#include <xo/alloc2/Collector.hpp>
#include <xo/alloc2/arena/IAllocator_DArena.hpp>
#include <xo/facet/FacetRegistry.hpp>
#include <xo/indentlog/scope.hpp>
#include <xo/indentlog/print/tostr.hpp>
#include <xo/indentlog/print/tag.hpp>
#include <stdexcept>
namespace xo {
using xo::mm::ACollector;
using xo::mm::AAllocator;
using xo::mm::AGCObject;
using xo::print::APrintable;
using xo::reflect::TypeDescr;
using xo::facet::FacetRegistry;
using xo::facet::with_facet;
namespace scm {
namespace {
/** Create global environment and populate with builtin primitives.
* Get memory from @p mm, with symbol names in @p stringtable.
* Stash symbol names in @p global_symtab, which coordinates with
* new global environment.
* @p pm_install_flags controls which primitives to install
**/
obj<AGCObject,DGlobalEnv>
global_env_setup(StringTable & stringtable,
obj<AAllocator> mm,
DGlobalSymtab * global_symtab,
InstallFlags pm_install_flags)
{
scope log(XO_DEBUG(false));
DGlobalEnv * env = DGlobalEnv::_make(mm,
global_symtab);
// FUDGING this for now
obj<AAllocator> err_mm;
DSimpleRcx rcx(mm, err_mm, &stringtable);
InstallSink sink = ([env, rcx, &log]
(std::string_view name,
TypeDescr fn_td,
obj<AProcedure> pm,
InstallFlags flags)
{
(void)flags;
obj<AGCObject> pm_gco = pm.to_facet<AGCObject>();
const DUniqueString * sym
= rcx.stringtable()->intern(name);
log && log("upsert", xtag("sym", std::string_view(*sym)));
env->_upsert_value(rcx.allocator(),
sym,
fn_td,
pm_gco);
return true;
});
PrimitiveRegistry::instance()
.install_primitives(with_facet<ARuntimeContext>::mkobj(&rcx),
sink,
pm_install_flags);
return obj<AGCObject,DGlobalEnv>(env);
}
}
ParserStateMachine::ParserStateMachine(const ArenaConfig & config,
const ArenaHashMapConfig & symtab_var_config,
const ArenaHashMapConfig & symtab_type_config,
size_type max_stringtable_capacity,
InstallFlags pm_install_flags,
obj<AAllocator> expr_alloc,
obj<AAllocator> aux_alloc)
: stringtable_{max_stringtable_capacity},
parser_alloc_{DArena::map(config)},
expr_alloc_{expr_alloc},
aux_alloc_{aux_alloc},
global_symtab_{DGlobalSymtab::make(expr_alloc, aux_alloc,
symtab_var_config,
symtab_type_config)},
global_env_{global_env_setup(stringtable_,
expr_alloc_,
global_symtab_.data(),
pm_install_flags)},
debug_flag_{config.debug_flag_}
{
// see xo-numeric/ {SetupNumeric.cpp, NumericPrimitives.cpp}
// for setup of {_mul, _div, _sub, ...}
//
{
const DUniqueString * name
= stringtable_.lookup(NumericPrimitives::c_multiply_pm_name);
assert(name);
this->multiply_binding_ = global_symtab_->lookup_binding(name);
}
{
const DUniqueString * name
= stringtable_.lookup(NumericPrimitives::c_divide_pm_name);
assert(name);
this->divide_binding_ = global_symtab_->lookup_binding(name);
}
{
const DUniqueString * name
= stringtable_.lookup(NumericPrimitives::c_add_pm_name);
assert(name);
this->add_binding_ = global_symtab_->lookup_binding(name);
}
{
const DUniqueString * name
= stringtable_.lookup(NumericPrimitives::c_sub_pm_name);
assert(name);
this->subtract_binding_ = global_symtab_->lookup_binding(name);
}
{
const DUniqueString * name
= stringtable_.lookup(NumericPrimitives::c_cmpeq_pm_name);
assert(name);
this->cmpeq_binding_ = global_symtab_->lookup_binding(name);
}
{
const DUniqueString * name
= stringtable_.lookup(NumericPrimitives::c_cmpne_pm_name);
assert(name);
this->cmpne_binding_ = global_symtab_->lookup_binding(name);
}
{
const DUniqueString * name
= stringtable_.lookup(NumericPrimitives::c_cmplt_pm_name);
assert(name);
this->cmplt_binding_ = global_symtab_->lookup_binding(name);
}
{
const DUniqueString * name
= stringtable_.lookup(NumericPrimitives::c_cmple_pm_name);
assert(name);
this->cmple_binding_ = global_symtab_->lookup_binding(name);
}
{
const DUniqueString * name
= stringtable_.lookup(NumericPrimitives::c_cmpgt_pm_name);
assert(name);
this->cmpgt_binding_ = global_symtab_->lookup_binding(name);
}
{
const DUniqueString * name
= stringtable_.lookup(NumericPrimitives::c_cmpge_pm_name);
assert(name);
this->cmpge_binding_ = global_symtab_->lookup_binding(name);
}
}
ParserStateMachine::~ParserStateMachine()
{
obj<ACollector> gc = expr_alloc_.try_to_facet<ACollector>();
if (gc) {
scope log(XO_DEBUG(true), "remove_gc_root not implemented");
gc.remove_gc_root(&global_symtab_);
gc.remove_gc_root(&local_symtab_);
gc.remove_gc_root(&global_env_);
}
}
obj<AGCObject>
ParserStateMachine::multiply_pm() const
{
obj<AGCObject> retval = global_env_->lookup_value(multiply_binding_);
assert(retval);
return retval;
}
obj<AGCObject>
ParserStateMachine::divide_pm() const
{
obj<AGCObject> retval = global_env_->lookup_value(divide_binding_);
assert(retval);
return retval;
}
obj<AGCObject>
ParserStateMachine::add_pm() const
{
obj<AGCObject> retval = global_env_->lookup_value(add_binding_);
assert(retval);
return retval;
}
obj<AGCObject>
ParserStateMachine::subtract_pm() const
{
obj<AGCObject> retval = global_env_->lookup_value(subtract_binding_);
assert(retval);
return retval;
}
obj<AGCObject>
ParserStateMachine::cmpeq_pm() const
{
obj<AGCObject> retval = global_env_->lookup_value(cmpeq_binding_);
assert(retval);
return retval;
}
obj<AGCObject>
ParserStateMachine::cmpne_pm() const
{
obj<AGCObject> retval = global_env_->lookup_value(cmpne_binding_);
assert(retval);
return retval;
}
obj<AGCObject>
ParserStateMachine::cmplt_pm() const
{
obj<AGCObject> retval = global_env_->lookup_value(cmplt_binding_);
assert(retval);
return retval;
}
obj<AGCObject>
ParserStateMachine::cmple_pm() const
{
obj<AGCObject> retval = global_env_->lookup_value(cmple_binding_);
assert(retval);
return retval;
}
obj<AGCObject>
ParserStateMachine::cmpgt_pm() const
{
obj<AGCObject> retval = global_env_->lookup_value(cmpgt_binding_);
assert(retval);
return retval;
}
obj<AGCObject>
ParserStateMachine::cmpge_pm() const
{
obj<AGCObject> retval = global_env_->lookup_value(cmpge_binding_);
assert(retval);
return retval;
}
bool
ParserStateMachine::is_at_toplevel() const noexcept
{
/* top-level always has DToplevelSeqSsm */
ParserStack * s = stack_;
if (s) {
auto def = obj<ASyntaxStateMachine,DDefineSsm>::from(s->top());
if (def) {
/* carve-out for top-level DefineSsm: report 'at top-level' when
* that top-level DefineSsm is on the stack, so we detect
* this condition inside DefineSsm's event handling
*/
s = stack_->parent();
}
if (s && s->parent() == nullptr) {
auto top = obj<ASyntaxStateMachine,DToplevelSeqSsm>::from(s->top());
return top;
}
} else {
/** this isn't a normal operating state, still need a batch/interactive toplevel seq.
* just the same seems better to call it top-level
**/
return true;
}
return false;
}
bool
ParserStateMachine::has_incomplete_expr() const noexcept
{
scope log(XO_DEBUG(debug_flag_));
// don't count toplevel expression
ParserStack * s = stack_;
if (s) {
auto top = obj<ASyntaxStateMachine,DToplevelSeqSsm>::from(s->top());
return !top;
} else {
return false;
}
}
obj<ASyntaxStateMachine>
ParserStateMachine::top_ssm() const
{
return this->stack_->top();
}
void
ParserStateMachine::visit_pools(const MemorySizeVisitor & visitor) const
{
stringtable_.visit_pools(visitor);
parser_alloc_.visit_pools(visitor);
global_symtab_->visit_pools(visitor);
// not counting {expr_alloc_, fixed_alloc_}. We don't consider
// either to be owned by ParserStateMachine
}
void
ParserStateMachine::establish_toplevel_ssm(obj<ASyntaxStateMachine> ssm)
{
scope log(XO_DEBUG(debug_flag_));
assert(stack_ == nullptr);
DArena::Checkpoint ckp = parser_alloc_.checkpoint();
this->stack_ = ParserStack::push(nullptr /*stack*/, ckp, parser_alloc_, ssm);
this->parser_alloc_ckp_ = parser_alloc_.checkpoint();
}
void
ParserStateMachine::push_ssm(DArena::Checkpoint ckp, obj<ASyntaxStateMachine> ssm)
{
scope log(XO_DEBUG(debug_flag_));
// note: using parser_alloc_ for parser stack, since stacklike behavior
this->stack_ = ParserStack::push(stack_, ckp, parser_alloc_, ssm);
}
void
ParserStateMachine::pop_ssm()
{
scope log(XO_DEBUG(debug_flag_));
assert(this->stack_);
this->stack_ = ParserStack::pop(stack_, parser_alloc_);
}
const DUniqueString *
ParserStateMachine::intern_string(std::string_view str)
{
return stringtable_.intern(str);
}
const DUniqueString *
ParserStateMachine::gensym(std::string_view str)
{
return stringtable_.gensym(str);
}
DVarRef *
ParserStateMachine::lookup_varref(std::string_view symbolname)
{
scope log(XO_DEBUG(debug_flag_));
const DUniqueString * ustr = stringtable_.lookup(symbolname);
if (!ustr) {
// if we don't already know the symbol,
// -> can't be a valid variable reference
// (whether global or local)
return nullptr;
}
// TODO:
// 1. check global symtab
// 2. combine local+global symtab into indept struct
// 3. move lookup_varref implementation there.
//
if (local_symtab_) {
DLocalSymtab * symtab = local_symtab_.data();
// count #of nested scopes to cross, to reach symbol
//
int32_t link_count = 0;
while (symtab) {
Binding b = symtab->lookup_binding(ustr);
if (b.is_local()) {
assert(b.i_link() == 0);
DVariable * vardef = symtab->lookup_var(b);
assert(vardef);
/** ascii diagram here
**/
return DVarRef::make(expr_alloc_,
vardef,
link_count);
} else {
assert(b.is_null());
}
++link_count;
symtab = symtab->parent();
}
}
DVariable * vardef = global_symtab_->lookup_variable(ustr);
if (vardef) {
return DVarRef::make(expr_alloc_,
vardef,
0 /*link_count -- n/a for globals*/);
}
// symbol not found
return nullptr;
}
void
ParserStateMachine::push_local_symtab(DLocalSymtab * symtab)
{
this->local_symtab_ = obj<AGCObject,DLocalSymtab>(symtab);
}
void
ParserStateMachine::pop_local_symtab()
{
assert(local_symtab_);
this->local_symtab_ = obj<AGCObject,DLocalSymtab>(local_symtab_->parent());
}
void
ParserStateMachine::upsert_var(DVariable * var)
{
assert(global_symtab_);
global_symtab_->upsert_variable(this->expr_alloc(), var);
}
void
ParserStateMachine::reset_result()
{
this->result_ = ParserResult();
}
void
ParserStateMachine::clear_error_reset()
{
this->reset_result();
while (stack_ && stack_->parent())
stack_ = stack_->parent();
this->parser_alloc_.restore(parser_alloc_ckp_);
}
void
ParserStateMachine::on_parsed_symbol(std::string_view sym)
{
scope log(XO_DEBUG(debug_flag_), xtag("sym", sym));
assert(stack_);
this->stack_->top().on_parsed_symbol(sym, this);
}
void
ParserStateMachine::on_parsed_typedescr(TypeDescr td)
{
scope log(XO_DEBUG(debug_flag_), xtag("td", td));
assert(stack_);
this->stack_->top().on_parsed_typedescr(td, this);
}
void
ParserStateMachine::on_parsed_type(obj<AType> type)
{
scope log(XO_DEBUG(debug_flag_));
assert(stack_);
this->stack_->top().on_parsed_type(type, 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_formal_with_token(const DUniqueString * sym,
TypeDescr td,
const Token & tk)
{
scope log(XO_DEBUG(debug_flag_), xtag("sym", std::string_view(*sym)), xtag("td", td), xtag("tk", tk));
assert(stack_);
this->stack_->top().on_parsed_formal_with_token(sym, td, tk, this);
}
void
ParserStateMachine::on_parsed_formal_arglist(DArray * arglist)
{
scope log(XO_DEBUG(debug_flag_),
xtag("arglist", obj<APrintable,DArray>(arglist)));
assert(stack_);
this->stack_->top().on_parsed_formal_arglist(arglist, this);
}
void
ParserStateMachine::on_parsed_expression(obj<AExpression> expr)
{
scope log(XO_DEBUG(debug_flag_), xtag("expr", expr));
assert(stack_);
this->top_ssm().on_parsed_expression(expr, this);
}
void
ParserStateMachine::on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk)
{
scope log(XO_DEBUG(debug_flag_), xtag("expr", expr), xtag("tk", tk));
assert(stack_);
this->top_ssm().on_parsed_expression_with_token(expr, tk, this);
}
void
ParserStateMachine::on_quoted_literal(obj<AGCObject> lit)
{
this->top_ssm().on_quoted_literal(lit, this);
}
void
ParserStateMachine::on_token(const Token & tk)
{
scope log(XO_DEBUG(debug_flag_), xtag("tk", tk));
if (!stack_) {
// parsing stack should always have toplevel expression sequence
throw std::runtime_error(tostr("unexpected empty parsing stack",
xtag("token", tk),
xtag("help", "do it the same. but better!")
));
}
stack_->top().on_token(tk, this);
}
void
ParserStateMachine::capture_result(std::string_view ssm_name,
obj<AExpression> expr)
{
this->result_ = ParserResult::expression(ssm_name, expr);
}
void
ParserStateMachine::capture_error(std::string_view ssm_name,
const DString * errmsg)
{
if (result_.is_error()) {
/* in case one error triggers another, remmber just the first one */
} else {
this->result_ = ParserResult::error(ssm_name, errmsg);
}
}
void
ParserStateMachine::illegal_input_on_token(std::string_view ssm_name,
const Token & tk,
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 token for parsing state",
xtag("token", tk),
xtag("expecting", expect_str),
xtag("ssm", ssm_name),
xtag("via", "ParserStateMachine::illegal_input_on_token"));
assert(expr_alloc_);
auto errmsg = DString::from_view(expr_alloc_,
std::string_view(errmsg_string));
this->capture_error(ssm_name, errmsg);
}
void
ParserStateMachine::illegal_input_on_symbol(std::string_view ssm_name,
std::string_view sym,
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 symbol for parsing state",
xtag("symbol", sym),
xtag("expecting", expect_str),
xtag("ssm", ssm_name),
xtag("via", "ParserStateMachine::illegal_input_on_symbol"));
assert(expr_alloc_);
auto errmsg = DString::from_view(expr_alloc_,
std::string_view(errmsg_string));
this->capture_error(ssm_name, errmsg);
}
void
ParserStateMachine::illegal_input_on_typedescr(std::string_view ssm_name,
TypeDescr td,
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 type-description for parsing state",
xtag("td", td),
xtag("expecting", expect_str),
xtag("ssm", ssm_name),
xtag("via", "ParserStateMachine::illegal_input_on_typedescr"));
assert(expr_alloc_);
auto errmsg = DString::from_view(expr_alloc_,
std::string_view(errmsg_string));
this->capture_error(ssm_name, errmsg);
}
void
ParserStateMachine::illegal_input_on_type(std::string_view ssm_name,
obj<AType> 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 type for parsing state",
xtag("type", type),
xtag("expecting", expect_str),
xtag("ssm", ssm_name),
xtag("via", "ParserStateMachine::illegal_input_on_type"));
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_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 formal",
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_formal"));
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_formal_with_token(std::string_view ssm_name,
const DUniqueString * param_name,
TypeDescr param_type,
const Token & tk,
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 formal",
xtag("param_name", std::string_view(*param_name)),
xtag("param_type", param_type),
xtag("tk", tk),
xtag("expecting", expect_str),
xtag("ssm", ssm_name),
xtag("via", "ParserStateMachine::illegal_parsed_formal"));
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_formal_arglist(std::string_view ssm_name,
DArray * arglist,
std::string_view expect_str)
{
obj<APrintable,DArray> arglist_pr(arglist);
auto errmsg_string = tostr("Unexpected formal arglist",
xtag("arglist", arglist_pr),
xtag("expecting", expect_str),
xtag("ssm", ssm_name),
xtag("via", "ParserStateMachine::illegal_parsed_formal_arglist"));
assert(expr_alloc_);
auto errmsg = DString::from_str(expr_alloc_, errmsg_string);
this->capture_error(ssm_name, errmsg);
}
void
ParserStateMachine::illegal_parsed_expression(std::string_view ssm_name,
obj<AExpression> expr,
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 expr_pr = expr.to_facet<APrintable>();
//= FacetRegistry::instance().variant<APrintable,AExpression>(expr);
assert(expr_pr);
/** TODO
* problem here: we have pretty() support for obj<AExpression>,
* but not "ordinary printing" support. So expression doesn't get printed
**/
auto errmsg_string = tostr("Unexpected expression",
xtag("expr", expr_pr),
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_with_token(std::string_view ssm_name,
obj<AExpression> expr,
const Token & tk,
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
obj<APrintable> expr_pr
= FacetRegistry::instance().variant<APrintable,AExpression>(expr);
assert(expr_pr);
/** TODO
* problem here: we have pretty() support for obj<AExpression>,
* but not "ordinary printing" support. So expression doesn't get printed
**/
auto errmsg_string = tostr("Unexpected expression",
xtag("expr", expr_pr),
xtag("tk", tk),
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_quoted_literal(std::string_view ssm_name,
obj<AGCObject> lit,
std::string_view expect_str)
{
obj<APrintable> lit_pr
= FacetRegistry::instance().variant<APrintable,AGCObject>(lit);
/** TODO
* problem here: we have pretty() support for obj<AExpression>,
* but not "ordinary printing" support. So expression doesn't get printed
**/
auto errmsg_string = tostr("Unexpected quoted literal",
xtag("lit", lit_pr),
xtag("expecting", expect_str),
xtag("ssm", ssm_name),
xtag("via", "ParserStateMachine::illegal_quoted_literal"));
assert(expr_alloc_);
auto errmsg = DString::from_view(expr_alloc_,
std::string_view(errmsg_string));
this->capture_error(ssm_name, errmsg);
}
void
ParserStateMachine::error_unbound_variable(std::string_view ssm_name,
std::string_view sym)
{
auto errmsg_string = tostr("No binding for symbol",
xtag("symbol", sym),
xtag("ssm", ssm_name));
auto errmsg = DString::from_view(expr_alloc_,
std::string_view(errmsg_string));
this->capture_error(ssm_name, errmsg);
}
// ----- gc support -----
#ifdef OBSOLETE
void
ParserStateMachine::shallow_copy(obj<ACollector> gc) noexcept
{
(void)gc;
assert(false);
}
#endif
void
ParserStateMachine::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
//scope log(XO_DEBUG(true));
assert(!stringtable_.is_gc_eligible());
assert(!parser_alloc_.is_gc_eligible());
//log && log("forward stack_", xtag("addr", stack_));
if (stack_) {
stack_->visit_gco_children(reason, gc);
}
// static_assert(!expr_alloc_.is_gc_eligible());
// static_assert(!aux_alloc_.is_gc_eligible());
//log && log("global_symtab_", xtag("addr", global_symtab_.data()));
gc.visit_child(reason, &global_symtab_);
//log && log("local_symtab_", xtag("addr", local_symtab_.data()));
gc.visit_child(reason, &local_symtab_);
//log && log("global_env_", xtag("addr", global_env_.data()));
gc.visit_child(reason, &global_env_);
//log && log("result_");
result_.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ParserStateMachine.cpp */

13
xo-reader2/src/reader2/ReaderConfig.cpp
View file

@ -1,13 +0,0 @@
/** @file ReaderConfig.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "ReaderConfig.hpp"
namespace xo {
namespace scm {
}
} /*namespace xo*/
/* end ReaderConfig.cpp */

224
xo-reader2/src/reader2/SchematikaReader.cpp
View file

@ -1,224 +0,0 @@
/** @file SchematikaReader.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "SchematikaReader.hpp"
namespace xo {
using xo::mm::MemorySizeInfo;
namespace scm {
void
ReaderResult::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
gc.visit_poly_child(reason, &expr_);
}
// ----- SchematikaReader -----
SchematikaReader::SchematikaReader(const ReaderConfig & config,
obj<AAllocator> expr_alloc,
obj<AAllocator> aux_alloc)
: tokenizer_{config.tk_buffer_config_,
config.tk_debug_flag_},
parser_{ParserConfig(config.parser_arena_config_,
config.symtab_var_config_,
config.symtab_types_config_,
config.max_stringtable_cap_,
config.pm_install_flags_,
config.parser_debug_flag_),
expr_alloc,
aux_alloc},
debug_flag_{config.reader_debug_flag_}
{
}
DGlobalSymtab *
SchematikaReader::global_symtab() const noexcept
{
return parser_.global_symtab();
}
DGlobalEnv *
SchematikaReader::global_env() const noexcept
{
return parser_.global_env();
}
StringTable *
SchematikaReader::stringtable() noexcept
{
return parser_.stringtable();
}
void
SchematikaReader::visit_pools(const MemorySizeVisitor & visitor) const
{
tokenizer_.visit_pools(visitor);
parser_.visit_pools(visitor);
}
bool
SchematikaReader::is_at_toplevel() const noexcept
{
return parser_.is_at_toplevel();
}
void
SchematikaReader::begin_interactive_session()
{
parser_.begin_interactive_session();
}
void
SchematikaReader::begin_batch_session()
{
parser_.begin_batch_session();
}
// TODO:
// Schematika::end_interactive_session()
const DUniqueString *
SchematikaReader::intern_string(std::string_view str)
{
return parser_.intern_string(str);
}
const ReaderResult &
SchematikaReader::read_expr(span_type input_ext, bool eof)
{
scope log(XO_DEBUG(debug_flag_));
if (log) {
log(xtag("input_ext", input_ext));
log(xtag("eof", eof));
}
if (!input_ext.empty()) {
auto [error, input]
= tokenizer_.buffer_input_line(input_ext, eof);
if (log) {
log(xtag("msg", "before loop: buffered input line"));
log(xtag("input", input));
}
while (!input.empty()) {
log && log(xtag("msg", "loop"),
xtag("input", input));
auto [tk, consumed, error] = tokenizer_.scan(input);
log && log(xtag("tk", tk), xtag("consumed", consumed));
auto rem_input = input.after_prefix(consumed);
log && log(xtag("rem_input", rem_input));
if (!tk.is_valid() && error.is_error()) {
this->result_
= ReaderResult
{ .expr_ = obj<AExpression>(),
.remaining_input_ = rem_input,
.tk_error_ = std::move(error)
};
return result_;
}
// log && log(xtag("consumed", consumed), xtag("tk", tk));
if (tk.is_valid()) {
// presult {
// result_type :: parser_result_type = none|expression|error
// result_expr :: obj<AExpression>
// error_src_function :: string_view
// error_description :: const DString *
// }
//
const ParserResult & presult = parser_.on_token(tk);
if (presult.is_error()) {
// tk_error {
// src_function :: const char *
// error_description :: string
// input_state {
// current_line :: span
// tk_start :: size_t
// current_pos :: size_t
// whitespace :: size_t
// debug_flag :: bool
// }
// error_pos :: size_t
// }
//
// tk_error.report(cout);
this->result_
= ReaderResult
{ .expr_ = obj<AExpression>(),
.remaining_input_ = rem_input,
.tk_error_ = std::move(error) };
assert(presult.error_description());
// carefully created error description, maybe
this->result_.tk_error_
= result_.tk_error_.with_error
(presult.error_src_fn_,
std::string
(std::string_view(*(presult.error_description()))));
return result_;
} else if (presult.is_expression()) {
this->result_
= ReaderResult
{
.expr_ = presult.result_expr(),
.remaining_input_ = rem_input,
.tk_error_ = TokenizerError()
};
return result_;
}
}
input = rem_input;
}
}
this->result_ = ReaderResult();
return this->result_;
}
void
SchematikaReader::reset_result()
{
this->parser_.reset_result();
}
void
SchematikaReader::reset_to_idle_toplevel()
{
this->tokenizer_.discard_current_line();
this->parser_.reset_to_idle_toplevel();
}
void
SchematikaReader::visit_gco_children(VisitReason reason,
obj<AGCObjectVisitor> gc) noexcept
{
// tokenizer doesn't contain any gc-aware pointers.
parser_.visit_gco_children(reason, gc);
result_.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end SchematikaReader.cpp */

164
xo-reader2/src/reader2/SetupReader2.cpp
View file

@ -1,164 +0,0 @@
/** @file SetupReader2.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "SetupReader2.hpp"
#include "SchematikaParser.hpp"
#include "ToplevelSeqSsm.hpp"
#include "DefineSsm.hpp"
#include "DeftypeSsm.hpp"
#include "LambdaSsm.hpp"
#include "IfElseSsm.hpp"
#include "ApplySsm.hpp"
#include "SequenceSsm.hpp"
#include "ParenSsm.hpp"
#include "QuoteSsm.hpp"
#include "ProgressSsm.hpp"
#include "SyntaxStateMachine.hpp"
#include "ExpectFormalArglistSsm.hpp"
#include "ExpectFormalArgSsm.hpp"
#include "ExpectSymbolSsm.hpp"
#include "ExpectTypeSsm.hpp"
#include "ExpectListTypeSsm.hpp"
#include "ExpectExprSsm.hpp"
#include "ExpectQLiteralSsm.hpp"
#include "ExpectQListSsm.hpp"
#include "ExpectQDictSsm.hpp"
#include "ExpectQArraySsm.hpp"
#include <xo/printable2/detail/APrintable.hpp>
#include <xo/facet/FacetRegistry.hpp>
#include <xo/indentlog/scope.hpp>
namespace xo {
using xo::print::APrintable;
using xo::mm::ACollector;
using xo::mm::AGCObject;
using xo::facet::FacetRegistry;
using xo::facet::TypeRegistry;
using xo::facet::typeseq;
using xo::facet::impl_for;
namespace scm {
bool
SetupReader2::register_facets()
{
scope log(XO_DEBUG(true));
// SchematikParser
FacetRegistry::register_impl<AGCObject, DSchematikaParser>();
// GlobalEnv
FacetRegistry::register_impl<AGCObject, DGlobalEnv>();
FacetRegistry::register_impl<APrintable, DGlobalEnv>();
// SyntaxStateMachine
FacetRegistry::register_impl<ASyntaxStateMachine, DToplevelSeqSsm>();
FacetRegistry::register_impl<APrintable, DToplevelSeqSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DDefineSsm>();
FacetRegistry::register_impl<APrintable, DDefineSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DDeftypeSsm>();
FacetRegistry::register_impl<APrintable, DDeftypeSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DLambdaSsm>();
FacetRegistry::register_impl<APrintable, DLambdaSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DIfElseSsm>();
FacetRegistry::register_impl<APrintable, DIfElseSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DApplySsm>();
FacetRegistry::register_impl<APrintable, DApplySsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DSequenceSsm>();
FacetRegistry::register_impl<APrintable, DSequenceSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DExpectFormalArglistSsm>();
FacetRegistry::register_impl<APrintable, DExpectFormalArglistSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DExpectFormalArgSsm>();
FacetRegistry::register_impl<APrintable, DExpectFormalArgSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DExpectSymbolSsm>();
FacetRegistry::register_impl<APrintable, DExpectSymbolSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DExpectTypeSsm>();
FacetRegistry::register_impl<APrintable, DExpectTypeSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DExpectListTypeSsm>();
FacetRegistry::register_impl<APrintable, DExpectListTypeSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DExpectExprSsm>();
FacetRegistry::register_impl<APrintable, DExpectExprSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DProgressSsm>();
FacetRegistry::register_impl<APrintable, DProgressSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DParenSsm>();
FacetRegistry::register_impl<APrintable, DParenSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DQuoteSsm>();
FacetRegistry::register_impl<APrintable, DQuoteSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DExpectQLiteralSsm>();
FacetRegistry::register_impl<APrintable, DExpectQLiteralSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DExpectQListSsm>();
FacetRegistry::register_impl<APrintable, DExpectQListSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DExpectQDictSsm>();
FacetRegistry::register_impl<APrintable, DExpectQDictSsm>();
FacetRegistry::register_impl<ASyntaxStateMachine, DExpectQArraySsm>();
FacetRegistry::register_impl<APrintable, DExpectQArraySsm>();
// misc types showing up in parser stack arena
TypeRegistry::register_type<ParserStack>();
log && log(xtag("DSchematikaParser.tseq", typeseq::id<DSchematikaParser>()));
log && log(xtag("DGlobalEnv.tseq", typeseq::id<DGlobalEnv>()));
log && log(xtag("DToplevelSeqSsm.tseq", typeseq::id<DToplevelSeqSsm>()));
log && log(xtag("DDefineSsm.tseq", typeseq::id<DDefineSsm>()));
log && log(xtag("DDeftypeSsm.tseq", typeseq::id<DDeftypeSsm>()));
log && log(xtag("DLambdaSsm.tseq", typeseq::id<DLambdaSsm>()));
log && log(xtag("DIfElseSsm.tseq", typeseq::id<DIfElseSsm>()));
log && log(xtag("DExpectFormalArglistSsm.tseq", typeseq::id<DExpectFormalArglistSsm>()));
log && log(xtag("DExpectFormalArgSsm.tseq", typeseq::id<DExpectFormalArgSsm>()));
log && log(xtag("DExpectSymbolSsm.tseq", typeseq::id<DExpectSymbolSsm>()));
log && log(xtag("DExpectTypeSsm.tseq", typeseq::id<DExpectTypeSsm>()));
log && log(xtag("DExpectExprSsm.tseq", typeseq::id<DExpectExprSsm>()));
log && log(xtag("DExpectQLiteralSsm.tseq", typeseq::id<DExpectQLiteralSsm>()));
log && log(xtag("DExpectQListSsm.tseq", typeseq::id<DExpectQListSsm>()));
log && log(xtag("DExpectQDictSsm.tseq", typeseq::id<DExpectQDictSsm>()));
log && log(xtag("DExpectQArraySsm.tseq", typeseq::id<DExpectQArraySsm>()));
log && log(xtag("DProgressSsm.tseq", typeseq::id<DProgressSsm>()));
log && log(xtag("DParenSsm.tseq", typeseq::id<DParenSsm>()));
log && log(xtag("DQuoteSsm.tseq", typeseq::id<DQuoteSsm>()));
log && log(xtag("ASyntaxStateMachine.tseq", typeseq::id<ASyntaxStateMachine>()));
return true;
}
bool
SetupReader2::register_types(obj<ACollector> gc)
{
scope log(XO_DEBUG(true));
bool ok = true;
ok &= gc.install_type(impl_for<AGCObject, DGlobalEnv>());
return ok;
}
} /*namespace scm*/
} /*namespace xo*/
/* end SetupReader2.cpp */

32
xo-reader2/src/reader2/facet/IGCObject_DGlobalEnv.cpp
View file

@ -1,32 +0,0 @@
/** @file IGCObject_DGlobalEnv.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/IGCObject_DGlobalEnv.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/IGCObject_DGlobalEnv.json5]
**/
#include "env/IGCObject_DGlobalEnv.hpp"
namespace xo {
namespace scm {
auto
IGCObject_DGlobalEnv::gco_shallow_move(DGlobalEnv & self, obj<AGCObjectVisitor> gc) noexcept -> Opaque
{
return self.gco_shallow_move(gc);
}
auto
IGCObject_DGlobalEnv::visit_gco_children(DGlobalEnv & self, VisitReason reason, obj<AGCObjectVisitor> fn) noexcept -> void
{
self.visit_gco_children(reason, fn);
}
} /*namespace scm*/
} /*namespace xo*/
/* end IGCObject_DGlobalEnv.cpp */

32
xo-reader2/src/reader2/facet/IGCObject_DSchematikaParser.cpp
View file

@ -1,32 +0,0 @@
/** @file IGCObject_DSchematikaParser.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/IGCObject_DSchematikaParser.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/IGCObject_DSchematikaParser.json5]
**/
#include "parser/IGCObject_DSchematikaParser.hpp"
namespace xo {
namespace scm {
auto
IGCObject_DSchematikaParser::gco_shallow_move(DSchematikaParser & self, obj<AGCObjectVisitor> gc) noexcept -> Opaque
{
return self.gco_shallow_move(gc);
}
auto
IGCObject_DSchematikaParser::visit_gco_children(DSchematikaParser & self, VisitReason reason, obj<AGCObjectVisitor> fn) noexcept -> void
{
self.visit_gco_children(reason, fn);
}
} /*namespace scm*/
} /*namespace xo*/
/* end IGCObject_DSchematikaParser.cpp */

28
xo-reader2/src/reader2/facet/IPrintable_DApplySsm.cpp
View file

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

28
xo-reader2/src/reader2/facet/IPrintable_DDefineSsm.cpp
View file

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

28
xo-reader2/src/reader2/facet/IPrintable_DDeftypeSsm.cpp
View file

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

28
xo-reader2/src/reader2/facet/IPrintable_DExpectFormalArgSsm.cpp
View file

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

28
xo-reader2/src/reader2/facet/IPrintable_DExpectListTypeSsm.cpp
View file

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

28
xo-reader2/src/reader2/facet/IPrintable_DExpectQDictSsm.cpp
View file

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

28
xo-reader2/src/reader2/facet/IPrintable_DGlobalEnv.cpp
View file

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

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

@ -1,28 +0,0 @@
/** @file IPrintable_DIfElseSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [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 "ifelse/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 */

28
xo-reader2/src/reader2/facet/IPrintable_DLambdaSsm.cpp
View file

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

28
xo-reader2/src/reader2/facet/IPrintable_DQuoteSsm.cpp
View file

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

89
xo-reader2/src/reader2/facet/ISyntaxStateMachine_DApplySsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DApplySsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DApplySsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DApplySsm.json5]
**/
#include "apply/ISyntaxStateMachine_DApplySsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DApplySsm::ssm_type(const DApplySsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DApplySsm::get_expect_str(const DApplySsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DApplySsm::on_token(DApplySsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DApplySsm::on_parsed_symbol(DApplySsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DApplySsm::on_parsed_typedescr(DApplySsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DApplySsm::on_parsed_type(DApplySsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, p_psm);
}
auto
ISyntaxStateMachine_DApplySsm::on_parsed_formal(DApplySsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal(param_name, param_type, p_psm);
}
auto
ISyntaxStateMachine_DApplySsm::on_parsed_formal_with_token(DApplySsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DApplySsm::on_parsed_formal_arglist(DApplySsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DApplySsm::on_parsed_expression(DApplySsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DApplySsm::on_parsed_expression_with_token(DApplySsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DApplySsm::on_quoted_literal(DApplySsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DApplySsm::visit_gco_children(DApplySsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DApplySsm.cpp */

89
xo-reader2/src/reader2/facet/ISyntaxStateMachine_DDefineSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DDefineSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DDefineSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DDefineSsm.json5]
**/
#include "define/ISyntaxStateMachine_DDefineSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DDefineSsm::ssm_type(const DDefineSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DDefineSsm::get_expect_str(const DDefineSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DDefineSsm::on_token(DDefineSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DDefineSsm::on_parsed_symbol(DDefineSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DDefineSsm::on_parsed_typedescr(DDefineSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DDefineSsm::on_parsed_type(DDefineSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, 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_formal_with_token(DDefineSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DDefineSsm::on_parsed_formal_arglist(DDefineSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DDefineSsm::on_parsed_expression(DDefineSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DDefineSsm::on_parsed_expression_with_token(DDefineSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DDefineSsm::on_quoted_literal(DDefineSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DDefineSsm::visit_gco_children(DDefineSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DDefineSsm.cpp */

89
xo-reader2/src/reader2/facet/ISyntaxStateMachine_DDeftypeSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DDeftypeSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DDeftypeSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DDeftypeSsm.json5]
**/
#include "deftype/ISyntaxStateMachine_DDeftypeSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DDeftypeSsm::ssm_type(const DDeftypeSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DDeftypeSsm::get_expect_str(const DDeftypeSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DDeftypeSsm::on_token(DDeftypeSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DDeftypeSsm::on_parsed_symbol(DDeftypeSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DDeftypeSsm::on_parsed_typedescr(DDeftypeSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DDeftypeSsm::on_parsed_type(DDeftypeSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, p_psm);
}
auto
ISyntaxStateMachine_DDeftypeSsm::on_parsed_formal(DDeftypeSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal(param_name, param_type, p_psm);
}
auto
ISyntaxStateMachine_DDeftypeSsm::on_parsed_formal_with_token(DDeftypeSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DDeftypeSsm::on_parsed_formal_arglist(DDeftypeSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DDeftypeSsm::on_parsed_expression(DDeftypeSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DDeftypeSsm::on_parsed_expression_with_token(DDeftypeSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DDeftypeSsm::on_quoted_literal(DDeftypeSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DDeftypeSsm::visit_gco_children(DDeftypeSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DDeftypeSsm.cpp */

89
xo-reader2/src/reader2/facet/ISyntaxStateMachine_DExpectFormalArgSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DExpectFormalArgSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DExpectFormalArgSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DExpectFormalArgSsm.json5]
**/
#include "expect_formal_arg/ISyntaxStateMachine_DExpectFormalArgSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DExpectFormalArgSsm::ssm_type(const DExpectFormalArgSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DExpectFormalArgSsm::get_expect_str(const DExpectFormalArgSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DExpectFormalArgSsm::on_token(DExpectFormalArgSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArgSsm::on_parsed_symbol(DExpectFormalArgSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArgSsm::on_parsed_typedescr(DExpectFormalArgSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArgSsm::on_parsed_type(DExpectFormalArgSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, 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_formal_with_token(DExpectFormalArgSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArgSsm::on_parsed_formal_arglist(DExpectFormalArgSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArgSsm::on_parsed_expression(DExpectFormalArgSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArgSsm::on_parsed_expression_with_token(DExpectFormalArgSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArgSsm::on_quoted_literal(DExpectFormalArgSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DExpectFormalArgSsm::visit_gco_children(DExpectFormalArgSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectFormalArgSsm.cpp */

89
xo-reader2/src/reader2/facet/ISyntaxStateMachine_DExpectListTypeSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DExpectListTypeSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DExpectListTypeSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DExpectListTypeSsm.json5]
**/
#include "expect_listtype/ISyntaxStateMachine_DExpectListTypeSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DExpectListTypeSsm::ssm_type(const DExpectListTypeSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::get_expect_str(const DExpectListTypeSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::on_token(DExpectListTypeSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::on_parsed_symbol(DExpectListTypeSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::on_parsed_typedescr(DExpectListTypeSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::on_parsed_type(DExpectListTypeSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, p_psm);
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::on_parsed_formal(DExpectListTypeSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal(param_name, param_type, p_psm);
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::on_parsed_formal_with_token(DExpectListTypeSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::on_parsed_formal_arglist(DExpectListTypeSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::on_parsed_expression(DExpectListTypeSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::on_parsed_expression_with_token(DExpectListTypeSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::on_quoted_literal(DExpectListTypeSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DExpectListTypeSsm::visit_gco_children(DExpectListTypeSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectListTypeSsm.cpp */

89
xo-reader2/src/reader2/facet/ISyntaxStateMachine_DExpectQDictSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DExpectQDictSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DExpectQDictSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DExpectQDictSsm.json5]
**/
#include "expect_qdict/ISyntaxStateMachine_DExpectQDictSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DExpectQDictSsm::ssm_type(const DExpectQDictSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DExpectQDictSsm::get_expect_str(const DExpectQDictSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DExpectQDictSsm::on_token(DExpectQDictSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQDictSsm::on_parsed_symbol(DExpectQDictSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExpectQDictSsm::on_parsed_typedescr(DExpectQDictSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DExpectQDictSsm::on_parsed_type(DExpectQDictSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, p_psm);
}
auto
ISyntaxStateMachine_DExpectQDictSsm::on_parsed_formal(DExpectQDictSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal(param_name, param_type, p_psm);
}
auto
ISyntaxStateMachine_DExpectQDictSsm::on_parsed_formal_with_token(DExpectQDictSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQDictSsm::on_parsed_formal_arglist(DExpectQDictSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DExpectQDictSsm::on_parsed_expression(DExpectQDictSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectQDictSsm::on_parsed_expression_with_token(DExpectQDictSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectQDictSsm::on_quoted_literal(DExpectQDictSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DExpectQDictSsm::visit_gco_children(DExpectQDictSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectQDictSsm.cpp */

89
xo-reader2/src/reader2/facet/ISyntaxStateMachine_DIfElseSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DIfElseSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [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 "ifelse/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_type(DIfElseSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, 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_formal_with_token(DIfElseSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DIfElseSsm::on_parsed_formal_arglist(DIfElseSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, 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_token(DIfElseSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DIfElseSsm::on_quoted_literal(DIfElseSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DIfElseSsm::visit_gco_children(DIfElseSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DIfElseSsm.cpp */

89
xo-reader2/src/reader2/facet/ISyntaxStateMachine_DLambdaSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DLambdaSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DLambdaSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DLambdaSsm.json5]
**/
#include "lambda/ISyntaxStateMachine_DLambdaSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DLambdaSsm::ssm_type(const DLambdaSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DLambdaSsm::get_expect_str(const DLambdaSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DLambdaSsm::on_token(DLambdaSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::on_parsed_symbol(DLambdaSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::on_parsed_typedescr(DLambdaSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::on_parsed_type(DLambdaSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, 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_formal_with_token(DLambdaSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::on_parsed_formal_arglist(DLambdaSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::on_parsed_expression(DLambdaSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::on_parsed_expression_with_token(DLambdaSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::on_quoted_literal(DLambdaSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::visit_gco_children(DLambdaSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DLambdaSsm.cpp */

89
xo-reader2/src/reader2/facet/ISyntaxStateMachine_DQuoteSsm.cpp
View file

@ -1,89 +0,0 @@
/** @file ISyntaxStateMachine_DQuoteSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DQuoteSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DQuoteSsm.json5]
**/
#include "quote/ISyntaxStateMachine_DQuoteSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DQuoteSsm::ssm_type(const DQuoteSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DQuoteSsm::get_expect_str(const DQuoteSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DQuoteSsm::on_token(DQuoteSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DQuoteSsm::on_parsed_symbol(DQuoteSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DQuoteSsm::on_parsed_typedescr(DQuoteSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DQuoteSsm::on_parsed_type(DQuoteSsm & self, obj<AType> type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_type(type, p_psm);
}
auto
ISyntaxStateMachine_DQuoteSsm::on_parsed_formal(DQuoteSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal(param_name, param_type, p_psm);
}
auto
ISyntaxStateMachine_DQuoteSsm::on_parsed_formal_with_token(DQuoteSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_with_token(param_name, param_type, tk, p_psm);
}
auto
ISyntaxStateMachine_DQuoteSsm::on_parsed_formal_arglist(DQuoteSsm & self, DArray * arglist, ParserStateMachine * p_psm) -> void
{
self.on_parsed_formal_arglist(arglist, p_psm);
}
auto
ISyntaxStateMachine_DQuoteSsm::on_parsed_expression(DQuoteSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DQuoteSsm::on_parsed_expression_with_token(DQuoteSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_token(expr, tk, p_psm);
}
auto
ISyntaxStateMachine_DQuoteSsm::on_quoted_literal(DQuoteSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm) -> void
{
self.on_quoted_literal(lit, p_psm);
}
auto
ISyntaxStateMachine_DQuoteSsm::visit_gco_children(DQuoteSsm & self, VisitReason reason, obj<AGCObjectVisitor> gc) -> void
{
self.visit_gco_children(reason, gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DQuoteSsm.cpp */

41
xo-reader2/src/reader2/init_reader2.cpp
View file

@ -1,41 +0,0 @@
/** @file init_reader2.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "init_reader2.hpp"
#include "SetupReader2.hpp"
#include <xo/expression2/init_expression2.hpp>
#include <xo/numeric/init_numeric.hpp>
#include <xo/alloc2/CollectorTypeRegistry.hpp>
namespace xo {
using xo::scm::SetupReader2;
using xo::mm::CollectorTypeRegistry;
void
InitSubsys<S_reader2_tag>::init()
{
SetupReader2::register_facets();
CollectorTypeRegistry::instance().register_types(&SetupReader2::register_types);
}
InitEvidence
InitSubsys<S_reader2_tag>::require()
{
InitEvidence retval;
/* direct subsystem deps for xo-reader2/ */
retval ^= InitSubsys<S_expression2_tag>::require();
retval ^= InitSubsys<S_numeric_tag>::require();
/* xo-reader2/'s own initialization code */
retval ^= Subsystem::provide<S_reader2_tag>("reader2", &init);
return retval;
}
} /*namespace xo*/
/* end init_reader2.cpp */

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

@ -1,66 +0,0 @@
/** @file syntaxstatetype.cpp
*
* @author Roland Conybeare, Jan 2026
**/
#include "syntaxstatetype.hpp"
namespace xo {
namespace scm {
const char *
syntaxstatetype_descr(syntaxstatetype x) {
switch (x) {
case syntaxstatetype::invalid:
break;
case syntaxstatetype::defexpr:
return "defexpr";
case syntaxstatetype::deftypeexpr:
return "deftypeexpr";
case syntaxstatetype::lambdaexpr:
return "lambdaexpr";
case syntaxstatetype::ifelseexpr:
return "ifelseexpr";
case syntaxstatetype::sequence:
return "sequence";
case syntaxstatetype::apply:
return "apply";
case syntaxstatetype::progress:
return "progress";
case syntaxstatetype::paren:
return "paren";
case syntaxstatetype::quote:
return "quote";
case syntaxstatetype::expect_toplevel_expression_sequence:
return "expect-toplevel-expression-sequence";
case syntaxstatetype::expect_formal_arglist:
return "expect-formal-arglist";
case syntaxstatetype::expect_formal_arg:
return "expect-formal-arg";
case syntaxstatetype::expect_symbol:
return "expect-symbol";
case syntaxstatetype::expect_type:
return "expect-type";
case syntaxstatetype::expect_listtype:
return "expect-listtype";
case syntaxstatetype::expect_rhs_expression:
return "expect-rhs-expression";
case syntaxstatetype::expect_qliteral:
return "expect-qliteral";
case syntaxstatetype::expect_qlist:
return "expect-qlist";
case syntaxstatetype::expect_qarray:
return "expect-qarray";
case syntaxstatetype::expect_qdict:
return "expect-qdict";
case syntaxstatetype::N:
break;
}
return "syntaxstatetype?";
}
} /*namespace scm*/
} /*namespace xo*/
/* end syntaxstatetype.cpp */