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

xo-reader2: parse list types + utest

Browse source
This commit is contained in:
Roland Conybeare 2026-03-11 14:13:48 -05:00
commit 46637ec16a
19 changed files with 787 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/reader2/CMakeLists.txt
View file

@ -65,6 +65,10 @@ set(SELF_SRCS
ISyntaxStateMachine_DExpectTypeSsm.cpp
IPrintable_DExpectTypeSsm.cpp
DExpectListTypeSsm.cpp
facet/ISyntaxStateMachine_DExpectListTypeSsm.cpp
facet/IPrintable_DExpectListTypeSsm.cpp
DExpectExprSsm.cpp
ISyntaxStateMachine_DExpectExprSsm.cpp
IPrintable_DExpectExprSsm.cpp

207
src/reader2/DExpectListTypeSsm.cpp Normal file
View file

@ -0,0 +1,207 @@
/** @file DExpectListTypeSsm.cpp
*
* @author Roland Conybeare, Mar 2026
**/
#include "ExpectListTypeSsm.hpp"
#include "ExpectTypeSsm.hpp"
#include "syntaxstatetype.hpp"
#include <xo/type/ListType.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_lessequal:
case tokentype::tk_greatequal:
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_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");
}
} /*namespace scm*/
} /*namespace xo*/
/* end DExpectListTypeSsm.cpp */

45
src/reader2/DExpectTypeSsm.cpp
View file

@ -4,7 +4,7 @@
**/
#include "ExpectTypeSsm.hpp"
//#include "ssm/ISyntaxStateMachine_DExpectTypeSsm.hpp"
#include "ExpectListTypeSsm.hpp"
#include "SyntaxStateMachine.hpp"
#include <xo/type/AtomicType.hpp>
#include <xo/reflect/Reflect.hpp>
@ -132,25 +132,32 @@ namespace xo {
obj<AType> type;
obj mm = p_psm->expr_alloc();
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());
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);
p_psm->pop_ssm();
p_psm->on_parsed_type(type);
}
} else {
TypeDescr td = nullptr;

28
src/reader2/facet/IPrintable_DExpectListTypeSsm.cpp Normal file
View file

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

84
src/reader2/facet/ISyntaxStateMachine_DExpectListTypeSsm.cpp Normal file
View file

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

5
src/reader2/reader2_register_facets.cpp
View file

@ -21,6 +21,7 @@
#include "ExpectFormalArgSsm.hpp"
#include "ExpectSymbolSsm.hpp"
#include "ExpectTypeSsm.hpp"
#include "ExpectListTypeSsm.hpp"
#include "ExpectExprSsm.hpp"
#include "ExpectQLiteralSsm.hpp"
#include "ExpectQListSsm.hpp"
@ -57,6 +58,7 @@ namespace xo {
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>();
@ -74,6 +76,9 @@ namespace xo {
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>();

2
src/reader2/syntaxstatetype.cpp
View file

@ -41,6 +41,8 @@ namespace xo {
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: