From bcd95502d2b13690f40eb5a46389f5bd02389cf9 Mon Sep 17 00:00:00 2001 From: Roland Conybeare Date: Fri, 30 Jan 2026 20:08:41 -0500 Subject: [PATCH] xo-expression2 xo-reader2 DSequenceExpr, DSequenceSsm [WIP] --- include/xo/reader2/DDefineSsm.hpp | 15 --- include/xo/reader2/DSequenceSsm.hpp | 57 ++++++++++++ src/reader2/DExpectExprSsm.cpp | 4 +- src/reader2/DSequenceSsm.cpp | 137 ++++++++++++++++++++++++++++ 4 files changed, 195 insertions(+), 18 deletions(-) create mode 100644 include/xo/reader2/DSequenceSsm.hpp create mode 100644 src/reader2/DSequenceSsm.cpp diff --git a/include/xo/reader2/DDefineSsm.hpp b/include/xo/reader2/DDefineSsm.hpp index 939d5479..34918dc9 100644 --- a/include/xo/reader2/DDefineSsm.hpp +++ b/include/xo/reader2/DDefineSsm.hpp @@ -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 **/ diff --git a/include/xo/reader2/DSequenceSsm.hpp b/include/xo/reader2/DSequenceSsm.hpp new file mode 100644 index 00000000..8d936254 --- /dev/null +++ b/include/xo/reader2/DSequenceSsm.hpp @@ -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 { + 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 make(); + + virtual void on_expr(bp expr, + parserstatemachine * p_psm) override; + virtual void on_expr_with_semicolon(bp 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> expr_v_; + }; + } /*namespace scm*/ +} /*namespace xo*/ + + +/* end DSequenceSsm.hpp */ diff --git a/src/reader2/DExpectExprSsm.cpp b/src/reader2/DExpectExprSsm.cpp index 899731a3..3b4b2c36 100644 --- a/src/reader2/DExpectExprSsm.cpp +++ b/src/reader2/DExpectExprSsm.cpp @@ -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 diff --git a/src/reader2/DSequenceSsm.cpp b/src/reader2/DSequenceSsm.cpp new file mode 100644 index 00000000..285960bd --- /dev/null +++ b/src/reader2/DSequenceSsm.cpp @@ -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::make() { + return std::make_unique(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 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 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 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 << ""; + } + + 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 */