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

xo-reader2: + ExpectSymbolSsm + SyntaxStateMachine.on_parsed_symbol

Browse source
This commit is contained in:
Roland Conybeare 2026-01-19 11:32:39 -05:00
commit 83ef04c250
28 changed files with 537 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -17,6 +17,9 @@ set(SELF_SRCS
DDefineSsm.cpp
ISyntaxStateMachine_DDefineSsm.cpp
DExpectSymbolSsm.cpp
ISyntaxStateMachine_DExpectSymbolSsm.cpp
reader2_register_facets.cpp
reader2_register_types.cpp
)

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

@ -46,12 +46,7 @@ namespace xo {
// ----- define_xs -----
#ifdef NOT_YET
std::unique_ptr<define_xs>
define_xs::make() {
return std::make_unique<define_xs>(define_xs(DefineExprAccess::make_empty()));
}
#endif
// DDefineSsm::make
// DDefineSsm::start
@ -410,6 +405,15 @@ namespace xo {
return "?expect";
}
void
DDefineSsm::on_parsed_symbol(std::string_view sym,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_symbol("DDefineSsm::on_parsed_symbol",
sym,
this->get_expect_str());
}
void
DDefineSsm::on_def_token(const Token & tk,
ParserStateMachine * p_psm)

109
xo-reader2/src/reader2/DExpectSymbolSsm.cpp Normal file
View file

@ -0,0 +1,109 @@
/** @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();
}
void
DExpectSymbolSsm::start(DArena & parser_alloc,
ParserStateMachine * p_psm)
{
DExpectSymbolSsm * sym_ssm
= DExpectSymbolSsm::make(parser_alloc);
// note:
// relying on [ISyntaxStateMachine_DExpectedSymbolSsm.hpp]
//
obj<ASyntaxStateMachine> ssm
= with_facet<ASyntaxStateMachine>::mkobj(sym_ssm);
p_psm->push_ssm(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_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()));
}
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_parsed_symbol(std::string_view sym,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_symbol("DExpectSymbolSsm::on_parsed_symbol",
sym,
this->get_expect_str());
}
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectSymbolSsm.cpp */

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

@ -109,6 +109,15 @@ namespace xo {
break;
}
}
void
DExprSeqState::on_parsed_symbol(std::string_view sym,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_symbol("DExprSeqState::on_parsed_symbol",
sym,
this->get_expect_str());
}
} /*namespace scm*/
} /*namespace xo*/

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

@ -34,6 +34,12 @@ ISyntaxStateMachine_Any::_valid
// nonconst methods
auto
ISyntaxStateMachine_Any::on_parsed_symbol(Opaque, std::string_view, ParserStateMachine *) -> void
{
_fatal();
}
auto
ISyntaxStateMachine_Any::on_def_token(Opaque, const Token &, ParserStateMachine *) -> void
{

23
xo-reader2/src/reader2/ISyntaxStateMachine_DDefineSsm.cpp
View file

@ -16,30 +16,29 @@
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DDefineSsm::ssm_type(const DDefineSsm & self) noexcept
-> syntaxstatetype
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
ISyntaxStateMachine_DDefineSsm::get_expect_str(const DDefineSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DDefineSsm::on_def_token(DDefineSsm & self,
const Token & tk,
ParserStateMachine * ps_psm) -> void
ISyntaxStateMachine_DDefineSsm::on_parsed_symbol(DDefineSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_def_token(tk, ps_psm);
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DDefineSsm::on_if_token(DDefineSsm & self,
const Token & tk,
ParserStateMachine * p_psm) -> void
ISyntaxStateMachine_DDefineSsm::on_def_token(DDefineSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_def_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DDefineSsm::on_if_token(DDefineSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_if_token(tk, p_psm);
}
@ -47,4 +46,4 @@ namespace xo {
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DDefineSsm.cpp */
/* end ISyntaxStateMachine_DDefineSsm.cpp */

49
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectSymbolSsm.cpp Normal file
View file

@ -0,0 +1,49 @@
/** @file ISyntaxStateMachine_DExpectSymbolSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [/Users/roland/proj/xo-umbrella2/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_parsed_symbol(DExpectSymbolSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::on_def_token(DExpectSymbolSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_def_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::on_if_token(DExpectSymbolSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_if_token(tk, p_psm);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExpectSymbolSsm.cpp */

15
xo-reader2/src/reader2/ISyntaxStateMachine_DExprSeqState.cpp
View file

@ -28,16 +28,17 @@ namespace xo {
}
auto
ISyntaxStateMachine_DExprSeqState::on_def_token(DExprSeqState & self,
const Token & tk,
ParserStateMachine * p_psm) -> void
ISyntaxStateMachine_DExprSeqState::on_parsed_symbol(DExprSeqState & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DExprSeqState::on_def_token(DExprSeqState & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_def_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DExprSeqState::on_if_token(DExprSeqState & self,
const Token & tk,
ParserStateMachine * p_psm) -> void
ISyntaxStateMachine_DExprSeqState::on_if_token(DExprSeqState & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_if_token(tk, p_psm);
}
@ -45,4 +46,4 @@ namespace xo {
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DExprSeqState.cpp */
/* end ISyntaxStateMachine_DExprSeqState.cpp */

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

@ -10,21 +10,35 @@ namespace xo {
using xo::facet::typeseq;
namespace scm {
ParserStack::ParserStack(obj<ASyntaxStateMachine> ssm,
ParserStack::ParserStack(DArena::Checkpoint ckp,
obj<ASyntaxStateMachine> ssm,
ParserStack * parent)
: ssm_{ssm}, parent_{parent}
: ckp_{ckp}, ssm_{ssm}, parent_{parent}
{}
ParserStack *
ParserStack::push(ParserStack * stack,
obj<AAllocator> mm,
DArena & mm,
obj<ASyntaxStateMachine> ssm)
{
DArena::Checkpoint ckp = mm.checkpoint();
void * mem = mm.alloc(typeseq::id<ParserStack>(),
sizeof(ParserStack));
return new (mem) ParserStack(ssm, stack);
return new (mem) ParserStack(ckp, ssm, stack);
}
ParserStack *
ParserStack::pop(ParserStack * stack,
DArena & mm)
{
assert(stack);
mm.restore(stack->ckp());
return stack->parent();
}
} /*namespace scm*/

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

@ -46,9 +46,7 @@ namespace xo {
assert(stack_ == nullptr);
auto alloc = with_facet<AAllocator>::mkobj(&parser_alloc_);
this->stack_ = ParserStack::push(nullptr /*stack*/, alloc, ssm);
this->stack_ = ParserStack::push(nullptr /*stack*/, parser_alloc_, ssm);
this->parser_alloc_ckp_ = parser_alloc_.checkpoint();
}
@ -59,9 +57,17 @@ namespace xo {
// note: using parser_alloc_ for parser stack, since stacklike behavior
auto alloc = with_facet<AAllocator>::mkobj(&parser_alloc_);
this->stack_ = ParserStack::push(stack_, parser_alloc_, ssm);
}
this->stack_ = ParserStack::push(stack_, alloc, ssm);
void
ParserStateMachine::pop_ssm()
{
scope log(XO_DEBUG(debug_flag_));
assert(this->stack_);
this->stack_ = ParserStack::pop(stack_, parser_alloc_);
}
void
@ -81,6 +87,16 @@ namespace xo {
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_token(const Token & tk)
{
@ -194,6 +210,29 @@ namespace xo {
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);
}
} /*namespace scm*/
} /*namespace xo*/