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

xo-reader2: DApplySsm for apply expressions [WIP]

Browse source
This commit is contained in:
Roland Conybeare 2026-02-11 16:02:41 -05:00
commit 40e1fb531d
7 changed files with 402 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

165
include/xo/reader2/DApplySsm.hpp Normal file
View file

@ -0,0 +1,165 @@
/** @file DApplySsm.hpp
*
* @author Roland Conybeare, Feb 2026
**/
#pragma once
#include "DSyntaxStateMachine.hpp"
#include "syntaxstatetype.hpp"
#include <xo/expression2/ApplyExpr.hpp>
//#include <xo/facet/obj.hpp>
#include <string_view>
namespace xo {
namespace scm {
/**
* fn ( arg1 , arg2 , .. , argn )
* ^ ^ ^ ^ ^ ^ ^ ^ ^
* | | | | | | | | (done)
* | | | | | | | apply_3
* | | | | | | apply_2:expect_rhs_expression
* | | | | | apply_3
* | | | | apply_2:expect_rhs_expression
* | | | apply_3
* | | apply_2:expect_rhs_expression
* | apply_1
* apply_0:expect_rhs_expression
*
* apply_0 --on_expr()--> apply_1
* apply_1 --on_leftparen()--> apply_2
* apply_2 --on_expr()--> apply_3
* apply_3 --on_comma()--> apply_2
* --on_rightparen()-> (done)
*
* apply_0: start
* apply_1: leftparen following expr allows parser to recognize apply
* apply_2: expect next argument
* apply_3: got argument, expect comma or rightparen to continue
* (done): apply complete, pop exprstate from stack
*
* In practice will start in state apply_1
**/
enum class applyexprstatetype {
invalid = -1,
apply_0,
apply_1,
apply_2,
apply_3,
N
};
extern const char * applyexprstatetype_descr(applyexprstatetype x);
std::ostream &
operator<<(std::ostream & os, applyexprstatetype x);
/** @class DApplySsm
* @brief state machine for parsing a schematika function-call-expression
**/
class DApplySsm : public DSyntaxStateMachine<DApplySsm> {
public:
using Super = DSyntaxStateMachine<DApplySsm>;
using TypeDescr = xo::reflect::TypeDescr;
using AAllocator = xo::mm::AAllocator;
using DArena = xo::mm::DArena;
using ppindentinfo = xo::print::ppindentinfo;
//using Apply = xo::scm::Apply;
public:
/** @defgroup scm-applyssm-ctors constructors **/
///@{
/** construct apply ssm with @p fn_expr
* supplying function to be invoked.
*
* Expect during parsing of input like f(...)
* that we parse f before parser knows that it will be
* followed by leftparen
**/
explicit DApplySsm(obj<AExpression> fn_expr);
/** create instance using memory from @p parser_mm.
* with function to be called supplied by @p fn_expr.
**/
static DApplySsm * make(DArena & parser_mm,
obj<AExpression> fn_expr);
#ifdef NOT_YET
/**
* Start apply. Will trigger this after input like
* "fn("
*
* apply_xs remains on expr stack until closing right paren
* fn(arg1-expr, arg2-expr, ...)
*
* @p fnex expression in function position
* @p p_psm parser state machine
**/
static void start(rp<Expression> fnex,
parserstatemachine * p_psm);
#endif
///@}
/** @defgroup scm-applyssm-access methods **/
///@{
/** identify this nested state machine **/
static const char * ssm_classname() { return "DApplySsm"; }
/** current internal state **/
applyexprstatetype applystate() const noexcept { return applystate_; }
///@}
/** @defgroup ssm-applyssm-facet syntaxstatemachine facet methods **/
///@{
/** identifies the ssm implemented here **/
syntaxstatetype ssm_type() const noexcept;
/** mnemonic for expected remaining syntax for current parsing state **/
std::string_view get_expect_str() const noexcept;
#ifdef NOT_YET
virtual void on_expr(bp<Expression> expr,
parserstatemachine * p_psm) override;
virtual void on_comma_token(const token_type & tk,
parserstatemachine * p_psm) override;
virtual void on_leftparen_token(const token_type & tk,
parserstatemachine * p_psm) override;
virtual void on_rightparen_token(const token_type & tk,
parserstatemachine * p_psm) override;
virtual void print(std::ostream & os) const override;
virtual bool pretty_print(const print::ppindentinfo & ppii) const final override;
private:
static std::unique_ptr<apply_xs> make();
#endif
private:
/** current state of parser for this apply expression **/
applyexprstatetype applystate_ = applyexprstatetype::apply_0;
/** evaluates to function to be invoked **/
obj<AExpression> fn_expr_;
#ifdef NOT_YET
/** evaluates to the arguments to pass to @ref fn_ **/
std::vector<rp<Expression>> args_expr_v_;
#endif
};
} /*namespace scm */
namespace print {
#ifndef ppdetail_atomic
PPDETAIL_ATOMIC(xo::scm::applyexprstatetype);
#endif
}
} /*namespace xo*/
/* end DApplySsm.hpp */

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

@ -78,7 +78,7 @@ namespace xo {
using ppindentinfo = xo::print::ppindentinfo;
public:
/** @defgroup scm-define-ssm-facet constructors **/
/** @defgroup scm-definessm-ctors constructors **/
///@{
/** constructor; using @p def_expr for initial expression scaffold **/
@ -110,7 +110,7 @@ namespace xo {
defexprstatetype defstate() const noexcept { return defstate_; }
///@}
/** @defgroup scm-define-ssm-facet syntaxstatemachine facet methods **/
/** @defgroup scm-definessm-facet syntaxstatemachine facet methods **/
///@{
/** identifies the ssm implemented here **/

5
include/xo/reader2/syntaxstatetype.hpp
View file

@ -27,9 +27,12 @@ namespace xo {
/** handle ifelse-expression. See @ref DIfElseSsm **/
ifelseexpr,
/** handle sequence-expression. See @ref DSequenceSsm **/
/** handle sequence-expression syntax. See @ref DSequenceSsm **/
sequence,
/** handle apply-expression syntax. See @ref DApplySsm **/
apply,
/** rhs expression. state exists to achieve 1-token lookahead **/
progress,