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

xo-expression2 xo-reader2 DSequenceExpr, DSequenceSsm [WIP]

Browse source
This commit is contained in:
Roland Conybeare 2026-01-30 20:08:41 -05:00
commit bcd95502d2
4 changed files with 195 additions and 18 deletions
Download patch file Download diff file Expand all files Collapse all files

15
include/xo/reader2/DDefineSsm.hpp
View file

@ -169,21 +169,6 @@ namespace xo {
void on_parsed_typedescr(TypeDescr td,
ParserStateMachine * p_psm);
#ifdef OBSOLETE
/** update state for this ssm to consume param (name,value)
* emitted by nested @p_psm
**/
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);
#endif
/** update state for this syntax after parsing an expression @p expr,
* overall parser state in @p p_psm
**/

57
include/xo/reader2/DSequenceSsm.hpp Normal file
View file

@ -0,0 +1,57 @@
/** @file DSequenceSsm.hpp
*
* @author Roland Conybeare, Jan 2026
**/
#pragma once
#include "DSyntaxStateMachine.hpp"
//#include "exprstate.hpp"
namespace xo {
namespace scm { class Sequence; }
namespace scm { class Lambda; }
namespace scm {
class DSequenceSsm : public DSyntaxStateMachine<DSequenceSsm> {
public:
using Sequence = xo::scm::Sequence;
using Lambda = xo::scm::Lambda;
public:
const char * ssm_classname() const noexcept { return "DSequenceSsm"; }
#ifdef NOT_YET
/** start parsing a sequence-expr.
* input begins with first expression in the sequence.
**/
static void start(parserstatemachine * p_psm);
/** named ctor idiom **/
static std::unique_ptr<sequence_xs> make();
virtual void on_expr(bp<Expression> expr,
parserstatemachine * p_psm) override;
virtual void on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm) override;
virtual void on_rightbrace_token(const token_type & tk,
parserstatemachine * p_psm) override;
virtual void print(std::ostream & os) const override;
virtual bool pretty_print(const xo::print::ppindentinfo & ppii) const override;
#endif
private:
DSequenceSsm();
private:
/** will build SequenceExpr from in-order contents of this array **/
DArray * expr_v_;
//std::vector<rp<Expression>> expr_v_;
};
} /*namespace scm*/
} /*namespace xo*/
/* end DSequenceSsm.hpp */

4
src/reader2/DExpectExprSsm.cpp
View file

@ -183,9 +183,7 @@ namespace xo {
DExpectExprSsm::on_symbol_token(const Token & tk,
ParserStateMachine * p_psm)
{
p_psm->illegal_input_on_token("DExpectExprSsm",
tk,
this->get_expect_str());
Super::on_token(tk, p_psm);
}
#ifdef NOT_YET

137
src/reader2/DSequenceSsm.cpp Normal file
View file

@ -0,0 +1,137 @@
/* @file DSequenceSsm.cpp */
#include "DSequenceSsm.hpp"
#ifdef NOT_YET
#include "expect_expr_xs.hpp"
#include "let1_xs.hpp"
#include "xo/expression/DefineExpr.hpp"
#include "xo/expression/Sequence.hpp"
#include "xo/expression/pretty_expression.hpp"
#endif
namespace xo {
using xo::scm::DefineExpr;
namespace scm {
#ifdef NOT_YET
std::unique_ptr<sequence_xs>
sequence_xs::make() {
return std::make_unique<sequence_xs>(sequence_xs());
}
#endif
void
sequence_xs::start(parserstatemachine * p_psm) {
p_psm->push_exprstate(sequence_xs::make());
/* want to accept anything that starts an expression,
* except that } ends it
*/
expect_expr_xs::start(true /*allow_defs*/,
true /*cxl_on_rightbrace*/,
p_psm);
}
sequence_xs::sequence_xs()
: exprstate(exprstatetype::sequenceexpr)
{}
void
sequence_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
scope log(XO_DEBUG(p_psm->debug_flag()));
log && log(xtag("expr", expr.promote()));
/* TODO: if expr is a DefineExpr,
* then need to rewrite...
*
* ...prefix
* DefineExpr(lhs_name, rhs)
* rest...
*
* becomes:
*
* /-- .outer_seq_expr_
* v
* Sequence(
* ...prefix,
*
* /-- .inner_lm_expr_
* v
* Apply(Lambda(gen999,
* [Variable(lhs_name, type(rhs))],
* /-- .expr_v_
* v
* sequencify(rest...)),
* rhs))
*
* so amongst other things,
* helpful to have nested seequence_xs that propagates '}'
* instead of swallowing it.
*/
bp<DefineExpr> def_expr = DefineExpr::from(expr);
if (def_expr) {
/** nested_start: control returns via
* .on_expr(x)
* with x something like:
* Apply(Lambda(gensym(),
* [Variable(def_expr->lhs_name(),
* def_expr->valuetype())],
* body...))
* followed immediately by
* .on_rightbrace_token()
**/
let1_xs::start(def_expr->lhs_name(),
def_expr->rhs(),
p_psm);
} else {
this->expr_v_.push_back(expr.promote());
expect_expr_xs::start(true /*allow_defs*/,
true /*cxl_on_rightbrace*/,
p_psm);
}
}
void
sequence_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
/* sequence continues until right brace */
this->on_expr(expr, p_psm);
}
void
sequence_xs::on_rightbrace_token(const token_type & /*tk*/,
parserstatemachine * p_psm)
{
auto self = p_psm->pop_exprstate();
/* make sequence from expressions seen at this level,
* and report it to parent
*/
auto expr = Sequence::make(this->expr_v_);
p_psm->top_exprstate().on_expr(expr, p_psm);
}
void
sequence_xs::print(std::ostream & os) const {
os << "<sequence_xs" << xtag("expr_v.size", expr_v_.size()) << ">";
}
bool
sequence_xs::pretty_print(const xo::print::ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct(ppii, "sequence_xs",
xrefrtag("expr_v.size", expr_v_.size()));
}
} /*namespace scm*/
} /*namespace xo*/
/* end DSequenceSsm.cpp */