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

xo-reader2: allow formals w/out explicit type

Browse source
This commit is contained in:
Roland Conybeare 2026-02-17 16:48:20 -05:00
commit 4a5d924676
39 changed files with 307 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

11
xo-reader2/idl/SyntaxStateMachine.json5
View file

@ -85,6 +85,17 @@
{type: "ParserStateMachine *", name: "p_psm"},
],
},
{
name: "on_parsed_formal_with_token",
doc: ["operate state machine for formal emitted by nested ssm"],
return_type: "void",
args: [
{type: "const DUniqueString *", name: "param_name"},
{type: "TypeDescr", name: "param_type"},
{type: "const Token &", name: "tk"},
{type: "ParserStateMachine *", name: "p_psm"},
],
},
{
name: "on_parsed_formal_arglist",
doc: ["consume formal arglist emitted by nested ssm"],

6
xo-reader2/include/xo/reader2/DExpectFormalArgSsm.hpp
View file

@ -79,6 +79,12 @@ namespace xo {
void on_colon_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-expectformalargssm-ssm-facet syntaxstatemachine facet methods **/
///@{

24
xo-reader2/include/xo/reader2/DExpectFormalArglistSsm.hpp
View file

@ -55,6 +55,7 @@ namespace xo {
class DExpectFormalArglistSsm : public DSyntaxStateMachine<DExpectFormalArglistSsm> {
public:
using Super = DSyntaxStateMachine<DExpectFormalArglistSsm>;
using AAllocator = xo::mm::AAllocator;
using DArena = xo::mm::DArena;
using TypeDescr = xo::reflect::TypeDescr;
using ppindentinfo = xo::print::ppindentinfo;
@ -108,6 +109,14 @@ namespace xo {
void on_parsed_formal(const DUniqueString * param_name,
TypeDescr param_type,
ParserStateMachine * p_psm);
/** update state to consume parsed formal (name,type) emitted
* by nested ssm, that's followed immediately by token @p tk.
* overall parser state in @p *p_psm
**/
void on_parsed_formal_with_token(const DUniqueString * param_name,
TypeDescr param_type,
const Token & tk,
ParserStateMachine * p_psm);
///@}
/** @defgroup scm-expectformalarglistssm-printable-facet printable facet methods **/
@ -117,6 +126,21 @@ namespace xo {
///@}
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:
/** parsing state-machine state **/
formalarglstatetype fastate_ = formalarglstatetype::argl_0;

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

@ -83,6 +83,23 @@ namespace xo {
self.get_expect_str());
}
/** Default implementation for required SyntaxStateMachine facet method
**/
void on_parsed_formal_with_token(const DUniqueString * param_name,
TypeDescr param_type,
const Token & tk,
ParserStateMachine * p_psm)
{
// starting with c++23 can use "this auto&& self" instead
Derived & self = reinterpret_cast<Derived&>(*this);
p_psm->illegal_parsed_formal_with_token(Derived::ssm_classname(),
param_name,
param_type,
tk,
self.get_expect_str());
}
/** Default implementation for required SyntaxStateMachine facet method
*
* arglist is DArray of obj<AGCObejct,DVariable>

19
xo-reader2/include/xo/reader2/ParserStateMachine.hpp
View file

@ -149,12 +149,20 @@ namespace xo {
**/
void on_parsed_typedescr(TypeDescr td);
/** update state to consume param (name, value) emitted by
/** update state to consume param (name, type) emitted by
* nested (expired) parsing state
**/
void on_parsed_formal(const DUniqueString * param_name,
TypeDescr param_type);
/** update state to consume formal parameter (name, type)
* emitted by nested (now expired) parsing state,
* with trailing token @p tk
**/
void on_parsed_formal_with_token(const DUniqueString * param_name,
TypeDescr param_type,
const Token & tk);
/** update state to consume formal arugment list
* emitted by nested (expired) parsing state
**/
@ -231,6 +239,15 @@ namespace xo {
TypeDescr param_type,
std::string_view expect_str);
/** report illegal parsed formal (param_name, param_type) from nested ssm;
* presented with immediately-following input token @p tk.
**/
void 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);
/** @p arglist stores obj<AGCObject,DVariable> pointers.
**/
void illegal_parsed_formal_arglist(std::string_view ssm_name,

2
xo-reader2/include/xo/reader2/ssm/ASyntaxStateMachine.hpp
View file

@ -67,6 +67,8 @@ public:
virtual void on_parsed_typedescr(Opaque data, TypeDescr td, ParserStateMachine * p_psm) = 0;
/** operate state machine for formal emitted by nested ssm **/
virtual void on_parsed_formal(Opaque data, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) = 0;
/** operate state machine for formal emitted by nested ssm **/
virtual void on_parsed_formal_with_token(Opaque data, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) = 0;
/** consume formal arglist emitted by nested ssm **/
virtual void on_parsed_formal_arglist(Opaque data, DArray * arglist, ParserStateMachine * p_psm) = 0;
/** update state machine for incoming parsed expression @p expr **/

1
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_Any.hpp
View file

@ -67,6 +67,7 @@ namespace scm {
[[noreturn]] void on_parsed_symbol(Opaque, std::string_view, ParserStateMachine *) override;
[[noreturn]] void on_parsed_typedescr(Opaque, TypeDescr, ParserStateMachine *) override;
[[noreturn]] void on_parsed_formal(Opaque, const DUniqueString *, TypeDescr, ParserStateMachine *) override;
[[noreturn]] void on_parsed_formal_with_token(Opaque, const DUniqueString *, TypeDescr, const Token &, ParserStateMachine *) override;
[[noreturn]] void on_parsed_formal_arglist(Opaque, DArray *, ParserStateMachine *) override;
[[noreturn]] void on_parsed_expression(Opaque, obj<AExpression>, ParserStateMachine *) override;
[[noreturn]] void on_parsed_expression_with_token(Opaque, obj<AExpression>, const Token &, ParserStateMachine *) override;

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DApplySsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DApplySsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DApplySsm & 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(DApplySsm & 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(DApplySsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DDefineSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DDefineSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DDefineSsm & 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(DDefineSsm & 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(DDefineSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectExprSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DExpectExprSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DExpectExprSsm & 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(DExpectExprSsm & 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(DExpectExprSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectFormalArgSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DExpectFormalArgSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DExpectFormalArgSsm & 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(DExpectFormalArgSsm & 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(DExpectFormalArgSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectFormalArglistSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DExpectFormalArglistSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DExpectFormalArglistSsm & 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(DExpectFormalArglistSsm & 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(DExpectFormalArglistSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectSymbolSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DExpectSymbolSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DExpectSymbolSsm & 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(DExpectSymbolSsm & 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(DExpectSymbolSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectTypeSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DExpectTypeSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DExpectTypeSsm & 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(DExpectTypeSsm & 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(DExpectTypeSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DIfElseSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DIfElseSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DIfElseSsm & 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(DIfElseSsm & 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(DIfElseSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DLambdaSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DLambdaSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DLambdaSsm & 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(DLambdaSsm & 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(DLambdaSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DParenSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DParenSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DParenSsm & 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(DParenSsm & 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(DParenSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DProgressSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DProgressSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DProgressSsm & 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(DProgressSsm & 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(DProgressSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DSequenceSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DSequenceSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DSequenceSsm & 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(DSequenceSsm & 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(DSequenceSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DToplevelSeqSsm.hpp
View file

@ -62,6 +62,8 @@ namespace xo {
static void on_parsed_typedescr(DToplevelSeqSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** operate state machine for formal emitted by nested ssm **/
static void on_parsed_formal(DToplevelSeqSsm & 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(DToplevelSeqSsm & 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(DToplevelSeqSsm & self, DArray * arglist, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/

3
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_Xfer.hpp
View file

@ -67,6 +67,9 @@ namespace scm {
void on_parsed_formal(Opaque data, const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) override {
return I::on_parsed_formal(_dcast(data), param_name, param_type, p_psm);
}
void on_parsed_formal_with_token(Opaque data, const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) override {
return I::on_parsed_formal_with_token(_dcast(data), param_name, param_type, tk, p_psm);
}
void on_parsed_formal_arglist(Opaque data, DArray * arglist, ParserStateMachine * p_psm) override {
return I::on_parsed_formal_arglist(_dcast(data), arglist, p_psm);
}

3
xo-reader2/include/xo/reader2/ssm/RSyntaxStateMachine.hpp
View file

@ -73,6 +73,9 @@ public:
void on_parsed_formal(const DUniqueString * param_name, TypeDescr param_type, ParserStateMachine * p_psm) {
return O::iface()->on_parsed_formal(O::data(), param_name, param_type, p_psm);
}
void on_parsed_formal_with_token(const DUniqueString * param_name, TypeDescr param_type, const Token & tk, ParserStateMachine * p_psm) {
return O::iface()->on_parsed_formal_with_token(O::data(), param_name, param_type, tk, p_psm);
}
void on_parsed_formal_arglist(DArray * arglist, ParserStateMachine * p_psm) {
return O::iface()->on_parsed_formal_arglist(O::data(), arglist, p_psm);
}

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

@ -97,6 +97,10 @@ namespace xo {
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:
@ -110,7 +114,6 @@ namespace xo {
case tokentype::tk_bool:
case tokentype::tk_semicolon:
case tokentype::tk_invalid:
case tokentype::tk_rightparen:
case tokentype::tk_leftbracket:
case tokentype::tk_rightbracket:
case tokentype::tk_leftbrace:
@ -159,6 +162,24 @@ namespace xo {
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)

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

@ -176,6 +176,49 @@ namespace xo {
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(argl_->at(i));
}
// update in place
this->argl_ = argl_2x;
}
this->argl_->push_back(var_o);
}
void
DExpectFormalArglistSsm::on_parsed_formal(const DUniqueString * param_name,
TypeDescr param_type,
@ -184,46 +227,37 @@ namespace xo {
if (fastate_ == formalarglstatetype::argl_1a) {
this->fastate_ = formalarglstatetype::argl_1b;
TypeRef typeref
= TypeRef::dwim(TypeRef::prefix_type::from_chars("formal"), param_type);
DVariable * var = DVariable::make(p_psm->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(&(p_psm->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);
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)

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

@ -58,6 +58,12 @@ ISyntaxStateMachine_Any::on_parsed_formal(Opaque, const DUniqueString *, TypeDes
_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
{

5
xo-reader2/src/reader2/ISyntaxStateMachine_DApplySsm.cpp
View file

@ -48,6 +48,11 @@ namespace xo {
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);

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

@ -48,6 +48,11 @@ namespace xo {
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);

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

@ -48,6 +48,11 @@ namespace xo {
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);

5
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectFormalArgSsm.cpp
View file

@ -48,6 +48,11 @@ namespace xo {
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);

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

@ -48,6 +48,11 @@ namespace xo {
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);

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

@ -48,6 +48,11 @@ namespace xo {
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);

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

@ -48,6 +48,11 @@ namespace xo {
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);

5
xo-reader2/src/reader2/ISyntaxStateMachine_DIfElseSsm.cpp
View file

@ -48,6 +48,11 @@ namespace xo {
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);

5
xo-reader2/src/reader2/ISyntaxStateMachine_DLambdaSsm.cpp
View file

@ -48,6 +48,11 @@ namespace xo {
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);

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

@ -48,6 +48,11 @@ namespace xo {
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);

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

@ -48,6 +48,11 @@ namespace xo {
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);

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

@ -48,6 +48,11 @@ namespace xo {
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);

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

@ -48,6 +48,11 @@ namespace xo {
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);

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

@ -286,6 +286,18 @@ namespace xo {
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)
{
@ -446,6 +458,33 @@ namespace xo {
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,