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

xo-reader2: streamline DExpectSymbolSsm w/ DSyntaxStateMachine

Browse source
This commit is contained in:
Roland Conybeare 2026-01-30 13:38:43 -05:00
commit 8b55483991
3 changed files with 14 additions and 280 deletions
Download patch file Download diff file Expand all files Collapse all files

110
xo-reader2/include/xo/reader2/DExpectSymbolSsm.hpp
View file

@ -5,8 +5,7 @@
#pragma once
#include "ParserStateMachine.hpp"
//#include "SyntaxStateMachine.hpp"
#include "DSyntaxStateMachine.hpp"
#include "syntaxstatetype.hpp"
#include <xo/indentlog/print/ppindentinfo.hpp>
#include <xo/facet/obj.hpp>
@ -19,8 +18,9 @@ namespace xo {
* For example:
* - lhs in a define-expression
**/
class DExpectSymbolSsm {
class DExpectSymbolSsm : public DSyntaxStateMachine<DExpectSymbolSsm> {
public:
using Super = DSyntaxStateMachine<DExpectSymbolSsm>;
using DArena = xo::mm::DArena;
using TypeDescr = xo::reflect::TypeDescr;
using ppindentinfo = xo::print::ppindentinfo;
@ -46,6 +46,8 @@ namespace xo {
static void on_symbol_token(const Token & tk,
ParserStateMachine * p_psm);
const char * ssm_classname() const noexcept { return "DExpectSymbolSsm"; }
/** @defgroup scm-expectsymbol-ssm-facet syntaxstatemachine facet methods **/
///@{
@ -57,114 +59,12 @@ namespace xo {
**/
std::string_view get_expect_str() const noexcept;
/** update state for this syntax after parsing a symbol @p sym;
* overall parser state in @p p_psm.
*
* NOTE:
* might not be obvious that this is unreachable.
* DExpectSymbolSsm converts a symbol token,
* and delivers it to parent ssm using this entry point.
* This method would only be called if consecutive
* DExpectSymbolSsm instances on parser stack;
* which scenario never occurs in Schematika syntax
**/
void on_parsed_symbol(std::string_view sym,
ParserStateMachine * p_psm);
/** update state for this syntax after parsing a type-description @p td
* in nested state machine.
* (provided to satisfy ASyntaxStateMachine api. not reachable)
**/
void on_parsed_typedescr(TypeDescr td,
ParserStateMachine * p_psm);
/** update state to consume param (name, value) emitted
* by nested ssm
**/
void on_parsed_formal(const DUniqueString * param_name,
TypeDescr param_type,
ParserStateMachine * p_psm);
/** consume formal params @p arglist from completed nested ssm,
* with overall parser state in @p p_psm.
**/
void on_parsed_formal_arglist(DArray * arglist,
ParserStateMachine * p_psm);
/** update state for this syntax after parsing an expression @p expr
* in nested state machine.
* (provided to satisfy ASyntaxStateMachine api. not reachable)
**/
void on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm);
/** update state for this syntax after parsing an expression @p expr
* followed by semicolon in nested state machine.
* (provided to satisfy ASyntaxStateMachine api. not reachable)
**/
void on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm);
/** operate state machine for this syntax on incoming token @p tk
* with overall parser state in @p p_psm
**/
void on_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state for this syntax on incoming token @p tk,
* overall parser state in @p p_psm.
**/
void on_def_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state for this syntax on incoming token @p tk,
* overall parser state in @p p_psm
**/
void on_if_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state for this syntax on incoming colon token @p tk,
* overall parser state in @p p_psm
**/
void on_colon_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state for this syntax on incoming singleassign token @p tk,
* overall parser state in @p p_psm
**/
void on_singleassign_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state for this syntax on incoming string token @p tk,
* overall parser state in @p p_psm
**/
void on_string_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state for this syntax on incoming f64 token @p tk,
* overall parser state in @p p_psm
**/
void on_f64_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state for this syntax on incoming i64 token @p tk,
* overall parser state in @p p_psm
**/
void on_i64_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state for this syntax on incoming bool token @p tk,
* overall parser state in @p p_psm
**/
void on_bool_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state for this syntax on incoming semicolon token @p tk,
* overall parser state in @p p_psm
**/
void on_semicolon_token(const Token & tk,
ParserStateMachine * p_psm);
///@}
/** @defgroup scm-expectsymbol-printable-facet printable facet methods **/
///@{

1
xo-reader2/include/xo/reader2/DSyntaxStateMachine.hpp
View file

@ -6,6 +6,7 @@
#pragma once
#include "SyntaxStateMachine.hpp"
#include "ParserStateMachine.hpp"
#include <xo/object2/DArray.hpp>
namespace xo {

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

@ -55,62 +55,6 @@ namespace xo {
return "symbol";
}
void
DExpectSymbolSsm::on_parsed_symbol(std::string_view sym,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_symbol("DExpectSymbolSsm::on_parsed_symbol",
sym,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_parsed_typedescr(TypeDescr td,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_typedescr("DExpectSymbolSsm::on_parsed_typedescr",
td,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_parsed_formal(const DUniqueString * param_name,
TypeDescr param_type,
ParserStateMachine * p_psm)
{
p_psm->illegal_parsed_formal("DExpectSymbolSsm::on_parsed_formal",
param_name,
param_type,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_parsed_formal_arglist(DArray * arglist,
ParserStateMachine * p_psm)
{
p_psm->illegal_parsed_formal_arglist("DExpectSymbolSsm::on_parsed_formal_arglist",
arglist,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
p_psm->illegal_parsed_expression("DExpectSymbolSsm::on_parsed_expression",
expr,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
p_psm->illegal_parsed_expression("DExpectSymbolSsm::on_parsed_expression_with_semicolon",
expr,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_token(const Token & tk,
ParserStateMachine * p_psm)
@ -120,46 +64,19 @@ namespace xo {
switch (tk.tk_type()) {
case tokentype::tk_symbol:
this->on_symbol_token(tk, p_psm);
break;
case tokentype::tk_def:
this->on_def_token(tk, p_psm);
break;
case tokentype::tk_if:
this->on_if_token(tk, p_psm);
break;
case tokentype::tk_colon:
this->on_colon_token(tk, p_psm);
break;
case tokentype::tk_singleassign:
this->on_singleassign_token(tk, p_psm);
break;
case tokentype::tk_string:
this->on_string_token(tk, p_psm);
break;
case tokentype::tk_f64:
this->on_f64_token(tk, p_psm);
break;
case tokentype::tk_i64:
this->on_i64_token(tk, p_psm);
break;
case tokentype::tk_bool:
this->on_bool_token(tk, p_psm);
break;
case tokentype::tk_semicolon:
this->on_semicolon_token(tk, p_psm);
break;
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_if:
case tokentype::tk_singleassign:
case tokentype::tk_colon:
case tokentype::tk_semicolon:
case tokentype::tk_leftparen:
case tokentype::tk_rightparen:
case tokentype::tk_leftbracket:
@ -189,12 +106,10 @@ namespace xo {
case tokentype::tk_in:
case tokentype::tk_end:
case tokentype::N:
p_psm->illegal_input_on_token("DExpectSymbolSsm::on_token",
tk,
this->get_expect_str());
break;
}
Super::on_token(tk, p_psm);
}
void
@ -214,91 +129,9 @@ namespace xo {
* the o.g. symbol-requester
*/
p_psm->pop_ssm();
p_psm->on_parsed_symbol(std::string_view(tk.text()));
}
void
DExpectSymbolSsm::on_def_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectSymbolSsm::on_def_token",
tk,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_if_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectSymbolSsm::on_if_token",
tk,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_colon_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectSymbolSsm::on_colon_token",
tk,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_singleassign_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectSymbolSsm::on_singleassign_token",
tk,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_string_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectSymbolSsm::on_string_token",
tk,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_f64_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectSymbolSsm::on_f64_token",
tk,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_i64_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectSymbolSsm::on_i64_token",
tk,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_bool_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectSymbolSsm::on_bool_token",
tk,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_semicolon_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectSymbolSsm::on_semicolon_token",
tk,
this->get_expect_str());
}
bool
DExpectSymbolSsm::pretty(const ppindentinfo & ppii) const
{