267 lines
8.4 KiB
C++
267 lines
8.4 KiB
C++
/* @file paren_xs.cpp */
|
|
|
|
#include "paren_xs.hpp"
|
|
#include "progress_xs.hpp"
|
|
|
|
namespace xo {
|
|
namespace scm {
|
|
paren_xs::paren_xs()
|
|
: parenxs_type_{parenexprstatetype::lparen_0}
|
|
{}
|
|
|
|
std::unique_ptr<paren_xs>
|
|
paren_xs::lparen_0() {
|
|
return std::make_unique<paren_xs>(paren_xs());
|
|
}
|
|
|
|
bool
|
|
paren_xs::admits_definition() const { return false; }
|
|
|
|
bool
|
|
paren_xs::admits_symbol() const { return true; }
|
|
|
|
bool
|
|
paren_xs::admits_colon() const { return false; }
|
|
|
|
bool
|
|
paren_xs::admits_semicolon() const { return false; }
|
|
|
|
bool
|
|
paren_xs::admits_singleassign() const { return false; }
|
|
|
|
bool
|
|
paren_xs::admits_leftparen() const { /*unreachable*/ return false; }
|
|
|
|
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(exprstatestack * /*p_stack*/) {
|
|
constexpr const char * c_self_name = "paren_xs::on_def";
|
|
|
|
throw std::runtime_error(tostr(c_self_name,
|
|
": unexpected keyword 'def' for parsing state",
|
|
xtag("state", *this)));
|
|
}
|
|
|
|
void
|
|
paren_xs::on_symbol_token(const token_type & /*tk*/,
|
|
exprstatestack * p_stack,
|
|
rp<Expression> * /*p_emit_expr*/)
|
|
{
|
|
constexpr bool c_debug_flag = true;
|
|
scope log(XO_DEBUG(c_debug_flag));
|
|
|
|
log && log(xtag("exstype", p_stack->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*/,
|
|
exprstatestack * /*p_stack*/,
|
|
rp<Expression> * /*p_emit_expr*/)
|
|
{
|
|
assert(false);
|
|
return;
|
|
}
|
|
|
|
void
|
|
paren_xs::on_colon_token(const token_type & /*tk*/,
|
|
exprstatestack * /*p_stack*/)
|
|
{
|
|
constexpr const char * c_self_name = "paren_xs::on_colon";
|
|
|
|
throw std::runtime_error(tostr(c_self_name,
|
|
": unexpected colon for parsing state",
|
|
xtag("state", *this)));
|
|
}
|
|
|
|
void
|
|
paren_xs::on_semicolon_token(const token_type & /*tk*/,
|
|
exprstatestack * /*p_stack*/,
|
|
rp<Expression> * /*p_emit_expr*/)
|
|
{
|
|
constexpr const char * c_self_name = "paren_xs::on_semicolon";
|
|
|
|
throw std::runtime_error(tostr(c_self_name,
|
|
": unexpected semicolon for parsing state",
|
|
xtag("state", *this)));
|
|
}
|
|
|
|
void
|
|
paren_xs::on_singleassign_token(const token_type & /*tk*/,
|
|
exprstatestack * /*p_stack*/)
|
|
{
|
|
constexpr const char * c_self_name = "paren_xs::on_singleassign";
|
|
|
|
throw std::runtime_error(tostr(c_self_name,
|
|
": unexpected equals for parsing state",
|
|
xtag("state", *this)));
|
|
}
|
|
|
|
void
|
|
paren_xs::on_leftparen_token(const token_type & /*tk*/,
|
|
exprstatestack * /*p_stack*/,
|
|
rp<Expression> * /*p_emit_expr*/)
|
|
{
|
|
constexpr const char * c_self_name = "paren_xs::on_leftparen";
|
|
|
|
throw std::runtime_error(tostr(c_self_name,
|
|
": unexpected leftparen '(' for parsing state",
|
|
xtag("state", *this)));
|
|
}
|
|
|
|
void
|
|
paren_xs::on_rightparen(exprstatestack * p_stack,
|
|
rp<Expression> * p_emit_expr)
|
|
{
|
|
constexpr bool c_debug_flag = true;
|
|
scope log(XO_DEBUG(c_debug_flag));
|
|
|
|
constexpr const char * self_name = "paren_xs::on_rightparen";
|
|
|
|
if (!this->admits_rightparen())
|
|
{
|
|
throw std::runtime_error(tostr(self_name,
|
|
": unexpected rightparen ')' for parsing state",
|
|
xtag("state", *this)));
|
|
}
|
|
|
|
if (this->parenxs_type_ == parenexprstatetype::lparen_1) {
|
|
rp<Expression> expr = this->gen_expr_;
|
|
|
|
std::unique_ptr<exprstate> self = p_stack->pop_exprstate();
|
|
|
|
p_stack->top_exprstate().on_expr(expr, p_stack, p_emit_expr);
|
|
}
|
|
}
|
|
|
|
void
|
|
paren_xs::on_f64(const token_type & /*tk*/,
|
|
exprstatestack * /*p_stack*/,
|
|
rp<Expression> * /*p_emit_expr*/)
|
|
{
|
|
constexpr bool c_debug_flag = true;
|
|
scope log(XO_DEBUG(c_debug_flag));
|
|
|
|
constexpr const char * c_self_name = "paren_xs::on_f64";
|
|
|
|
if (!this->admits_f64())
|
|
{
|
|
throw std::runtime_error(tostr(c_self_name,
|
|
": unexpected floating-point literal for parsing state",
|
|
xtag("state", *this)));
|
|
}
|
|
|
|
assert(false);
|
|
}
|
|
|
|
void
|
|
paren_xs::on_expr(ref::brw<Expression> expr,
|
|
exprstatestack * p_stack,
|
|
rp<Expression> * /*p_emit_expr*/)
|
|
{
|
|
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 */
|
|
p_stack->push_exprstate(progress_xs::make(expr.promote()));
|
|
|
|
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*/,
|
|
exprstatestack * /*p_stack*/,
|
|
rp<Expression> * /*p_emit_expr*/)
|
|
{
|
|
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("type", exs_type_);
|
|
if (gen_expr_)
|
|
os << xtag("gen_expr", gen_expr_);
|
|
os << ">";
|
|
}
|
|
|
|
|
|
} /*namespace scm*/
|
|
} /*namespace xo*/
|
|
|
|
|
|
/* end paren_xs.cpp */
|