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

xo-interpreter2 stack: handle operator expressions w/ qliterals

Browse source
This commit is contained in:
Roland Conybeare 2026-03-02 11:05:12 +11:00
commit 906bb2a913
24 changed files with 942 additions and 51 deletions
Download patch file Download diff file Expand all files Collapse all files

20
CMakeLists.txt
View file

@ -313,6 +313,26 @@ xo_add_genfacetimpl(
# ----------------------------------------------------------------
# note: manual target; generated code committed to git
xo_add_genfacetimpl(
TARGET xo-reader2-facetimpl-syntaxstatemachine-expectqliteralssm
FACET_PKG xo_reader2
FACET SyntaxStateMachine
REPR ExpectQLiteralSsm
INPUT idl/ISyntaxStateMachine_DExpectQLiteralSsm.json5
)
# note: manual target; generated code committed to git
xo_add_genfacetimpl(
TARGET xo-reader2-facetimpl-printable-expectqliteralssm
FACET_PKG xo_printable2
FACET Printable
REPR ExpectQLiteralSsm
INPUT idl/IPrintable_DExpectQLiteralSsm.json5
)
# ----------------------------------------------------------------
xo_add_genfacet_all(xo-reader2-genfacet-all)
# ----------------------------------------------------------------

16
idl/IPrintable_DExpectQLiteralSsm.json5 Normal file
View file

@ -0,0 +1,16 @@
{
mode: "implementation",
output_cpp_dir: "src/reader2",
output_hpp_dir: "include/xo/reader2",
output_impl_subdir: "ssm",
includes: [ "<xo/printable2/Printable.hpp>",
"<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
local_types: [],
namespace1: "xo",
namespace2: "scm",
facet_idl: "idl/Printable.json5",
brief: "provide APrintable interface for DExpectQLiteralSsm",
using_doxygen: true,
repr: "DExpectQLiteralSsm",
doc: [ "implement APrintable for DExpectQLiteralSsm" ],
}

16
idl/ISyntaxStateMachine_DExpectQLiteralSsm.json5 Normal file
View file

@ -0,0 +1,16 @@
{
mode: "implementation",
output_cpp_dir: "src/reader2",
output_hpp_dir: "include/xo/reader2",
output_impl_subdir: "ssm",
includes: [ "\"SyntaxStateMachine.hpp\"",
"\"ssm/ISyntaxStateMachine_Xfer.hpp\"" ],
local_types: [ ],
namespace1: "xo",
namespace2: "scm",
facet_idl: "idl/SyntaxStateMachine.json5",
brief: "provide ASyntaxStateMachine interface for DExpectQLiteralSsm",
using_doxygen: true,
repr: "DExpectQLiteralSsm",
doc: [ "implement ASyntaxStateMachine for DExpectQLiteralSsm" ],
}

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

@ -76,6 +76,14 @@ namespace xo {
void on_leftbrace_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state for this syntax on quote token @p tk,
* with overall parser state in @p p_psm.
*
* Starts nested {progress-ssm, quote-ssm} combination.
**/
void on_quote_token(const Token & tk,
ParserStateMachine * p_psm);
/** step state machine for this syntax on incoming boolean literal token @p tkk
* with overall parser state in @p p_psm
**/
@ -160,6 +168,15 @@ namespace xo {
const Token & tk,
ParserStateMachine * p_psm);
#ifdef NOT_YET
/** update state for literal @p lit with overall state in @p p_psm.
* wraps literal as constant-expr + starts progress-ssm for possible
* operator expression.
**/
void on_quoted_literal(obj<AGCObject> lit,
ParserStateMachine * p_psm);
#endif
///@}
/** @defgroup scm-define-printable-facet printable facet methods **/
///@{

143
include/xo/reader2/DExpectQLiteralSsm.hpp Normal file
View file

@ -0,0 +1,143 @@
/** @file DExpectQLiteralSsm.hpp
*
* @author Roland Conybeare, Mar 2026
**/
#pragma once
#include "DSyntaxStateMachine.hpp"
//#include <xo/object2/DArray.hpp>
//#include <xo/arena/DArena.hpp>
namespace xo {
namespace scm {
#ifdef NOT_USING
/**
* Already in quoted-literal context
*
* #q{ }
* ^
* qliteral_0
*
* qliteral_0 --on_leftparen_token()--> push QuotedListSsm
**/
enum class formalarglstatetype {
invalid = -1,
argl_0,
argl_1a,
argl_1b,
n_formalarglstatetype,
};
extern const char *
formalarglstatetype_descr(formalarglstatetype x);
inline std::ostream &
operator<< (std::ostream & os, formalarglstatetype x) {
os << formalarglstatetype_descr(x);
return os;
}
#endif
/** @class expect_formal_arglist
* @brief parser state-machine for a formal parameter list
**/
class DExpectQLiteralSsm : public DSyntaxStateMachine<DExpectQLiteralSsm> {
public:
using Super = DSyntaxStateMachine<DExpectQLiteralSsm>;
using AAllocator = xo::mm::AAllocator;
using DArena = xo::mm::DArena;
using TypeDescr = xo::reflect::TypeDescr;
using ppindentinfo = xo::print::ppindentinfo;
using size_type = std::uint32_t;
public:
DExpectQLiteralSsm();
/** create instance, using memory from @parser_mm **/
static obj<ASyntaxStateMachine,DExpectQLiteralSsm> make(DArena & parser_mm);
static DExpectQLiteralSsm * _make(DArena & parser_mm);
/** start nested syntax for a quoted literal **/
static void start(ParserStateMachine * p_psm);
/** @defgroup scm-expectformalarglistssm-methods general methods **/
///@{
static const char * ssm_classname() { return "DExpectQLiteralSsm"; }
/** update state for f64 token @p tk, with overall parser state in @p p_psm.
* delegates to parent ssm via @ref on_quoted_literal
**/
void on_f64_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state on incoming token @p tk, with overall parser state in @p p_psm **/
void on_leftparen_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state on incoming token @p tk, with overall parser state in @p p_psm **/
void on_comma_token(const Token & tk,
ParserStateMachine * p_psm);
/** update state on incoming rightparen token @p tk, with overall parser state in @p p_psm **/
void on_rightparen_token(const Token & tk,
ParserStateMachine * p_psm);
///@}
/** @defgroup scm-expectformalarglistssm-ssm-facet syntaxstatemachine facet methods **/
///@{
/** identifies the ssm implemented here **/
syntaxstatetype ssm_type() const noexcept;
/** mnemonic for expected input (for this ssm) in current state **/
std::string_view get_expect_str() const;
/** update state on incoming token @p tk,
* with overall parser state in @p p_psm
**/
void on_token(const Token & tk,
ParserStateMachine * p_psm);
///@}
/** @defgroup scm-expectformalarglistssm-printable-facet printable facet methods **/
///@{
bool pretty(const ppindentinfo & ppii) const;
///@}
private:
/** @defgroup scm-expectformalarglistssm-impl-methods **/
///@{
/** update local state to include parsed formal (param_name, param_type).
* If stack memory needed, get from @p parser_alloc.
* Lifetime until formal arglist completely parsed
**/
void _accept_formal(obj<AAllocator> expr_alloc,
DArena & parser_alloc,
const DUniqueString * param_name,
TypeDescr param_type);
///@}
private:
#ifdef NOT_USING
/** parsing state-machine state **/
formalarglstatetype fastate_ = formalarglstatetype::argl_0;
/** populate with (parameter-name, parameter-type) list
* as they're encountered.
*
* Not using flexible array here since we don't know size at construction time
**/
DArray * argl_ = nullptr;
#endif
};
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectQLiteralSsm.hpp */

17
include/xo/reader2/DQuoteSsm.hpp
View file

@ -100,6 +100,13 @@ namespace xo {
/** @defgroup scm-parenssm-admin-methods admin methods **/
///@{
/** update ssm for incoming quote token @p tk.
* with overall parser state in @p p_psm.
* advances from quote_0 -> quote_1. Otherwise error
**/
void on_quote_token(const Token & tk,
ParserStateMachine * p_psm);
/** update ssm state for incoming leftparen token @p tk,
* with overall parser state in @p p_psm
**/
@ -129,17 +136,9 @@ namespace xo {
/** update ssm for expression @p expr (emitted by nested ssm),
* with overall parser state in @p p_psm
**/
void on_parsed_expression(obj<AExpression> expr,
void on_quoted_literal(obj<AGCObject> literal,
ParserStateMachine * p_psm);
/** update ssm for expression @p expr (emitted by nested ssm)
* that's immediately followed by token @p tk
* with overall parser state in @p p_psm
**/
void on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk,
ParserStateMachine * p_psmn);
///@}
/** @defgroup scm-parenssm-printable-facet printable facet methods **/
///@{

5
include/xo/reader2/DToplevelSeqSsm.hpp
View file

@ -119,6 +119,11 @@ namespace xo {
**/
void on_leftparen_token(const Token & tk, ParserStateMachine * p_psm);
/** update ssm for incoming quote token @p tk, overall parser state in @p p_psm
* starts nested syntax for quoted literal
**/
void on_quote_token(const Token & tk, ParserStateMachine * p_psm);
/** update state for this syntax on parsed expression @p expr
* from nested ssm.
* overall parser state in @p p_psm

12
include/xo/reader2/ExpectQLiteralSsm.hpp Normal file
View file

@ -0,0 +1,12 @@
/** @file ExpectQLiteralSsm.hpp
*
* @author Roland Conybeare, Mar 2026
**/
#pragma once
#include "DExpectQLiteralSsm.hpp"
#include "ssm/ISyntaxStateMachine_DExpectQLiteralSsm.hpp"
#include "ssm/IPrintable_DExpectQLiteralSsm.hpp"
/* end ExpectQLiteralSsm.hpp */

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

@ -186,6 +186,9 @@ namespace xo {
void on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk);
/** update state to consume quoted literal @p lit **/
void on_quoted_literal(obj<AGCObject> lit);
/** update state to respond to input token @p tk.
* record output (if any) in @ref result_
**/

62
include/xo/reader2/ssm/IPrintable_DExpectQLiteralSsm.hpp Normal file
View file

@ -0,0 +1,62 @@
/** @file IPrintable_DExpectQLiteralSsm.hpp
*
* 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_repr.hpp.j2]
* 3. idl for facet methods
* [idl/IPrintable_DExpectQLiteralSsm.json5]
**/
#pragma once
#include "Printable.hpp"
#include <xo/printable2/Printable.hpp>
#include <xo/printable2/detail/IPrintable_Xfer.hpp>
#include "DExpectQLiteralSsm.hpp"
namespace xo { namespace scm { class IPrintable_DExpectQLiteralSsm; } }
namespace xo {
namespace facet {
template <>
struct FacetImplementation<xo::print::APrintable,
xo::scm::DExpectQLiteralSsm>
{
using ImplType = xo::print::IPrintable_Xfer
<xo::scm::DExpectQLiteralSsm,
xo::scm::IPrintable_DExpectQLiteralSsm>;
};
}
}
namespace xo {
namespace scm {
/** @class IPrintable_DExpectQLiteralSsm
**/
class IPrintable_DExpectQLiteralSsm {
public:
/** @defgroup scm-printable-dexpectqliteralssm-type-traits **/
///@{
using ppindentinfo = xo::print::APrintable::ppindentinfo;
using Copaque = xo::print::APrintable::Copaque;
using Opaque = xo::print::APrintable::Opaque;
///@}
/** @defgroup scm-printable-dexpectqliteralssm-methods **/
///@{
// const methods
/** Pretty-printing support for this object.
See [xo-indentlog/xo/indentlog/pretty.hpp] **/
static bool pretty(const DExpectQLiteralSsm & self, const ppindentinfo & ppii);
// non-const methods
///@}
};
} /*namespace scm*/
} /*namespace xo*/
/* end */

82
include/xo/reader2/ssm/ISyntaxStateMachine_DExpectQLiteralSsm.hpp Normal file
View file

@ -0,0 +1,82 @@
/** @file ISyntaxStateMachine_DExpectQLiteralSsm.hpp
*
* 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_repr.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DExpectQLiteralSsm.json5]
**/
#pragma once
#include "SyntaxStateMachine.hpp"
#include "SyntaxStateMachine.hpp"
#include "ssm/ISyntaxStateMachine_Xfer.hpp"
#include "DExpectQLiteralSsm.hpp"
namespace xo { namespace scm { class ISyntaxStateMachine_DExpectQLiteralSsm; } }
namespace xo {
namespace facet {
template <>
struct FacetImplementation<xo::scm::ASyntaxStateMachine,
xo::scm::DExpectQLiteralSsm>
{
using ImplType = xo::scm::ISyntaxStateMachine_Xfer
<xo::scm::DExpectQLiteralSsm,
xo::scm::ISyntaxStateMachine_DExpectQLiteralSsm>;
};
}
}
namespace xo {
namespace scm {
/** @class ISyntaxStateMachine_DExpectQLiteralSsm
**/
class ISyntaxStateMachine_DExpectQLiteralSsm {
public:
/** @defgroup scm-syntaxstatemachine-dexpectqliteralssm-type-traits **/
///@{
using TypeDescr = xo::scm::ASyntaxStateMachine::TypeDescr;
using AGCObject = xo::scm::ASyntaxStateMachine::AGCObject;
using Copaque = xo::scm::ASyntaxStateMachine::Copaque;
using Opaque = xo::scm::ASyntaxStateMachine::Opaque;
///@}
/** @defgroup scm-syntaxstatemachine-dexpectqliteralssm-methods **/
///@{
// const methods
/** identify a type of syntax state machine **/
static syntaxstatetype ssm_type(const DExpectQLiteralSsm & self) noexcept;
/** text describing expected/allowed input to this ssm in current state **/
static std::string_view get_expect_str(const DExpectQLiteralSsm & self) noexcept;
// non-const methods
/** operate state machine for incoming token @p tk **/
static void on_token(DExpectQLiteralSsm & self, const Token & tk, ParserStateMachine * p_psm);
/** update stat machine for incoming parsed symbol @p sym **/
static void on_parsed_symbol(DExpectQLiteralSsm & self, std::string_view sym, ParserStateMachine * p_psm);
/** operate state machine for incoming type description @p td **/
static void on_parsed_typedescr(DExpectQLiteralSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DExpectQLiteralSsm & self, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal_with_token(DExpectQLiteralSsm & self, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm);
/** consume formal arglist emitted by nested ssm **/
static void on_parsed_formal_arglist(DExpectQLiteralSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for nested parsed expression @p expr **/
static void on_parsed_expression(DExpectQLiteralSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
/** update state machine @p p_psm for incoming parsed expression @p expr followed by token @p tk **/
static void on_parsed_expression_with_token(DExpectQLiteralSsm & self, obj<AExpression> expr, const Token & tk, ParserStateMachine * p_psm);
/** update state machine for nested quoted literal @p lit **/
static void on_quoted_literal(DExpectQLiteralSsm & self, obj<AGCObject> lit, ParserStateMachine * p_psm);
///@}
};
} /*namespace scm*/
} /*namespace xo*/
/* end */

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

@ -60,6 +60,9 @@ namespace xo {
/** expecting a rhs expression. See @ref DExpectExprSsm **/
expect_rhs_expression,
/** expecting a quoted literal. See @ref DExpectQLiteralSsm **/
expect_qliteral,
/** comes lasts, counts number of valid enums **/
N
};

5
src/reader2/CMakeLists.txt
View file

@ -65,6 +65,10 @@ set(SELF_SRCS
ISyntaxStateMachine_DExpectExprSsm.cpp
IPrintable_DExpectExprSsm.cpp
DExpectQLiteralSsm.cpp
ISyntaxStateMachine_DExpectQLiteralSsm.cpp
IPrintable_DExpectQLiteralSsm.cpp
DProgressSsm.cpp
ISyntaxStateMachine_DProgressSsm.cpp
IPrintable_DProgressSsm.cpp
@ -72,6 +76,7 @@ set(SELF_SRCS
DQuoteSsm.cpp
ISyntaxStateMachine_DQuoteSsm.cpp
IPrintable_DQuoteSsm.cpp
)
xo_add_shared_library4(${SELF_LIB} ${PROJECT_NAME}Targets ${PROJECT_VERSION} 1 ${SELF_SRCS})

38
src/reader2/DExpectExprSsm.cpp
View file

@ -7,10 +7,11 @@
#include "ParserStateMachine.hpp"
#include "ParserStack.hpp"
#include "SyntaxStateMachine.hpp"
#include "ssm/ISyntaxStateMachine_DProgressSsm.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>
@ -22,14 +23,10 @@
#include <xo/facet/facet_implementation.hpp>
#ifdef NOT_YET
#include "exprstatestack.hpp"
#include "define_xs.hpp"
#include "lambda_xs.hpp"
#include "if_else_xs.hpp"
#include "paren_xs.hpp"
#include "sequence_xs.hpp"
#include "progress_xs.hpp"
#include "xo/expression/pretty_expression.hpp"
#endif
namespace xo {
@ -140,6 +137,10 @@ namespace xo {
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;
@ -169,7 +170,6 @@ namespace xo {
case tokentype::tk_singleassign:
case tokentype::tk_colon:
case tokentype::tk_semicolon:
case tokentype::tk_quote:
case tokentype::tk_leftbracket:
case tokentype::tk_rightbracket:
case tokentype::tk_rightbrace:
@ -344,6 +344,17 @@ namespace xo {
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)
@ -500,6 +511,21 @@ namespace xo {
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
{

256
src/reader2/DExpectQLiteralSsm.cpp Normal file
View file

@ -0,0 +1,256 @@
/* @file DExpectQLiteralSsm.cpp
*
* @author Roland Conybeare, Mar 2026
*/
#include "ExpectQLiteralSsm.hpp"
#include <xo/object2/Float.hpp>
//#include "DExpectFormalArgSsm.hpp"
//#include "ssm/ISyntaxStateMachine_DExpectFormalArgSsm.hpp"
//#include <xo/expression2/DVariable.hpp>
//#include <xo/expression2/detail/IGCObject_DVariable.hpp>
//#include <xo/printable2/Printable.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::AGCObject;
// using xo::mm::AAllocator;
// using xo::facet::FacetRegistry;
// using xo::reflect::typeseq;
namespace scm {
#ifdef NOT_USING
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";
}
#endif
DExpectQLiteralSsm::DExpectQLiteralSsm()
{}
DExpectQLiteralSsm *
DExpectQLiteralSsm::_make(DArena & 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_for<DExpectQLiteralSsm>();
return new (mem) DExpectQLiteralSsm();
}
obj<ASyntaxStateMachine,DExpectQLiteralSsm>
DExpectQLiteralSsm::make(DArena & arena)
{
obj<ASyntaxStateMachine,DExpectQLiteralSsm> retval(_make(arena));
return retval;
}
void
DExpectQLiteralSsm::start(ParserStateMachine * p_psm)
{
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
p_psm->push_ssm(ckp, DExpectQLiteralSsm::make(p_psm->parser_alloc()));
}
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_leftparen:
case tokentype::tk_comma:
case tokentype::tk_rightparen:
case tokentype::tk_lambda:
case tokentype::tk_def:
case tokentype::tk_if:
case tokentype::tk_symbol:
case tokentype::tk_colon:
case tokentype::tk_singleassign:
case tokentype::tk_string:
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_lessequal:
case tokentype::tk_greatequal:
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_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);
}
#ifdef NOT_YET
void
DExpectQLiteralSsm::_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 DExpectQLiteralSsm 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(argl_->at(i));
}
// update in place
this->argl_ = argl_2x;
}
this->argl_->push_back(var_o);
}
#endif
#ifdef NOT_YET
void
DExpectQLiteralSsm::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
DExpectQLiteralSsm::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
DExpectQLiteralSsm::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);
}
#endif
bool
DExpectQLiteralSsm::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct(ppii,
"DExpectQLiteralSsm",
refrtag("expect", this->get_expect_str()));
}
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectQLiteralSsm.cpp */

4
src/reader2/DProgressSsm.cpp
View file

@ -3,8 +3,7 @@
* @author Roland Conybeare, Jan 2026
**/
#include "DProgressSsm.hpp"
#include "ssm/ISyntaxStateMachine_DProgressSsm.hpp"
#include "ProgressSsm.hpp"
#include "DExpectExprSsm.hpp"
#include "ssm/ISyntaxStateMachine_DExpectExprSsm.hpp"
@ -189,6 +188,7 @@ namespace xo {
start(parser_mm, lhs, optype::invalid, p_psm);
}
void
DProgressSsm::start(DArena & parser_mm,
ParserStateMachine * p_psm)

55
src/reader2/DQuoteSsm.cpp
View file

@ -4,8 +4,9 @@
**/
#include "QuoteSsm.hpp"
#include "ExpectExprSsm.hpp"
#include "ExpectQLiteralSsm.hpp"
#include "syntaxstatetype.hpp"
#include <xo/expression2/Constant.hpp>
//#include <string_view>
namespace xo {
@ -88,6 +89,10 @@ namespace xo {
{
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;
@ -108,7 +113,6 @@ namespace xo {
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:
@ -143,15 +147,25 @@ namespace xo {
}
void
DQuoteSsm::on_leftbrace_token(const Token & tk,
ParserStateMachine * p_psm)
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;
}
assert(false);
//DExpectQLiteralSsm::start(p_psm);
//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);
@ -173,41 +187,24 @@ namespace xo {
}
void
DQuoteSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)
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_ = expr;
this->expr_ = DConstant::make(p_psm->expr_alloc(), literal);
return;
}
Super::on_parsed_expression(expr, p_psm);
}
void
DQuoteSsm::on_parsed_expression_with_token(obj<AExpression> expr,
const Token & tk,
ParserStateMachine * p_psm)
{
if (quote_xst_.code() == QuoteXst::code::quote_2) {
this->quote_xst_ = QuoteXst(QuoteXst::code::quote_3);
this->expr_ = expr;
this->on_token(tk, p_psm);
return;
}
Super::on_parsed_expression(expr, p_psm);
Super::illegal_quoted_literal(literal, p_psm);
}
bool
DQuoteSsm::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct(ppii,
"DParenSsm",
"DQuoteSsm",
refrtag("quote_xst", quote_xst_),
refrtag("expect", this->get_expect_str()));
}

33
src/reader2/DToplevelSeqSsm.cpp
View file

@ -9,12 +9,13 @@
#include "DLambdaSsm.hpp"
#include "ProgressSsm.hpp"
#include "DIfElseSsm.hpp"
#include "QuoteSsm.hpp"
#include "ParenSsm.hpp"
#include "ExpectExprSsm.hpp"
#include "VarRef.hpp"
#include <xo/expression2/DConstant.hpp>
#include <xo/expression2/detail/IExpression_DConstant.hpp>
#include <xo/expression2/Constant.hpp>
//#include <xo/expression2/detail/IExpression_DConstant.hpp>
#include <xo/object2/DString.hpp>
#include <xo/object2/string/IGCObject_DString.hpp>
@ -160,9 +161,12 @@ namespace xo {
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_quote:
case tokentype::tk_rightparen:
case tokentype::tk_leftbracket:
case tokentype::tk_rightbracket:
@ -424,6 +428,29 @@ namespace xo {
Super::on_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::on_token(tk, p_psm);
}
void
DToplevelSeqSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)

28
src/reader2/IPrintable_DExpectQLiteralSsm.cpp Normal file
View file

@ -0,0 +1,28 @@
/** @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 */

79
src/reader2/ISyntaxStateMachine_DExpectQLiteralSsm.cpp Normal file
View file

@ -0,0 +1,79 @@
/** @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_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);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectQLiteralSsm.cpp */

6
src/reader2/ParserStateMachine.cpp
View file

@ -330,6 +330,12 @@ namespace xo {
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)
{

9
src/reader2/reader2_register_facets.cpp
View file

@ -13,11 +13,13 @@
#include "ApplySsm.hpp"
#include "SequenceSsm.hpp"
#include "ParenSsm.hpp"
#include "QuoteSsm.hpp"
#include "ExpectFormalArglistSsm.hpp"
#include "ExpectFormalArgSsm.hpp"
#include "ExpectSymbolSsm.hpp"
#include "ExpectTypeSsm.hpp"
#include "ExpectExprSsm.hpp"
#include "ExpectQLiteralSsm.hpp"
#include "ProgressSsm.hpp"
#include "SyntaxStateMachine.hpp"
@ -75,6 +77,12 @@ namespace xo {
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>();
// misc types showing up in aux arena
TypeRegistry::register_type<SchematikaParser>();
// misc types showing up in parser stack arena
@ -91,6 +99,7 @@ namespace xo {
log && log(xtag("DExpectExprSsm.tseq", typeseq::id<DExpectExprSsm>()));
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;

2
src/reader2/syntaxstatetype.cpp
View file

@ -41,6 +41,8 @@ namespace xo {
return "expect-type";
case syntaxstatetype::expect_rhs_expression:
return "expect-rhs-expression";
case syntaxstatetype::expect_qliteral:
return "expect-qliteral";
case syntaxstatetype::N:
break;
}

82
utest/SchematikaParser.test.cpp
View file

@ -849,7 +849,7 @@ namespace xo {
{
const auto & testname = Catch::getResultCapture().getCurrentTestName();
constexpr bool c_debug_flag = true;
constexpr bool c_debug_flag = false;
scope log(XO_DEBUG(c_debug_flag),
xtag("test", testname));
@ -1151,7 +1151,7 @@ namespace xo {
const auto & testname = Catch::getResultCapture().getCurrentTestName();
constexpr bool c_debug_flag = true;
constexpr bool c_debug_flag = false;
scope log(XO_DEBUG(c_debug_flag), xtag("test", testname));
ParserFixture fixture(testname, c_debug_flag);
@ -1203,6 +1203,84 @@ namespace xo {
log && fixture.log_memory_layout(&log);
}
TEST_CASE("SchematikaParser-batch-qliteral1", "[reader2][SchematikaParser]")
{
// top-level recursive function definition
const auto & testname = Catch::getResultCapture().getCurrentTestName();
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag), xtag("test", testname));
ParserFixture fixture(testname, c_debug_flag);
auto & parser = *(fixture.parser_);
parser.begin_interactive_session();
/** Walkthrough parsing input equivalent to:
*
* #q{ 4.5 } ;
* ^ ^ ^ ^ ^
* 0 1 2 3 4
**/
std::vector<Token> tk_v{
/* [ 0] */ Token::quote_token(),
/* [ 1] */ Token::leftbrace_token(),
/* [ 2] */ Token::f64_token("4.5"),
/* [ 3] */ Token::rightbrace_token(),
/* [ 4] */ Token::semicolon_token(),
};
utest_tokenizer_loop(&parser, tk_v, c_debug_flag);
log && fixture.log_memory_layout(&log);
}
TEST_CASE("SchematikaParser-batch-qliteral2", "[reader2][SchematikaParser]")
{
// top-level recursive function definition
const auto & testname = Catch::getResultCapture().getCurrentTestName();
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag), xtag("test", testname));
ParserFixture fixture(testname, c_debug_flag);
auto & parser = *(fixture.parser_);
parser.begin_interactive_session();
/** Walkthrough parsing input equivalent to:
*
* #q{ 4.5 } + #q { 7.2 };
* ^ ^ ^ ^ ^ ^ ^ ^ ^^
* 0 1 2 3 4 5 6 7 8|
* 9
**/
std::vector<Token> tk_v{
/* [ 0] */ Token::quote_token(),
/* [ 1] */ Token::leftbrace_token(),
/* [ 2] */ Token::f64_token("4.5"),
/* [ 3] */ Token::rightbrace_token(),
/* [ 4] */ Token::plus_token(),
/* [ 5] */ Token::quote_token(),
/* [ 6] */ Token::leftbrace_token(),
/* [ 7] */ Token::f64_token("7.2"),
/* [ 8] */ Token::rightbrace_token(),
/* [ 9] */ Token::semicolon_token(),
};
utest_tokenizer_loop(&parser, tk_v, c_debug_flag);
log && fixture.log_memory_layout(&log);
}
} /*namespace ut*/
} /*namespace xo*/