460 lines
14 KiB
C++
460 lines
14 KiB
C++
/** @file DParenSsm.cpp
|
|
*
|
|
* @author Roland Conybeare, Feb 2026
|
|
**/
|
|
|
|
#include "ParenSsm.hpp"
|
|
#include "ExpectExprSsm.hpp"
|
|
#include "syntaxstatetype.hpp"
|
|
#include <string_view>
|
|
|
|
namespace xo {
|
|
using xo::facet::with_facet;
|
|
using xo::facet::typeseq;
|
|
|
|
namespace scm {
|
|
|
|
extern const char *
|
|
parenexprstatetype_descr(parenexprstatetype x)
|
|
{
|
|
switch(x) {
|
|
case parenexprstatetype::invalid: return "invalid";
|
|
case parenexprstatetype::lparen_0: return "lparen_0";
|
|
case parenexprstatetype::lparen_1: return "lparen_1";
|
|
case parenexprstatetype::lparen_2: return "lparen_2";
|
|
case parenexprstatetype::N: break;
|
|
}
|
|
|
|
return "???parenexprstatetype";
|
|
}
|
|
|
|
std::ostream &
|
|
operator<<(std::ostream & os, parenexprstatetype x) {
|
|
os << parenexprstatetype_descr(x);
|
|
return os;
|
|
}
|
|
|
|
DParenSsm::DParenSsm()
|
|
: parenstate_(parenexprstatetype::lparen_0),
|
|
expr_{}
|
|
{}
|
|
|
|
DParenSsm *
|
|
DParenSsm::_make(DArena & mm)
|
|
{
|
|
void * mem = mm.alloc(typeseq::id<DParenSsm>(),
|
|
sizeof(DParenSsm));
|
|
|
|
return new (mem) DParenSsm();
|
|
}
|
|
|
|
obj<ASyntaxStateMachine,DParenSsm>
|
|
DParenSsm::make(DArena & mm)
|
|
{
|
|
return obj<ASyntaxStateMachine,DParenSsm>(_make(mm));
|
|
}
|
|
|
|
void
|
|
DParenSsm::start(ParserStateMachine * p_psm)
|
|
{
|
|
DArena::Checkpoint ckp = p_psm->parser_alloc().checkpoint();
|
|
|
|
auto paren_ssm = DParenSsm::make(p_psm->parser_alloc());
|
|
|
|
p_psm->push_ssm(ckp, paren_ssm);
|
|
}
|
|
|
|
syntaxstatetype
|
|
DParenSsm::ssm_type() const noexcept
|
|
{
|
|
return syntaxstatetype::paren;
|
|
}
|
|
|
|
std::string_view
|
|
DParenSsm::get_expect_str() const noexcept
|
|
{
|
|
switch (this->parenstate_) {
|
|
case parenexprstatetype::invalid:
|
|
case parenexprstatetype::N:
|
|
break;
|
|
case parenexprstatetype::lparen_0: return "leftparen";
|
|
case parenexprstatetype::lparen_1: return "expression";
|
|
case parenexprstatetype::lparen_2: return "rightparen";
|
|
}
|
|
|
|
return "???parenexprstatetype";
|
|
}
|
|
|
|
void
|
|
DParenSsm::on_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
switch (tk.tk_type()) {
|
|
|
|
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_symbol:
|
|
case tokentype::tk_def:
|
|
case tokentype::tk_colon:
|
|
case tokentype::tk_singleassign:
|
|
case tokentype::tk_semicolon:
|
|
case tokentype::tk_invalid:
|
|
case tokentype::tk_string:
|
|
case tokentype::tk_f64:
|
|
case tokentype::tk_i64:
|
|
case tokentype::tk_bool:
|
|
case tokentype::tk_if:
|
|
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_then:
|
|
case tokentype::tk_else:
|
|
case tokentype::tk_let:
|
|
case tokentype::tk_in:
|
|
case tokentype::tk_end:
|
|
case tokentype::N:
|
|
break;
|
|
}
|
|
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
void
|
|
DParenSsm::on_leftparen_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
if (parenstate_ == parenexprstatetype::lparen_0) {
|
|
this->parenstate_ = parenexprstatetype::lparen_1;
|
|
|
|
/** 1. allow_defs=false not allowing definitions immediately
|
|
* within a parenthesized expression.
|
|
* e.g.
|
|
* (def y : i64 = 4; x + y) // nope
|
|
* 2. cxl_on_rightparen=false expression _must_ be followed
|
|
* by rightparen. empty parentheses '()'
|
|
* do not denote anything, in expression context
|
|
**/
|
|
DExpectExprSsm::start(p_psm);
|
|
|
|
return;
|
|
}
|
|
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
#ifdef OBSOLETE
|
|
void
|
|
paren_xs::start(parserstatemachine * p_psm)
|
|
{
|
|
p_psm->push_exprstate(paren_xs::make());
|
|
expect_expr_xs::start(p_psm);
|
|
}
|
|
|
|
bool
|
|
paren_xs::admits_rightparen() const {
|
|
switch (parenxs_type_) {
|
|
case parenexprstatetype::lparen_0:
|
|
/* unreachable */
|
|
assert(false);
|
|
return false;
|
|
|
|
case parenexprstatetype::lparen_1:
|
|
return true;
|
|
|
|
case parenexprstatetype::invalid:
|
|
case parenexprstatetype::n_parenexprstatetype:
|
|
/* unreachable */
|
|
assert(false);
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
paren_xs::admits_f64() const {
|
|
switch (parenxs_type_) {
|
|
case parenexprstatetype::lparen_0:
|
|
return true;
|
|
|
|
case parenexprstatetype::lparen_1:
|
|
return false;
|
|
|
|
case parenexprstatetype::invalid:
|
|
case parenexprstatetype::n_parenexprstatetype:
|
|
/* unreachable */
|
|
assert(false);
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void
|
|
paren_xs::on_def_token(const token_type & tk,
|
|
parserstatemachine * /*p_psm*/)
|
|
{
|
|
constexpr const char * c_self_name = "paren_xs::on_def";
|
|
|
|
this->illegal_input_error(c_self_name, tk);
|
|
}
|
|
|
|
void
|
|
paren_xs::on_symbol_token(const token_type & /*tk*/,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
constexpr bool c_debug_flag = true;
|
|
scope log(XO_DEBUG(c_debug_flag));
|
|
|
|
log && log(xtag("exstype", p_psm->top_exprstate().exs_type()));
|
|
|
|
//constexpr const char * self_name = "paren_xs::on_symbol";
|
|
|
|
/* TODO: lparen_0: treat as variable reference */
|
|
|
|
assert(false);
|
|
}
|
|
|
|
void
|
|
paren_xs::on_typedescr(TypeDescr /*td*/,
|
|
parserstatemachine * /*p_psm*/)
|
|
{
|
|
assert(false);
|
|
return;
|
|
}
|
|
|
|
void
|
|
paren_xs::on_colon_token(const token_type & tk,
|
|
parserstatemachine * /*p_psm*/)
|
|
{
|
|
constexpr const char * c_self_name = "paren_xs::on_colon";
|
|
|
|
this->illegal_input_error(c_self_name, tk);
|
|
}
|
|
|
|
void
|
|
paren_xs::on_semicolon_token(const token_type & tk,
|
|
parserstatemachine * /*p_psm*/)
|
|
{
|
|
constexpr const char * c_self_name = "paren_xs::on_semicolon";
|
|
|
|
this->illegal_input_error(c_self_name, tk);
|
|
}
|
|
|
|
void
|
|
paren_xs::on_singleassign_token(const token_type & tk,
|
|
parserstatemachine * /*p_psm*/)
|
|
{
|
|
constexpr const char * c_self_name = "paren_xs::on_singleassign";
|
|
|
|
this->illegal_input_error(c_self_name, tk);
|
|
}
|
|
|
|
void
|
|
paren_xs::on_leftparen_token(const token_type & tk,
|
|
parserstatemachine * /*p_psm*/)
|
|
{
|
|
constexpr const char * c_self_name = "paren_xs::on_leftparen";
|
|
|
|
this->illegal_input_error(c_self_name, tk);
|
|
}
|
|
#endif
|
|
|
|
void
|
|
DParenSsm::on_rightparen_token(const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
if (this->parenstate_ == parenexprstatetype::lparen_2) {
|
|
// parenthesized expression successfully parsed
|
|
|
|
p_psm->pop_ssm();
|
|
p_psm->on_parsed_expression(this->expr_);
|
|
return;
|
|
}
|
|
|
|
Super::on_token(tk, p_psm);
|
|
}
|
|
|
|
#ifdef NOT_YET
|
|
void
|
|
paren_xs::on_rightparen_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 = "paren_xs::on_rightparen";
|
|
|
|
if (!this->admits_rightparen())
|
|
{
|
|
this->illegal_input_error(c_self_name, tk);
|
|
}
|
|
|
|
if (this->parenxs_type_ == parenexprstatetype::lparen_1) {
|
|
rp<Expression> expr = this->gen_expr_;
|
|
|
|
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
|
|
|
p_psm->top_exprstate().on_expr(expr, p_psm);
|
|
}
|
|
}
|
|
|
|
void
|
|
paren_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 = "paren_xs::on_i64";
|
|
|
|
this->illegal_input_error(c_self_name, tk);
|
|
}
|
|
|
|
void
|
|
paren_xs::on_f64_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 = "paren_xs::on_f64";
|
|
|
|
this->illegal_input_error(c_self_name, tk);
|
|
}
|
|
#endif
|
|
|
|
void
|
|
DParenSsm::on_parsed_expression(obj<AExpression> expr,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
if (parenstate_ == parenexprstatetype::lparen_1) {
|
|
this->parenstate_ = parenexprstatetype::lparen_2;
|
|
this->expr_ = expr;
|
|
|
|
return;
|
|
}
|
|
|
|
Super::on_parsed_expression(expr, p_psm);
|
|
}
|
|
|
|
void
|
|
DParenSsm::on_parsed_expression_with_token(obj<AExpression> expr,
|
|
const Token & tk,
|
|
ParserStateMachine * p_psm)
|
|
{
|
|
if (parenstate_ == parenexprstatetype::lparen_1) {
|
|
this->parenstate_ = parenexprstatetype::lparen_2;
|
|
this->expr_ = expr;
|
|
|
|
this->on_token(tk, p_psm);
|
|
|
|
return;
|
|
}
|
|
|
|
Super::on_parsed_expression(expr, p_psm);
|
|
}
|
|
|
|
#ifdef NOT_YET
|
|
void
|
|
paren_xs::on_expr(bp<Expression> expr,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
constexpr bool c_debug_flag = true;
|
|
scope log(XO_DEBUG(c_debug_flag));
|
|
|
|
log && log(xtag("exstype", this->exs_type_),
|
|
xtag("expr", expr));
|
|
|
|
switch (this->parenxs_type_) {
|
|
case parenexprstatetype::lparen_0: {
|
|
this->parenxs_type_ = parenexprstatetype::lparen_1; /* wants on_rightparen */
|
|
progress_xs::start(expr.promote(), p_psm);
|
|
|
|
return;
|
|
}
|
|
|
|
case parenexprstatetype::lparen_1: {
|
|
this->gen_expr_ = expr.promote();
|
|
|
|
/* expect immediate incoming call, this time to on_rightparen() */
|
|
return;
|
|
}
|
|
|
|
default:
|
|
/* unreachable */
|
|
assert(false);
|
|
return;
|
|
}
|
|
} /*on_expr*/
|
|
|
|
void
|
|
paren_xs::on_symbol(const std::string & /*symbol_name*/,
|
|
parserstatemachine * /*p_psm*/)
|
|
{
|
|
switch(this->parenxs_type_) {
|
|
case parenexprstatetype::lparen_0:
|
|
case parenexprstatetype::lparen_1:
|
|
/* NOT IMPLEMENTED */
|
|
assert(false);
|
|
return;
|
|
|
|
default:
|
|
/* unreachable */
|
|
assert(false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void
|
|
paren_xs::print(std::ostream & os) const {
|
|
os << "<paren_xs"
|
|
<< xtag("this", (void*)this)
|
|
//<< xtag("type", exs_type_);
|
|
<< xtag("parenxs_type", parenxs_type_);
|
|
|
|
if (gen_expr_)
|
|
os << xtag("gen_expr", gen_expr_);
|
|
|
|
os << ">";
|
|
}
|
|
#endif
|
|
|
|
bool
|
|
DParenSsm::pretty(const ppindentinfo & ppii) const
|
|
{
|
|
return ppii.pps()->pretty_struct(ppii,
|
|
"DParenSsm",
|
|
refrtag("parenstate", parenstate_),
|
|
refrtag("expect", this->get_expect_str()));
|
|
}
|
|
|
|
} /*namespace scm*/
|
|
} /*namespace xo*/
|
|
|
|
/* end DParenSsm.cpp */
|