370 lines
12 KiB
C++
370 lines
12 KiB
C++
/** @file DApplySsm.cpp
|
|
*
|
|
* @author Roland Conybeare, Feb 2026
|
|
**/
|
|
|
|
#include "ApplySsm.hpp"
|
|
#include "ExpectExprSsm.hpp"
|
|
#include <xo/facet/FacetRegistry.hpp>
|
|
#include <xo/alloc2/Arena.hpp>
|
|
#include <xo/reflectutil/typeseq.hpp>
|
|
|
|
//#include "parserstatemachine.hpp"
|
|
//#include "expect_expr_xs.hpp"
|
|
|
|
namespace xo {
|
|
using xo::mm::AGCObject;
|
|
using xo::print::APrintable;
|
|
using xo::reflect::typeseq;
|
|
|
|
namespace scm {
|
|
|
|
// ----- applyexprstatetype -----
|
|
|
|
const char *
|
|
applyexprstatetype_descr(applyexprstatetype x) {
|
|
switch (x) {
|
|
case applyexprstatetype::invalid: return "invalid";
|
|
case applyexprstatetype::apply_0: return "apply_0";
|
|
case applyexprstatetype::apply_1: return "apply_1";
|
|
case applyexprstatetype::apply_2: return "apply_2";
|
|
case applyexprstatetype::apply_3: return "apply_3";
|
|
case applyexprstatetype::N: break;
|
|
}
|
|
|
|
return "???applyexprstatetype";
|
|
}
|
|
|
|
std::ostream &
|
|
operator<<(std::ostream & os, applyexprstatetype x) {
|
|
os << applyexprstatetype_descr(x);
|
|
return os;
|
|
}
|
|
|
|
// ----- DApplySsm -----
|
|
|
|
DApplySsm::DApplySsm(applyexprstatetype applystate,
|
|
obj<AExpression> fn_expr,
|
|
DArray * args)
|
|
: applystate_{applystate},
|
|
fn_expr_{fn_expr},
|
|
args_expr_v_{args}
|
|
{
|
|
if (fn_expr) {
|
|
this->applystate_ = applyexprstatetype::apply_1;
|
|
}
|
|
|
|
assert(args->is_empty());
|
|
}
|
|
|
|
DApplySsm *
|
|
DApplySsm::_make(DArena & arena,
|
|
obj<AExpression> fn_expr)
|
|
{
|
|
obj<AAllocator,DArena> mm(&arena);
|
|
|
|
void * mem = arena.alloc(typeseq::id<DApplySsm>(),
|
|
sizeof(DApplySsm));
|
|
|
|
/* allocate room for 8 arguments (during parsing)
|
|
* will reallocate to expand if needed.
|
|
*
|
|
* See similar code in DExpectFormalArglistSsm::_make
|
|
*/
|
|
DArray * args = DArray::empty(mm, 8);
|
|
|
|
applyexprstatetype applystate
|
|
= (fn_expr
|
|
? applyexprstatetype::apply_1
|
|
: applyexprstatetype::apply_0);
|
|
|
|
// TODO: revisit if we decide to use flexible array for arguments
|
|
|
|
return new (mem) DApplySsm(applystate, fn_expr, args);
|
|
}
|
|
|
|
obj<ASyntaxStateMachine,DApplySsm>
|
|
DApplySsm::make(DArena & arena,
|
|
obj<AExpression> fn_expr)
|
|
{
|
|
return obj<ASyntaxStateMachine,DApplySsm>(_make(arena, fn_expr));
|
|
}
|
|
|
|
void
|
|
DApplySsm::start(obj<AExpression> fn_expr,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
|
|
|
|
auto ssm = DApplySsm::make(p_psm->parser_alloc(), fn_expr);
|
|
|
|
p_psm->push_ssm(ckp, ssm);
|
|
}
|
|
|
|
syntaxstatetype
|
|
DApplySsm::ssm_type() const noexcept {
|
|
return syntaxstatetype::apply;
|
|
}
|
|
|
|
|
|
std::string_view
|
|
DApplySsm::get_expect_str() const noexcept
|
|
{
|
|
switch(applystate_) {
|
|
case applyexprstatetype::invalid: return "invalid";
|
|
case applyexprstatetype::apply_0: return "expr";
|
|
case applyexprstatetype::apply_1: return "lparen";
|
|
case applyexprstatetype::apply_2: return "expr";
|
|
case applyexprstatetype::apply_3: return "comma|rparen";
|
|
case applyexprstatetype::N: break;
|
|
}
|
|
|
|
return "?expect";
|
|
}
|
|
|
|
void
|
|
DApplySsm::on_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()), xtag("tk", tk));
|
|
|
|
switch (tk.tk_type()) {
|
|
case tokentype::tk_leftparen:
|
|
this->on_leftparen_token(tk, p_psm);
|
|
return;
|
|
case tokentype::tk_symbol:
|
|
case tokentype::tk_def:
|
|
case tokentype::tk_if:
|
|
case tokentype::tk_then:
|
|
case tokentype::tk_else:
|
|
case tokentype::tk_semicolon:
|
|
case tokentype::tk_colon:
|
|
case tokentype::tk_singleassign:
|
|
case tokentype::tk_string:
|
|
case tokentype::tk_f64:
|
|
case tokentype::tk_i64:
|
|
case tokentype::tk_bool:
|
|
case tokentype::tk_invalid:
|
|
case tokentype::tk_rightparen:
|
|
case tokentype::tk_leftbracket:
|
|
case tokentype::tk_rightbracket:
|
|
case tokentype::tk_leftbrace:
|
|
case tokentype::tk_rightbrace:
|
|
case tokentype::tk_leftangle:
|
|
case tokentype::tk_rightangle:
|
|
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_let:
|
|
case tokentype::tk_in:
|
|
case tokentype::tk_end:
|
|
case tokentype::N:
|
|
break;
|
|
}
|
|
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
void
|
|
DApplySsm::on_leftparen_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
if (applystate_ == applyexprstatetype::apply_1) {
|
|
this->applystate_ = applyexprstatetype::apply_2;
|
|
|
|
DExpectExprSsm::start(p_psm);
|
|
return;
|
|
}
|
|
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
void
|
|
DApplySsm::on_parsed_expression_with_token(obj<AExpression> expr,
|
|
const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
/* maybe we'll find control comes here also on function position?
|
|
* hasn't come up when applyssm recognized via leftparen
|
|
*/
|
|
|
|
if (applystate_ == applyexprstatetype::apply_2) {
|
|
obj<AGCObject> expr_gco = expr.to_facet<AGCObject>();
|
|
assert(expr_gco);
|
|
|
|
obj<AAllocator,DArena> mm(&(p_psm->parser_alloc()));
|
|
|
|
if (args_expr_v_->size() == args_expr_v_->capacity()) {
|
|
// need to expand .args_expr_v_ capacity.
|
|
// Could use DArena checkpoint to redo this in place,
|
|
// since argument array must be on the top of the stack.
|
|
|
|
DArray * argv_2x = DArray::empty(mm, 2 * args_expr_v_->capacity());
|
|
|
|
for (DArray::size_type i = 0, n = args_expr_v_->size(); i < n; ++i) {
|
|
argv_2x->push_back((*args_expr_v_)[i]);
|
|
}
|
|
|
|
this->args_expr_v_ = argv_2x;
|
|
}
|
|
|
|
if (args_expr_v_->size() < args_expr_v_->capacity())
|
|
args_expr_v_->push_back(expr_gco);
|
|
|
|
if (tk.tk_type() == tokentype::tk_rightparen) {
|
|
// begin assemble_expr()..
|
|
|
|
std::uint32_t n_args = args_expr_v_->size();
|
|
|
|
DApplyExpr * apply
|
|
= (DApplyExpr::scaffold
|
|
(mm,
|
|
TypeRef::dwim(TypeRef::prefix_type::from_chars("apply"),
|
|
nullptr),
|
|
fn_expr_,
|
|
n_args));
|
|
|
|
for (std::uint32_t i_arg = 0; i_arg < n_args; ++i_arg) {
|
|
auto arg_expr
|
|
= args_expr_v_->at(i_arg).to_facet<AExpression>();
|
|
|
|
apply->assign_arg(i_arg, arg_expr);
|
|
}
|
|
|
|
// ..end assemble_expr()
|
|
|
|
obj<AExpression,DApplyExpr> apply_ex(apply);
|
|
|
|
p_psm->pop_ssm();
|
|
p_psm->on_parsed_expression(apply_ex);
|
|
|
|
return;
|
|
} else if (tk.tk_type() == tokentype::tk_comma) {
|
|
// 1. want to remain in state apply_2
|
|
// 2. expr from nested ssm already incorporated
|
|
// into .args_expr_v_
|
|
|
|
DExpectExprSsm::start(p_psm);
|
|
return;
|
|
}
|
|
}
|
|
|
|
Super::on_parsed_expression_with_token(expr, tk, p_psm);
|
|
}
|
|
|
|
#ifdef NOT_YET
|
|
void
|
|
apply_xs::on_expr(bp<Expression> expr,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
switch (applyxs_type_) {
|
|
case applyexprstatetype::invalid:
|
|
case applyexprstatetype::n_applyexprstatetype:
|
|
// unreachable
|
|
break;
|
|
case applyexprstatetype::apply_0:
|
|
log && log("stash fn -> new state apply_1");
|
|
this->fn_expr_ = expr.promote();
|
|
this->applyxs_type_ = applyexprstatetype::apply_1;
|
|
return;
|
|
case applyexprstatetype::apply_1:
|
|
log && log("error: was expecting lparen");
|
|
// error, expecting lparen
|
|
break;
|
|
case applyexprstatetype::apply_2:
|
|
log && log(xtag("expr", expr), xtag("do", "stash expr -> new state apply_3"));
|
|
this->args_expr_v_.push_back(expr.promote());
|
|
this->applyxs_type_ = applyexprstatetype::apply_3;
|
|
return;
|
|
case applyexprstatetype::apply_3:
|
|
// error, expecting comma|rparen
|
|
break;
|
|
}
|
|
|
|
/* control here --implies-> error state */
|
|
|
|
constexpr const char * c_self_name = "apply_xs::on_expr";
|
|
const char * exp = this->get_expect_str();
|
|
|
|
this->illegal_input_on_expr(c_self_name, expr, exp, p_psm);
|
|
}
|
|
|
|
void
|
|
apply_xs::on_comma_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
if (this->applyxs_type_ == applyexprstatetype::apply_3) {
|
|
this->applyxs_type_ = applyexprstatetype::apply_2;
|
|
expect_expr_xs::start(p_psm);
|
|
} else {
|
|
constexpr const char * c_self_name = "apply_xs::on_comma_token";
|
|
const char * exp = this->get_expect_str();
|
|
|
|
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
|
|
}
|
|
}
|
|
|
|
void
|
|
apply_xs::on_rightparen_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
log && log("applyxs_type", applyxs_type_);
|
|
|
|
if (this->applyxs_type_ == applyexprstatetype::apply_3) {
|
|
/* (done) state */
|
|
log("apply complete -> pop + send expr");
|
|
|
|
rp<Apply> apply_expr = Apply::make(this->fn_expr_, this->args_expr_v_);
|
|
|
|
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
|
|
|
p_psm->top_exprstate().on_expr(apply_expr, p_psm);
|
|
return;
|
|
}
|
|
|
|
constexpr const char * c_self_name = "apply_xs::on_rightparen_token";
|
|
const char * exp = this->get_expect_str();
|
|
|
|
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
|
|
}
|
|
#endif
|
|
|
|
bool
|
|
DApplySsm::pretty(const ppindentinfo & ppii) const
|
|
{
|
|
// TODO: const-correct version of obj<> template
|
|
auto fn_expr = const_cast<DApplySsm*>(this)->fn_expr_.to_facet<APrintable>();
|
|
bool fn_expr_present(fn_expr);
|
|
|
|
return ppii.pps()->pretty_struct(ppii,
|
|
"DApplySsm",
|
|
refrtag("applystate", applystate_),
|
|
refrtag("expect", this->get_expect_str()),
|
|
refrtag("fn_expr", fn_expr, fn_expr_present));
|
|
}
|
|
|
|
} /*namespace scm*/
|
|
} /*namespace xo*/
|
|
|
|
|
|
/* end DApplySsm.cpp */
|