Roland Conybeare
ec639ebb4b
Helps streamline DX1Collector in xo-gc/. Want both forward and verify entry points for the same representation.
1257 lines
41 KiB
C++
1257 lines
41 KiB
C++
/** @file DProgressSsm.cpp
|
|
*
|
|
* @author Roland Conybeare, Jan 2026
|
|
**/
|
|
|
|
#include "ProgressSsm.hpp"
|
|
|
|
#include "DExpectExprSsm.hpp"
|
|
#include "ssm/ISyntaxStateMachine_DExpectExprSsm.hpp"
|
|
|
|
#include "ApplySsm.hpp"
|
|
#include "ParenSsm.hpp"
|
|
|
|
#include <xo/numeric/NumericPrimitives.hpp>
|
|
|
|
#include <xo/expression2/DApplyExpr.hpp>
|
|
#include <xo/expression2/detail/IExpression_DApplyExpr.hpp>
|
|
|
|
#include <xo/expression2/DConstant.hpp>
|
|
#include <xo/expression2/detail/IExpression_DConstant.hpp>
|
|
|
|
#include <xo/procedure2/init_primitives.hpp> // for xo::scm::Primitives
|
|
#include <xo/procedure2/detail/IGCObject_DPrimitive_gco_2_gco_gco.hpp>
|
|
|
|
#include <xo/alloc2/GCObject.hpp>
|
|
#include <xo/printable2/Printable.hpp>
|
|
#include <xo/facet/FacetRegistry.hpp>
|
|
#include <xo/reflectutil/typeseq.hpp>
|
|
#include <xo/indentlog/print/cond.hpp>
|
|
|
|
#ifdef NOT_YET
|
|
#include "expect_expr_xs.hpp"
|
|
#include "pretty_exprstatestack.hpp"
|
|
#include "xo/expression/AssignExpr.hpp"
|
|
#include "xo/expression/Apply.hpp"
|
|
#include "xo/expression/pretty_expression.hpp"
|
|
#endif
|
|
|
|
namespace xo {
|
|
#ifdef NOT_YET
|
|
using xo::scm::Expression;
|
|
using xo::scm::AssignExpr;
|
|
using xo::scm::Variable;
|
|
using xo::scm::Apply;
|
|
#endif
|
|
using xo::mm::AAllocator;
|
|
using xo::mm::AGCObject;
|
|
using xo::print::APrintable;
|
|
using xo::facet::FacetRegistry;
|
|
using xo::facet::with_facet;
|
|
using xo::reflect::typeseq;
|
|
|
|
namespace scm {
|
|
const char *
|
|
optype_descr(optype x) {
|
|
switch (x) {
|
|
case optype::invalid:
|
|
return "?optype";
|
|
case optype::op_assign:
|
|
return "op:=";
|
|
case optype::op_less:
|
|
return "op<";
|
|
case optype::op_less_equal:
|
|
return "op<=";
|
|
case optype::op_equal:
|
|
return "op==";
|
|
case optype::op_not_equal:
|
|
return "op!=";
|
|
case optype::op_great:
|
|
return "op>";
|
|
case optype::op_great_equal:
|
|
return "op>=";
|
|
case optype::op_add:
|
|
return "op+";
|
|
case optype::op_subtract:
|
|
return "op-";
|
|
case optype::op_multiply:
|
|
return "op*";
|
|
case optype::op_divide:
|
|
return "op/";
|
|
case optype::n_optype:
|
|
break;
|
|
}
|
|
return "???";
|
|
}
|
|
|
|
/** higher-precedence operators bind before lower-preference operators **/
|
|
int
|
|
precedence(optype x) {
|
|
switch (x) {
|
|
case optype::invalid:
|
|
case optype::n_optype:
|
|
return 0;
|
|
|
|
case optype::op_assign:
|
|
return 1;
|
|
|
|
case optype::op_less:
|
|
case optype::op_less_equal:
|
|
case optype::op_equal:
|
|
case optype::op_not_equal:
|
|
case optype::op_great:
|
|
case optype::op_great_equal:
|
|
return 2;
|
|
|
|
case optype::op_add:
|
|
case optype::op_subtract:
|
|
return 3;
|
|
|
|
case optype::op_multiply:
|
|
case optype::op_divide:
|
|
return 4;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
namespace {
|
|
optype
|
|
tk2op(const tokentype & tktype) {
|
|
switch (tktype) {
|
|
case tokentype::tk_assign:
|
|
return optype::op_assign;
|
|
case tokentype::tk_plus: // [+]
|
|
return optype::op_add;
|
|
case tokentype::tk_minus: // [-]
|
|
return optype::op_subtract;
|
|
case tokentype::tk_star: // [*]
|
|
return optype::op_multiply;
|
|
case tokentype::tk_slash: // [/]
|
|
return optype::op_divide;
|
|
case tokentype::tk_cmpeq: // [==]
|
|
return optype::op_equal;
|
|
case tokentype::tk_cmpne: // [!=]
|
|
return optype::op_not_equal;
|
|
case tokentype::tk_leftangle: // [<]
|
|
return optype::op_less;
|
|
case tokentype::tk_cmple: // [<=]
|
|
return optype::op_less_equal;
|
|
case tokentype::tk_rightangle: // [>]
|
|
return optype::op_great;
|
|
case tokentype::tk_cmpge: // [>=]
|
|
return optype::op_great_equal;
|
|
default:
|
|
assert(false);
|
|
return optype::invalid;
|
|
}
|
|
return optype::invalid;
|
|
}
|
|
}
|
|
|
|
DProgressSsm *
|
|
DProgressSsm::_make(DArena & mm,
|
|
obj<AExpression> lhs,
|
|
optype op)
|
|
{
|
|
void * mem = mm.alloc(typeseq::id<DProgressSsm>(),
|
|
sizeof(DProgressSsm));
|
|
|
|
return new (mem) DProgressSsm(lhs, op);
|
|
}
|
|
|
|
obj<ASyntaxStateMachine,DProgressSsm>
|
|
DProgressSsm::make(DArena & mm,
|
|
obj<AExpression> lhs,
|
|
optype op)
|
|
{
|
|
return obj<ASyntaxStateMachine,DProgressSsm>(_make(mm, lhs, op));
|
|
}
|
|
|
|
void
|
|
DProgressSsm::start(DArena & parser_mm,
|
|
obj<AExpression> lhs,
|
|
optype op,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
DArena::Checkpoint ckp = parser_mm.checkpoint();
|
|
|
|
auto ssm = DProgressSsm::make(parser_mm, lhs, op);
|
|
|
|
p_psm->push_ssm(ckp, ssm);
|
|
}
|
|
|
|
void
|
|
DProgressSsm::start(DArena & parser_mm,
|
|
obj<AExpression> lhs,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
start(parser_mm, lhs, optype::invalid, p_psm);
|
|
}
|
|
|
|
|
|
void
|
|
DProgressSsm::start(DArena & parser_mm,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
start(parser_mm, obj<AExpression>(), p_psm);
|
|
}
|
|
|
|
DProgressSsm::DProgressSsm(obj<AExpression> valex,
|
|
optype op)
|
|
: lhs_{valex},
|
|
op_type_{op}
|
|
{}
|
|
|
|
syntaxstatetype
|
|
DProgressSsm::ssm_type() const noexcept
|
|
{
|
|
return syntaxstatetype::progress;
|
|
}
|
|
|
|
#ifdef NOT_YET
|
|
bool
|
|
progress_xs::admits_f64() const { return false; }
|
|
#endif
|
|
|
|
std::string_view
|
|
DProgressSsm::get_expect_str() const noexcept {
|
|
if (!lhs_) {
|
|
return "expr1|leftparen";
|
|
} else if (op_type_ == optype::invalid) {
|
|
return "oper|semicolon|leftparen|rightparen|rightbrace";
|
|
} else {
|
|
return "expr2|leftparen";
|
|
}
|
|
}
|
|
|
|
void
|
|
DProgressSsm::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_then:
|
|
case tokentype::tk_else:
|
|
case tokentype::tk_comma:
|
|
this->on_completing_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_symbol:
|
|
this->on_symbol_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_colon:
|
|
this->on_colon_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_singleassign:
|
|
this->on_singleassign_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_string:
|
|
this->on_string_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_f64:
|
|
this->on_f64_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_i64:
|
|
this->on_i64_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_bool:
|
|
this->on_bool_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_semicolon:
|
|
this->on_semicolon_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_rightbrace:
|
|
this->on_rightbrace_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_leftparen:
|
|
this->on_leftparen_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_rightparen:
|
|
this->on_rightparen_token(tk, p_psm);
|
|
return;
|
|
|
|
// all the not-yet handled cases
|
|
case tokentype::tk_invalid:
|
|
case tokentype::tk_def:
|
|
case tokentype::tk_deftype:
|
|
case tokentype::tk_if:
|
|
case tokentype::tk_quote:
|
|
case tokentype::tk_leftbracket:
|
|
case tokentype::tk_rightbracket:
|
|
case tokentype::tk_leftbrace:
|
|
case tokentype::tk_dot:
|
|
case tokentype::tk_doublecolon:
|
|
case tokentype::tk_assign:
|
|
case tokentype::tk_yields:
|
|
break;
|
|
|
|
case tokentype::tk_star:
|
|
case tokentype::tk_slash:
|
|
case tokentype::tk_plus:
|
|
case tokentype::tk_minus:
|
|
case tokentype::tk_cmpeq:
|
|
case tokentype::tk_cmpne:
|
|
case tokentype::tk_leftangle:
|
|
case tokentype::tk_rightangle:
|
|
case tokentype::tk_cmple:
|
|
case tokentype::tk_cmpge:
|
|
this->on_operator_token(tk, p_psm);
|
|
return;
|
|
|
|
case tokentype::tk_nil:
|
|
case tokentype::tk_type:
|
|
case tokentype::tk_lambda:
|
|
break;
|
|
case tokentype::tk_let:
|
|
case tokentype::tk_in:
|
|
case tokentype::tk_end:
|
|
case tokentype::N:
|
|
break;
|
|
}
|
|
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_symbol_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_completing_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
obj<AExpression> expr = this->assemble_expr(p_psm);
|
|
|
|
p_psm->pop_ssm(); // completes self
|
|
p_psm->on_parsed_expression_with_token(expr, tk);
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_colon_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
p_psm->illegal_input_on_token("DProgressSsm::on_colon_token",
|
|
tk,
|
|
this->get_expect_str());
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_singleassign_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
p_psm->illegal_input_on_token("DProgressSsm::on_singleassign_token",
|
|
tk,
|
|
this->get_expect_str());
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_operator_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
if (op_type_ == optype::invalid) {
|
|
// tk is the operator this instance was waiting for.
|
|
// But need to consider precedence.
|
|
// possibly need to take lhs_ expression and rotate it into new lhs of
|
|
// surrounding ProgressSsm
|
|
|
|
|
|
this->op_type_ = tk2op(tk.tk_type());
|
|
|
|
DExpectExprSsm::start(p_psm);
|
|
return;
|
|
} else if (rhs_) {
|
|
optype op_type2 = tk2op(tk.tk_type());
|
|
|
|
/* already have {lhs_, op_type_, rhs_},
|
|
* with incoming op_type2 operator decides whether to parse like
|
|
* (lhs_, op_type_, rhs_) op_type2 ...
|
|
* or
|
|
* (lhs_, op_type_, (rhs_ op_type2 ...))
|
|
*/
|
|
|
|
if (precedence(op_type_) >= precedence(op_type2)) {
|
|
/* associate to the left
|
|
*
|
|
* parse like
|
|
* a + b - ... (a + b) - ...
|
|
* a * b - ... (a * b) - ...
|
|
*/
|
|
|
|
auto lhs2 = this->assemble_expr(p_psm);
|
|
|
|
p_psm->pop_ssm();
|
|
|
|
DProgressSsm::start(p_psm->parser_alloc(),
|
|
lhs2,
|
|
op_type2,
|
|
p_psm);
|
|
DExpectExprSsm::start(p_psm);
|
|
return;
|
|
} else {
|
|
/* associate to the right
|
|
*
|
|
* parse like
|
|
* a + b * ... (a + (b * ...))
|
|
*/
|
|
|
|
obj<AExpression> lhs1 = lhs_;
|
|
optype op_type1 = op_type_;
|
|
obj<AExpression> rhs1 = rhs_;
|
|
|
|
assert(lhs1);
|
|
assert(op_type1 != optype::invalid);
|
|
assert(rhs1);
|
|
|
|
p_psm->pop_ssm();
|
|
|
|
/* (a + ..) */
|
|
DProgressSsm::start(p_psm->parser_alloc(),
|
|
lhs1,
|
|
op_type1,
|
|
p_psm);
|
|
DExpectExprSsm::start(p_psm);
|
|
/* (b * ..) */
|
|
DProgressSsm::start(p_psm->parser_alloc(),
|
|
rhs1,
|
|
op_type2,
|
|
p_psm);
|
|
DExpectExprSsm::start(p_psm);
|
|
return;
|
|
}
|
|
}
|
|
|
|
p_psm->illegal_input_on_token("DProgressSsm::on_operator_token",
|
|
tk,
|
|
this->get_expect_str());
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_string_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_f64_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_i64_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_bool_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_semicolon_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
/* note: implementation should parallel .on_rightparen_token() */
|
|
|
|
(void)tk;
|
|
|
|
obj<AExpression> expr = this->assemble_expr(p_psm);
|
|
|
|
{
|
|
obj<APrintable> expr_pr
|
|
= FacetRegistry::instance().variant<APrintable,AExpression>(expr);
|
|
assert(expr_pr);
|
|
log && log(xtag("expr", expr_pr));
|
|
}
|
|
|
|
p_psm->pop_ssm();
|
|
p_psm->on_parsed_expression_with_token(expr, tk);
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_rightbrace_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
(void)tk;
|
|
|
|
obj<AExpression> expr = this->assemble_expr(p_psm);
|
|
|
|
if (expr) {
|
|
obj<APrintable> expr_pr
|
|
= FacetRegistry::instance().try_variant<APrintable,AExpression>(expr);
|
|
assert(expr_pr);
|
|
log && log(xtag("expr", expr_pr));
|
|
} else {
|
|
// illegal token if assemble failed
|
|
Super::on_token(tk, p_psm);
|
|
return;
|
|
}
|
|
|
|
p_psm->pop_ssm();
|
|
p_psm->on_parsed_expression_with_token(expr, tk);
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_parsed_expression(obj<AExpression> expr,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
const bool c_debug_flag = p_psm->debug_flag();
|
|
|
|
scope log(XO_DEBUG(c_debug_flag));
|
|
|
|
if (!lhs_) {
|
|
log && log("accepting expr1");
|
|
|
|
this->lhs_ = expr;
|
|
|
|
return;
|
|
}
|
|
|
|
assert (op_type_ != optype::invalid);
|
|
|
|
if (!rhs_) {
|
|
this->rhs_ = expr;
|
|
|
|
// need next token before we know whether this DProgressSsm
|
|
// is complete. Consider input like 7 + 2 * 3 vs 7 * 2 + 3
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
Super::on_parsed_expression(expr, p_psm);
|
|
}
|
|
|
|
void
|
|
DProgressSsm::on_parsed_expression_with_token(obj<AExpression> expr,
|
|
const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
const bool c_debug_flag = p_psm->debug_flag();
|
|
|
|
scope log(XO_DEBUG(c_debug_flag),
|
|
xtag("expr", expr),
|
|
xtag("tk", tk));
|
|
|
|
#ifdef NOT_YET
|
|
if (!lhs_) {
|
|
log && log("DProgressSsm: accepting expr1");
|
|
|
|
this->lhs_ = expr;
|
|
|
|
// now we have to handle tk!
|
|
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
// here: have lhs_ expression
|
|
|
|
if (op_type_ == optype::invalid) {
|
|
// e.g. control here on input like
|
|
// x : = 4 4
|
|
|
|
p_psm->illegal_parsed_expression
|
|
("DProgressSsm::on_parsed_expression_with_token",
|
|
expr,
|
|
this->get_expect_str());
|
|
|
|
return;
|
|
}
|
|
|
|
this->rhs_ = expr;
|
|
|
|
obj<AExpression> expr2 = this->assemble_expr(p_psm);
|
|
|
|
if (expr2) {
|
|
p_psm->pop_ssm();
|
|
p_psm->on_parsed_expression_with_token(expr2, tk);
|
|
}
|
|
}
|
|
|
|
#ifdef NOT_YET
|
|
void
|
|
progress_xs::apply_type_error(const char * self_name,
|
|
optype op,
|
|
bp<Expression> expr1,
|
|
bp<Expression> expr2,
|
|
parserstatemachine * p_psm) const
|
|
{
|
|
std::string errmsg = tostr("incompatible argument types T1,T2 to op",
|
|
xtag("op", op),
|
|
xtag("T1", expr1->valuetype()),
|
|
xtag("T2", expr2->valuetype()));
|
|
|
|
p_psm->on_error(self_name, std::move(errmsg));
|
|
}
|
|
|
|
void
|
|
progress_xs::on_expr(bp<Expression> expr,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()), xtag("expr", expr));
|
|
|
|
/* note: previous token probably an operator,
|
|
* handled from progress_xs::on_operator_token(),
|
|
* which pushes expect_expr_xs::expect_rhs_expression()
|
|
*/
|
|
|
|
constexpr const char * c_self_name = "progress_xs::on_expr";
|
|
const char * exp = get_expect_str();
|
|
|
|
if (lhs_) {
|
|
if (op_type_ == optype::invalid) {
|
|
/* two consecutive expression without an operator */
|
|
this->illegal_input_on_expr(c_self_name, expr, exp, p_psm);
|
|
}
|
|
|
|
#ifdef NOT_QUITE
|
|
assert(result.get());
|
|
|
|
/* this expression complete.. */
|
|
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
|
|
|
/* ..but more operators could follow, so don't commit yet */
|
|
p_stack->push_exprstate(progress_xs::make(result));
|
|
#endif
|
|
|
|
this->rhs_ = expr.promote();
|
|
} else {
|
|
/* control here on input like
|
|
* add(1,2)...
|
|
*
|
|
* add(1,2) needs to be handled inside a progress_xs
|
|
* instance because may be followed by an operator:
|
|
* add(1,2) + ...
|
|
*/
|
|
this->lhs_ = expr.promote();
|
|
}
|
|
}
|
|
|
|
void
|
|
progress_xs::on_expr_with_semicolon(bp<Expression> expr,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
log && log(xtag("lhs", lhs_), xtag("op", op_type_), xtag("expr", expr));
|
|
|
|
constexpr const char * c_self_name = "progress_xs::on_expr_with_semicolon";
|
|
const char * exp = get_expect_str();
|
|
|
|
if (op_type_ == optype::invalid) {
|
|
this->illegal_input_on_expr(c_self_name, expr, exp, p_psm);
|
|
}
|
|
|
|
this->rhs_ = expr.promote();
|
|
|
|
// FORBIDDEN, because .on_semicolon_token() destroys *this before returning
|
|
// this->on_semicolon_token(token_type::semicolon(), p_psm);
|
|
// INSTEAD, spell out the body
|
|
|
|
rp<Expression> expr2 = this->assemble_expr(p_psm);
|
|
|
|
if (expr2) {
|
|
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
|
|
|
p_psm->on_expr_with_semicolon(expr2);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef NOT_YET
|
|
void
|
|
progress_xs::on_comma_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
/* note: implementation parllels .on_semicolon_token(), .on_rightparen_token() */
|
|
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
constexpr const char * self_name = "progress::xs::on_comma_token";
|
|
|
|
auto & xs_stack = p_psm->xs_stack_;
|
|
|
|
/* stack may be something like
|
|
*
|
|
* applyexpr
|
|
* expect_expr_xs
|
|
* progress_xs
|
|
* <-- comma
|
|
*
|
|
* 1. comma completes expression-in-progress
|
|
*/
|
|
|
|
/* comma confirms stack expression */
|
|
rp<Expression> expr = this->assemble_expr(p_psm);
|
|
|
|
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
|
|
|
if (xs_stack.empty()) {
|
|
throw std::runtime_error(tostr(self_name,
|
|
": expected non-empty parsing state"));
|
|
}
|
|
|
|
log && log(xtag("stack", &xs_stack));
|
|
|
|
p_psm->top_exprstate().on_expr(expr, p_psm);
|
|
|
|
/* now deliver comma */
|
|
p_psm->top_exprstate().on_comma_token(tk, p_psm);
|
|
}
|
|
|
|
void
|
|
progress_xs::on_semicolon_token(const token_type & /*tk*/,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
/* note: implementation parallels .on_rightparen_token() */
|
|
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
rp<Expression> expr = this->assemble_expr(p_psm);
|
|
|
|
log && log(xtag("assembled-expr", expr));
|
|
|
|
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
|
|
|
p_psm->on_expr_with_semicolon(expr);
|
|
|
|
/* control here on input like:
|
|
* (1.234;
|
|
*
|
|
* a. '(' sets up stack [lparen_0:expect_rhs_expression]
|
|
* (see exprstate::on_leftparen())
|
|
* b. 1.234 pushes (in case operators) [lparen_0:expect_rhs_expression:expr_progress]
|
|
* (see exprstate::on_f64())
|
|
* c. semicolon completes expr_progress [lparen_0:expect_rhs_expression]
|
|
* deliver expresssion to expect_rhs_expression.on_expr_with_semicolon()
|
|
* (see exprstate::on_expr_with_semicolon())
|
|
* d. expr_rhs_expression forwards expression to [lparen_0]
|
|
* e. lparen_0 would advance to [lparen_1], but rejects semicolon
|
|
*/
|
|
}
|
|
|
|
void
|
|
progress_xs::on_assign_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
this->on_operator_token(tk, p_psm);
|
|
}
|
|
#endif
|
|
|
|
void
|
|
DProgressSsm::on_leftparen_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
if (!lhs_) {
|
|
// leftparen begins possible lhs expression
|
|
DParenSsm::start(p_psm);
|
|
|
|
p_psm->on_token(Token::leftparen_token());
|
|
return;
|
|
}
|
|
|
|
if (op_type_ == optype::invalid) {
|
|
// input:
|
|
/// <--- F1 --->
|
|
// (..........)(.. )..
|
|
// <------ A1 ----->
|
|
// <------- X1 ------>
|
|
//
|
|
// F1: expression evaluating to a function,
|
|
// parsed as fn_expr
|
|
// A1: expression parsed as a function call (i.e. apply-expression)
|
|
// X1: operator expression starting with A1
|
|
//
|
|
// before:
|
|
// [0] ProgressSsm responsible for input beginning with F1
|
|
// .lhs = fn_expr, .op_type empty, .rhs empty
|
|
//
|
|
// after:
|
|
// [0] ApplySsm responsible for function call A1
|
|
// .fn_expr = fn_expr
|
|
// [1] ProgressSsm responsible for operator expression X1
|
|
// .lhs empty, .op_type empty, .rhs empty
|
|
//
|
|
// Remarks:
|
|
// 1. keep ProgressSsm on the stack in case input continues like:
|
|
// fn_expr(args..) + ..
|
|
// i.e. to allow for infix operator following apply
|
|
//
|
|
|
|
obj<AExpression> fn_expr(this->lhs_);
|
|
|
|
this->lhs_ = obj<AExpression>();
|
|
|
|
DApplySsm::start(fn_expr, p_psm);
|
|
// + send leftparen to just-pushed apply
|
|
p_psm->on_token(tk);
|
|
|
|
return;
|
|
}
|
|
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
#ifdef NOT_YET
|
|
/* editor bait: on_lparen */
|
|
void
|
|
progress_xs::on_leftparen_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
/* input like:
|
|
* 'foo(' -> expect function call. might continue 'foo(a,b,c)'
|
|
* 'foo+(' -> expect parenthesized expression. might continue 'foo+(bar/2)'
|
|
*/
|
|
|
|
if (op_type_ == optype::invalid) {
|
|
/* start function call */
|
|
assert(rhs_.get() == nullptr);
|
|
|
|
rp<Expression> fn_expr = lhs_;
|
|
|
|
/* reset this progress_xs back to empty state;
|
|
* apply_xs will be responsible for lhs_.
|
|
*/
|
|
lhs_ = nullptr;
|
|
|
|
#ifdef OBSOLETE
|
|
/* don't unwind! want to handle input like
|
|
* f(x,y)+g(z)
|
|
*/
|
|
/* unwind this progress_xs + replace with function call */
|
|
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
|
#endif
|
|
|
|
apply_xs::start(fn_expr, p_psm);
|
|
|
|
/* control will reenter progress_xs via .on_expr() */
|
|
return;
|
|
}
|
|
|
|
const char * exp = get_expect_str();
|
|
constexpr const char * c_self_name = "exprstate::on_leftparen";
|
|
|
|
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
|
|
}
|
|
#endif
|
|
|
|
void
|
|
DProgressSsm::on_rightparen_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
/* note: implementation parallels .on_semicolon_token() */
|
|
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
/* stack may be something like:
|
|
*
|
|
* [0] DProgressSsm
|
|
* [1] DExpectExprSsm
|
|
* [2] DApplySsm
|
|
*
|
|
* where we want rightparen to resolve in [2] DApplySsm,
|
|
* after triggering completion of [0] and [1]
|
|
*/
|
|
auto expr = this->assemble_expr(p_psm);
|
|
|
|
if (expr) {
|
|
/* 1. popping self from parser stack.. */
|
|
p_psm->pop_ssm();
|
|
/* 2. report parsed subexpr to parent ssm, along with the triggering rightparen **/
|
|
p_psm->on_parsed_expression_with_token(expr, tk);
|
|
|
|
return;
|
|
}
|
|
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
#ifdef NOT_YET
|
|
void
|
|
progress_xs::on_rightparen_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
/* note: implementation parallels .on_semicolon_token() */
|
|
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
constexpr const char * self_name = "progress_xs::on_rightparen";
|
|
|
|
auto & xs_stack = p_psm->xs_stack_;
|
|
|
|
/* stack may be something like:
|
|
*
|
|
* lparen_0
|
|
* expect_expr_xs
|
|
* expr_progress
|
|
* <-- rightparen
|
|
*
|
|
* 1. rightparen completes expression-in-progress
|
|
* 2. rightparen must then match innermost waiting lparen_0
|
|
*/
|
|
|
|
/* right paren confirms stack expression */
|
|
rp<Expression> expr = this->assemble_expr(p_psm);
|
|
|
|
log && log(xtag("expr", expr),
|
|
xtag("do", "pop self + send {expr, rparen} -> parent"));
|
|
|
|
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
|
|
|
if (xs_stack.empty()) {
|
|
throw std::runtime_error(tostr(self_name,
|
|
": expected non-empty parsing stack"));
|
|
}
|
|
|
|
log && log(xtag("stack", &xs_stack));
|
|
|
|
p_psm->top_exprstate().on_expr(expr, p_psm);
|
|
|
|
/* now deliver rightparen */
|
|
p_psm->top_exprstate().on_rightparen_token(tk, p_psm);
|
|
}
|
|
|
|
void
|
|
progress_xs::on_else_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
rp<Expression> expr = this->assemble_expr(p_psm);
|
|
|
|
log && log(xtag("assembled-expr", expr));
|
|
|
|
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
|
|
|
p_psm->on_expr(expr);
|
|
p_psm->on_else_token(tk);
|
|
|
|
/* control here on input like:
|
|
*
|
|
* if a > b then c else..
|
|
*/
|
|
}
|
|
|
|
void
|
|
progress_xs::on_rightbrace_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
rp<Expression> expr = this->assemble_expr(p_psm);
|
|
|
|
log && log(xtag("assembled-expr", expr));
|
|
|
|
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
|
|
|
p_psm->on_expr(expr);
|
|
p_psm->on_rightbrace_token(tk);
|
|
|
|
/* control here on input like:
|
|
*
|
|
* { n * n }
|
|
*/
|
|
}
|
|
#endif
|
|
|
|
#ifdef OBSOLETE
|
|
//void progress_xs::on_operator_token(const token_type & tk, parserstatemachine * p_psm)
|
|
|
|
void
|
|
progress_xs::on_bool_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
constexpr const char * c_self_name = "progress_xs::on_bool_token";
|
|
const char * exp = get_expect_str();
|
|
|
|
if (this->op_type_ == optype::invalid) {
|
|
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
|
|
} else {
|
|
exprstate::on_bool_token(tk, p_psm);
|
|
}
|
|
}
|
|
|
|
void
|
|
progress_xs::on_i64_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
constexpr bool c_debug_flag = true;
|
|
scope log(XO_DEBUG(c_debug_flag));
|
|
|
|
constexpr const char * c_self_name = "progress_xs::on_i64_token";
|
|
const char * exp = get_expect_str();
|
|
|
|
if (this->op_type_ == optype::invalid) {
|
|
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
|
|
} else {
|
|
exprstate::on_i64_token(tk, p_psm);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
bool
|
|
DProgressSsm::pretty(const xo::print::ppindentinfo & ppii) const
|
|
{
|
|
scope log(XO_DEBUG(false));
|
|
log && log(xtag("lhs_.tseq", lhs_._typeseq()));
|
|
log && log(xtag("rhs_.tseq", rhs_._typeseq()));
|
|
|
|
obj<APrintable> lhs
|
|
= FacetRegistry::instance().try_variant<APrintable,AExpression>(lhs_);
|
|
|
|
obj<APrintable> rhs
|
|
= FacetRegistry::instance().try_variant<APrintable,AExpression>(rhs_);
|
|
|
|
bool lhs_present = lhs;
|
|
bool rhs_present = rhs;
|
|
bool op_present = (op_type_ != optype::invalid);
|
|
|
|
return ppii.pps()->pretty_struct
|
|
(ppii,
|
|
"DProgressSsm",
|
|
refrtag("lhs", lhs, lhs_present),
|
|
refrtag("op", op_type_, op_present),
|
|
refrtag("rhs", rhs, rhs_present),
|
|
refrtag("expect", this->get_expect_str())
|
|
);
|
|
}
|
|
|
|
namespace {
|
|
// make_builtin_apply_pm2
|
|
|
|
// helper function for making apply expression that invokes
|
|
// a binary primitive. Use for numeric operators:
|
|
// {*, /, +, -, ==}
|
|
//
|
|
obj<AExpression>
|
|
assemble_numeric_expr_aux(obj<AAllocator> expr_alloc,
|
|
const TypeRef::prefix_type & prefix,
|
|
obj<AGCObject> pm_obj,
|
|
obj<AExpression> lhs,
|
|
obj<AExpression> rhs)
|
|
{
|
|
auto fn_expr = DConstant::make(expr_alloc, pm_obj);
|
|
|
|
/* note:
|
|
* 1. don't assume we know lhs_ / rhs_ value types yet.
|
|
* perhaps have expression like
|
|
* f(..) * g(..)
|
|
* where f is the function that contains current ssm.
|
|
*
|
|
* 2. consequence: we need representation for
|
|
* polymorphic multiply on unknown numeric arguments.
|
|
*
|
|
* 3. TypeRef::dwim(..) is a placeholder.
|
|
* Plan to later provide abstract interpreter
|
|
* (ie compiler pass :) to drive type inference/unification
|
|
*
|
|
* 4. Alternatively could supply type-annotation syntax
|
|
* so human can assist inference; context here is we want
|
|
* to automate the boring stuff
|
|
*/
|
|
|
|
TypeRef tref = TypeRef::dwim(prefix, nullptr);
|
|
|
|
return DApplyExpr::make2(expr_alloc,
|
|
tref, fn_expr, lhs, rhs);
|
|
|
|
}
|
|
|
|
#ifdef OBSOLETE
|
|
obj<AExpression>
|
|
assemble_numeric_expr_aux(obj<AAllocator> expr_alloc,
|
|
const TypeRef::prefix_type & prefix,
|
|
DPrimitive_gco_2_gco_gco * p_gco_pm,
|
|
obj<AExpression> lhs,
|
|
obj<AExpression> rhs)
|
|
{
|
|
auto pm_obj = with_facet<AGCObject>::mkobj(p_gco_pm);
|
|
|
|
return assemble_numeric_expr_aux(expr_alloc,
|
|
prefix,
|
|
pm_obj,
|
|
lhs, rhs);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
obj<AExpression>
|
|
DProgressSsm::assemble_expr(ParserStateMachine * p_psm)
|
|
{
|
|
/* need to defer building Apply incase expr followed by higher-precedence operator:
|
|
* consider input like
|
|
* 3.14 + 2.0 * ...
|
|
*/
|
|
|
|
constexpr const char * c_self_name = "DProgressSsm::assemble_expr";
|
|
|
|
if ((op_type_ != optype::invalid) && !rhs_) {
|
|
std::string errmsg_string = tostr("expected expression on rhs of operator op",
|
|
xtag("lhs", lhs_),
|
|
xtag("op", op_type_));
|
|
|
|
auto errmsg = DString::from_view(p_psm->expr_alloc(),
|
|
std::string_view(errmsg_string));
|
|
|
|
p_psm->capture_error(c_self_name, errmsg);
|
|
return obj<AExpression>();
|
|
}
|
|
|
|
/* consecutive expressions not legal, e.g:
|
|
* 3.14 6.28
|
|
* but expressions surrounding an infix operators is:
|
|
* 3.14 / 6.28
|
|
*/
|
|
switch (op_type_) {
|
|
case optype::invalid:
|
|
return this->lhs_;
|
|
|
|
case optype::op_assign:
|
|
assert(false);
|
|
break;
|
|
|
|
case optype::op_equal:
|
|
return assemble_numeric_expr_aux
|
|
(p_psm->expr_alloc(),
|
|
TypeRef::prefix_type::from_chars("_cmpeq_gco"),
|
|
p_psm->cmpeq_pm(),
|
|
lhs_, rhs_);
|
|
|
|
case optype::op_not_equal:
|
|
return assemble_numeric_expr_aux
|
|
(p_psm->expr_alloc(),
|
|
TypeRef::prefix_type::from_chars("_cmpne_gco"),
|
|
p_psm->cmpne_pm(),
|
|
lhs_, rhs_);
|
|
|
|
case optype::op_less:
|
|
return assemble_numeric_expr_aux
|
|
(p_psm->expr_alloc(),
|
|
TypeRef::prefix_type::from_chars("_cmplt_gco"),
|
|
p_psm->cmplt_pm(),
|
|
lhs_, rhs_);
|
|
|
|
case optype::op_less_equal:
|
|
return assemble_numeric_expr_aux
|
|
(p_psm->expr_alloc(),
|
|
TypeRef::prefix_type::from_chars("_cmple_gco"),
|
|
p_psm->cmple_pm(),
|
|
lhs_, rhs_);
|
|
|
|
case optype::op_great:
|
|
return assemble_numeric_expr_aux
|
|
(p_psm->expr_alloc(),
|
|
TypeRef::prefix_type::from_chars("_cmpgt_gco"),
|
|
p_psm->cmpgt_pm(),
|
|
lhs_, rhs_);
|
|
break;
|
|
|
|
case optype::op_great_equal:
|
|
return assemble_numeric_expr_aux
|
|
(p_psm->expr_alloc(),
|
|
TypeRef::prefix_type::from_chars("_cmpge_gco"),
|
|
p_psm->cmpge_pm(),
|
|
lhs_, rhs_);
|
|
|
|
case optype::op_multiply:
|
|
return assemble_numeric_expr_aux
|
|
(p_psm->expr_alloc(),
|
|
TypeRef::prefix_type::from_chars("_mul_gco"),
|
|
p_psm->multiply_pm(),
|
|
lhs_, rhs_);
|
|
|
|
case optype::op_divide:
|
|
return assemble_numeric_expr_aux
|
|
(p_psm->expr_alloc(),
|
|
TypeRef::prefix_type::from_chars("_div_gco"),
|
|
p_psm->divide_pm(),
|
|
lhs_, rhs_);
|
|
|
|
case optype::op_add:
|
|
return assemble_numeric_expr_aux
|
|
(p_psm->expr_alloc(),
|
|
TypeRef::prefix_type::from_chars("_add_gco"),
|
|
p_psm->add_pm(),
|
|
lhs_, rhs_);
|
|
|
|
break;
|
|
|
|
case optype::op_subtract: /* editor bait: op_minus */
|
|
return assemble_numeric_expr_aux
|
|
(p_psm->expr_alloc(),
|
|
TypeRef::prefix_type::from_chars("_sub_gco"),
|
|
p_psm->subtract_pm(),
|
|
lhs_, rhs_);
|
|
|
|
#ifdef NOT_YET
|
|
case optype::op_assign:
|
|
{
|
|
bp<Variable> lhs = Variable::from(this->lhs_);
|
|
|
|
if (!lhs) {
|
|
throw std::runtime_error
|
|
(tostr("progress_xs::assemble_expr",
|
|
" expect variable on lhs of assignment operator :=",
|
|
xtag("lhs", lhs_),
|
|
xtag("rhs", rhs_)));
|
|
}
|
|
|
|
return AssignExpr::make(lhs.promote(),
|
|
this->rhs_);
|
|
}
|
|
|
|
#endif
|
|
|
|
case optype::n_optype:
|
|
/* unreachable */
|
|
assert(false);
|
|
break;
|
|
}
|
|
|
|
return obj<AExpression>();
|
|
}
|
|
|
|
void
|
|
DProgressSsm::visit_gco_children(VisitReason reason,
|
|
obj<AGCObjectVisitor> gc) noexcept
|
|
{
|
|
gc.visit_poly_child(reason, &lhs_);
|
|
gc.visit_poly_child(reason, &rhs_);
|
|
}
|
|
|
|
} /*namespace scm*/
|
|
} /*namespace xo*/
|
|
|
|
/* end DProgressSsm.cpp */
|