288 lines
9.3 KiB
C++
288 lines
9.3 KiB
C++
/** @file if_else_xs.cpp
|
|
*
|
|
* author: Roland Conybeare, Jul 2025
|
|
**/
|
|
|
|
#include "if_else_xs.hpp"
|
|
//#include "exprstatestack.hpp"
|
|
#include "parserstatemachine.hpp"
|
|
#include "expect_expr_xs.hpp"
|
|
#include "xo/indentlog/print/ppdetail_atomic.hpp"
|
|
|
|
namespace xo {
|
|
namespace scm {
|
|
// ----- ifexprstatetype -----
|
|
|
|
const char *
|
|
ifexprstatetype_descr(ifexprstatetype x) {
|
|
switch (x) {
|
|
case ifexprstatetype::invalid: return "invalid";
|
|
case ifexprstatetype::if_0: return "if_0";
|
|
case ifexprstatetype::if_1: return "if_1";
|
|
case ifexprstatetype::if_2: return "if_2";
|
|
case ifexprstatetype::if_3: return "if_3";
|
|
case ifexprstatetype::if_4: return "if_4";
|
|
case ifexprstatetype::if_5: return "if_5";
|
|
case ifexprstatetype::if_6: return "if_6";
|
|
case ifexprstatetype::n_ifexprstatetype: break;
|
|
}
|
|
|
|
return "???ifexprstatetype";
|
|
}
|
|
|
|
std::ostream &
|
|
operator<<(std::ostream & os, ifexprstatetype x) {
|
|
os << ifexprstatetype_descr(x);
|
|
return os;
|
|
}
|
|
|
|
// ----- if_else_xs -----
|
|
|
|
std::unique_ptr<if_else_xs>
|
|
if_else_xs::make() {
|
|
return std::make_unique<if_else_xs>(if_else_xs(IfExprAccess::make_empty()));
|
|
}
|
|
|
|
void
|
|
if_else_xs::start(parserstatemachine * p_psm)
|
|
{
|
|
constexpr bool c_debug_flag = true;
|
|
scope log(XO_DEBUG(c_debug_flag));
|
|
|
|
p_psm->push_exprstate(if_else_xs::make());
|
|
p_psm->top_exprstate().on_if_token(token_type::if_token(), p_psm);
|
|
}
|
|
|
|
if_else_xs::if_else_xs(rp<IfExprAccess> if_expr)
|
|
: exprstate(exprstatetype::ifexpr),
|
|
ifxs_type_{ifexprstatetype::if_0},
|
|
if_expr_{std::move(if_expr)}
|
|
{}
|
|
|
|
const char *
|
|
if_else_xs::get_expect_str() const
|
|
{
|
|
/**
|
|
* if test-expr then then-expr else else-expr ;
|
|
* ^ ^ ^ ^ ^ ^ ^
|
|
* | | | | | | |
|
|
* | if_1 if_2 if_3 if_4 if_5 if_6
|
|
* if_0
|
|
*
|
|
* if_0 --on_if_token()--> if_1
|
|
* if_1 --on_expr()--> if_2
|
|
* if_2 --on_then_token()--> if_3
|
|
* if_3 --on_expr()--> if_4
|
|
* if_4 --on_else_token()--> if_5
|
|
* --on_semicolon_token()--> (done)
|
|
* if_5 --on_expr()-->if_6
|
|
* if_6 --on_semicolon_token()--> (done)
|
|
**/
|
|
switch (this->ifxs_type_) {
|
|
case ifexprstatetype::invalid:
|
|
case ifexprstatetype::if_0:
|
|
case ifexprstatetype::n_ifexprstatetype:
|
|
assert(false); // unreachable
|
|
return nullptr;
|
|
case ifexprstatetype::if_1:
|
|
return "expression";
|
|
case ifexprstatetype::if_2:
|
|
return "then";
|
|
case ifexprstatetype::if_3:
|
|
return "expression";
|
|
case ifexprstatetype::if_4:
|
|
return "else|semicolon";
|
|
case ifexprstatetype::if_5:
|
|
return "expression";
|
|
case ifexprstatetype::if_6:
|
|
return "semicolon";
|
|
}
|
|
|
|
return "?expect";
|
|
}
|
|
|
|
void
|
|
if_else_xs::on_if_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
log && log("ifxs_type", ifxs_type_);
|
|
|
|
if (this->ifxs_type_ == ifexprstatetype::if_0) {
|
|
this->ifxs_type_ = ifexprstatetype::if_1;
|
|
|
|
expect_expr_xs::start(p_psm);
|
|
return;
|
|
}
|
|
|
|
constexpr const char * c_self_name = "if_else_xs::on_if_token";
|
|
const char * exp = this->get_expect_str();
|
|
|
|
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
|
|
}
|
|
|
|
void
|
|
if_else_xs::on_then_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
log && log("ifxs_type", ifxs_type_);
|
|
|
|
if (this->ifxs_type_ == ifexprstatetype::if_2) {
|
|
this->ifxs_type_ = ifexprstatetype::if_3;
|
|
|
|
expect_expr_xs::start(p_psm);
|
|
return;
|
|
}
|
|
|
|
constexpr const char * c_self_name = "if_else_xs::on_then_token";
|
|
const char * exp = this->get_expect_str();
|
|
|
|
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
|
|
}
|
|
|
|
void
|
|
if_else_xs::on_else_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
log && log("ifxs_type", ifxs_type_);
|
|
|
|
if (this->ifxs_type_ == ifexprstatetype::if_4) {
|
|
this->ifxs_type_ = ifexprstatetype::if_5;
|
|
|
|
expect_expr_xs::start(p_psm);
|
|
return;
|
|
}
|
|
|
|
constexpr const char * c_self_name = "if_else_xs::on_else_token";
|
|
const char * exp = this->get_expect_str();
|
|
|
|
this->illegal_input_on_token(c_self_name, tk, exp, p_psm);
|
|
}
|
|
|
|
void
|
|
if_else_xs::finish_and_continue(parserstatemachine * p_psm)
|
|
{
|
|
rp<IfExprAccess> if_expr = this->if_expr_;
|
|
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
|
|
|
if (this->ifxs_type_ == ifexprstatetype::if_4) {
|
|
/* if no else-branch, then if-expr can't have valuetype */
|
|
if_expr->assign_valuetype(nullptr);
|
|
}
|
|
|
|
p_psm->top_exprstate().on_expr(if_expr, p_psm);
|
|
}
|
|
|
|
void
|
|
if_else_xs::on_rightbrace_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
this->finish_and_continue(p_psm);
|
|
p_psm->on_rightbrace_token(tk);
|
|
}
|
|
|
|
void
|
|
if_else_xs::on_semicolon_token(const token_type & tk,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
log && log("ifxs_type", ifxs_type_);
|
|
|
|
const char * c_self_name = "if_else_xs::on_semicolon_token";
|
|
|
|
switch (this->ifxs_type_) {
|
|
case ifexprstatetype::invalid:
|
|
case ifexprstatetype::if_0:
|
|
case ifexprstatetype::n_ifexprstatetype:
|
|
// unreachable
|
|
assert(false);
|
|
break;
|
|
|
|
case ifexprstatetype::if_1:
|
|
case ifexprstatetype::if_2:
|
|
case ifexprstatetype::if_3:
|
|
case ifexprstatetype::if_5:
|
|
this->illegal_input_on_token(c_self_name, tk, get_expect_str(), p_psm);
|
|
break;
|
|
case ifexprstatetype::if_4:
|
|
case ifexprstatetype::if_6: {
|
|
this->finish_and_continue(p_psm);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
if_else_xs::on_expr(bp<Expression> expr,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
log && log(xtag("ifxs_type", ifxs_type_));
|
|
|
|
switch (this->ifxs_type_) {
|
|
case ifexprstatetype::invalid:
|
|
case ifexprstatetype::if_0:
|
|
case ifexprstatetype::n_ifexprstatetype:
|
|
assert(false); // unreachable
|
|
return;
|
|
case ifexprstatetype::if_1:
|
|
if_expr_->assign_test(expr.promote());
|
|
ifxs_type_ = ifexprstatetype::if_2;
|
|
return;
|
|
case ifexprstatetype::if_2:
|
|
/** error: expecting 'then' **/
|
|
break;
|
|
case ifexprstatetype::if_3:
|
|
if_expr_->assign_when_true(expr.promote());
|
|
ifxs_type_ = ifexprstatetype::if_4;
|
|
return;
|
|
case ifexprstatetype::if_4:
|
|
/** error: expecting 'else' or ';' **/
|
|
break;
|
|
case ifexprstatetype::if_5:
|
|
if_expr_->assign_when_false(expr.promote());
|
|
ifxs_type_ = ifexprstatetype::if_6;
|
|
return;
|
|
case ifexprstatetype::if_6:
|
|
/** error: expecting ';' **/
|
|
break;
|
|
}
|
|
|
|
constexpr const char* c_self_name = "if_else_xs::on_expr";
|
|
const char * exp = get_expect_str();
|
|
|
|
this->illegal_input_on_expr(c_self_name, expr, exp, p_psm);
|
|
}
|
|
|
|
void
|
|
if_else_xs::on_expr_with_semicolon(bp<Expression> expr,
|
|
parserstatemachine * p_psm)
|
|
{
|
|
scope log(XO_DEBUG(p_psm->debug_flag()));
|
|
|
|
|
|
log && log(xtag("ifxs_type", ifxs_type_));
|
|
|
|
this->on_expr(expr, p_psm);
|
|
this->on_semicolon_token(token_type::semicolon(), p_psm);
|
|
}
|
|
|
|
void
|
|
if_else_xs::print(std::ostream & os) const {
|
|
os << "<if_else_xs"
|
|
<< xtag("this", (void*)this)
|
|
<< xtag("ifxs_type", ifxs_type_)
|
|
<< ">";
|
|
}
|
|
|
|
} /*namespace scm*/
|
|
} /*namespace xo*/
|