roland/xo-alloc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

xo-reader: refactor: splitoff paren handline -> paren_xs

Browse source
This commit is contained in:
Roland Conybeare 2024-08-09 11:55:22 -04:00
commit c1ab574a73
4 changed files with 108 additions and 140 deletions
Download patch file Download diff file Expand all files Collapse all files

19
include/xo/reader/exprstate.hpp
View file

@ -20,10 +20,8 @@ namespace xo {
defexpr,
/* lparen_0: look for expression; capture + advance to lparen_1 */
lparen_0,
/* lparen_1: expect rightparen */
lparen_1,
/* handle parenthesized expression */
parenexpr,
expect_rhs_expression,
expect_symbol,
@ -45,17 +43,6 @@ namespace xo {
class exprstatestack;
#ifdef NOT_YET
class exprstateaux {
public:
};
class lparen_xsa : public exprstateaux {
public:
private:
};
#endif
class define_xs;
/** state associated with a partially-parsed expression.
@ -92,9 +79,11 @@ namespace xo {
return std::make_unique<exprstate>(exprstate(exprstatetype::expr_progress, expr));
}
#endif
#ifdef RELOCATED
static std::unique_ptr<exprstate> lparen_0() {
return std::make_unique<exprstate>(exprstate(exprstatetype::lparen_0, nullptr));
}
#endif
exprstatetype exs_type() const { return exs_type_; }

6
include/xo/reader/paren_xs.hpp
View file

@ -24,12 +24,12 @@ namespace xo {
**/
class paren_xs : public exprstate {
public:
//paren_xs(rp<Expression> valex);
paren_xs();
virtual ~paren_xs() = default;
static const paren_xs * from(const exprstate * x) { return dynamic_cast<const paren_xs *>(x); }
//static std::unique_ptr<paren_xs> make();
static std::unique_ptr<paren_xs> lparen_0();
virtual bool admits_definition() const override;
virtual bool admits_symbol() const override;
@ -71,7 +71,6 @@ namespace xo {
virtual void print(std::ostream & os) const override;
private:
#ifdef NOT_YET
/**
* ( foo ... )
* ^
@ -79,7 +78,6 @@ namespace xo {
* lparen_0
**/
parenexprstatetype parenxs_type_;
#endif
};
} /*namespace scm*/
} /*namespace xo*/

174
src/reader/exprstate.cpp
View file

@ -3,6 +3,7 @@
#include "exprstate.hpp"
#include "define_xs.hpp"
#include "progress_xs.hpp"
#include "paren_xs.hpp"
//#include "xo/expression/DefineExpr.hpp"
#include "xo/expression/Constant.hpp"
//#include "xo/expression/ConvertExpr.hpp"
@ -23,10 +24,8 @@ namespace xo {
return "expect_toplevel_expression_sequence";
case exprstatetype::defexpr:
return "defexpr";
case exprstatetype::lparen_0:
return "lparen_0";
case exprstatetype::lparen_1:
return "lparen_1";
case exprstatetype::parenexpr:
return "parenexpr";
case exprstatetype::expect_rhs_expression:
return "expect_rhs_expression";
case exprstatetype::expect_symbol:
@ -49,11 +48,10 @@ namespace xo {
return true;
case exprstatetype::defexpr:
case exprstatetype::parenexpr:
/* unreachable */
assert(false);
return false;
case exprstatetype::lparen_0:
case exprstatetype::lparen_1:
case exprstatetype::expect_rhs_expression:
return false;
case exprstatetype::expect_symbol:
@ -79,12 +77,11 @@ namespace xo {
return false;
case exprstatetype::defexpr:
case exprstatetype::parenexpr:
/* unreachable */
assert(false);
return false;
case exprstatetype::lparen_0:
case exprstatetype::lparen_1:
case exprstatetype::expect_rhs_expression:
/* treat symbol as variable name */
return true;
@ -116,12 +113,11 @@ namespace xo {
case exprstatetype::expect_toplevel_expression_sequence:
case exprstatetype::defexpr:
/* unreachable -- redirects to define_xs::admits_colon() */
case exprstatetype::parenexpr:
/* unreachable -- redirects to define_xs::admits_colon() etc */
assert(false);
return false;
case exprstatetype::lparen_0:
case exprstatetype::lparen_1:
case exprstatetype::expect_rhs_expression:
/* rhs-expressions (or expressions for that matter)
* may not begin with a colon
@ -149,8 +145,7 @@ namespace xo {
switch (exs_type_) {
case exprstatetype::expect_toplevel_expression_sequence:
case exprstatetype::defexpr:
case exprstatetype::lparen_0:
case exprstatetype::lparen_1:
case exprstatetype::parenexpr:
case exprstatetype::expect_rhs_expression:
case exprstatetype::expect_symbol:
case exprstatetype::expect_type:
@ -187,12 +182,11 @@ namespace xo {
* note that we skip from def_1 -> def_4 if '=' instead of ':'
*/
case exprstatetype::defexpr:
/* unreachable - redirects to define_xs */
case exprstatetype::parenexpr:
/* unreachable - redirects to define_xs etrc */
assert(false);
return false;
case exprstatetype::lparen_0:
case exprstatetype::lparen_1:
case exprstatetype::expect_rhs_expression:
/* rhs-expressions (or expressions for that matter)
* may not begin with singleassign '='
@ -215,43 +209,6 @@ namespace xo {
return false;
}
bool
exprstate::admits_f64() const {
switch (exs_type_) {
case exprstatetype::expect_toplevel_expression_sequence:
case exprstatetype::defexpr:
/* unreachable - redirects to define_xs */
assert(false);
return false;
case exprstatetype::lparen_0:
return true;
case exprstatetype::lparen_1:
return false;
case exprstatetype::expect_rhs_expression:
return true;
case exprstatetype::expect_symbol:
case exprstatetype::expect_type:
return false;
case exprstatetype::expr_progress:
/* unreachable */
assert(false);
return false;
case exprstatetype::invalid:
case exprstatetype::n_exprstatetype:
/* unreachable */
return false;
}
return false;
}
bool
exprstate::admits_leftparen() const {
switch (exs_type_) {
@ -268,16 +225,11 @@ namespace xo {
return false;
case exprstatetype::defexpr:
case exprstatetype::parenexpr:
/* unreachable - redirects to define_xs */
assert(false);
return false;
case exprstatetype::lparen_0:
case exprstatetype::lparen_1:
/* unreachable */
assert(false);
return false;
case exprstatetype::expect_rhs_expression:
/* can always begin non-toplevel expression with '(' */
return true;
@ -310,18 +262,11 @@ namespace xo {
return false;
case exprstatetype::defexpr:
case exprstatetype::parenexpr:
/* unreachable - redirects to define_xs */
assert(false);
return false;
case exprstatetype::lparen_0:
/* unreachable -- will have pushed expect_rhs_expression */
assert(false);
return false;
case exprstatetype::lparen_1:
return true;
case exprstatetype::expect_rhs_expression:
return false;
@ -342,6 +287,38 @@ namespace xo {
return false;
}
bool
exprstate::admits_f64() const {
switch (exs_type_) {
case exprstatetype::expect_toplevel_expression_sequence:
case exprstatetype::defexpr:
case exprstatetype::parenexpr:
/* unreachable - redirects to define_xs */
assert(false);
return false;
case exprstatetype::expect_rhs_expression:
return true;
case exprstatetype::expect_symbol:
case exprstatetype::expect_type:
return false;
case exprstatetype::expr_progress:
/* unreachable */
assert(false);
return false;
case exprstatetype::invalid:
case exprstatetype::n_exprstatetype:
/* unreachable */
return false;
}
return false;
}
void
exprstate::on_def(exprstatestack * p_stack) {
constexpr bool c_debug_flag = true;
@ -400,21 +377,11 @@ namespace xo {
break;
case exprstatetype::defexpr:
case exprstatetype::parenexpr:
/* unreachable - redirects to define_xs */
assert(false);
return;
case exprstatetype::lparen_0:
/* todo: variable reference */
assert(false);
break;
case exprstatetype::lparen_1:
/* unreachable */
assert(false);
break;
case exprstatetype::expect_rhs_expression:
{
/* various possibilities when looking for rhs expression:
@ -503,21 +470,17 @@ namespace xo {
exprstatestack * /*p_stack*/,
rp<Expression> * /*p_emit_expr*/)
{
/* returning type description to somethign that wants it */
/* returning type description to something that wants it */
switch (this->exs_type_) {
case exprstatetype::expect_toplevel_expression_sequence:
case exprstatetype::defexpr:
case exprstatetype::parenexpr:
/* unreachable - redirects to define_xs */
assert(false);
return;
case exprstatetype::lparen_0:
case exprstatetype::lparen_1:
assert(false);
return;
case exprstatetype::expect_rhs_expression:
case exprstatetype::expect_type:
case exprstatetype::expect_symbol:
@ -612,14 +575,14 @@ namespace xo {
if (this->exs_type_ == exprstatetype::expect_rhs_expression) {
/* push lparen_0 to remember to look for subsequent rightparen. */
p_stack->push_exprstate(exprstate::lparen_0());
p_stack->push_exprstate(paren_xs::lparen_0());
p_stack->push_exprstate(exprstate::expect_rhs_expression());
}
}
void
exprstate::on_rightparen(exprstatestack * p_stack,
rp<Expression> * p_emit_expr)
exprstate::on_rightparen(exprstatestack * /*p_stack*/,
rp<Expression> * /*p_emit_expr*/)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
@ -633,15 +596,10 @@ namespace xo {
xtag("state", *this)));
}
if (this->exs_type_ == exprstatetype::expr_progress) {
/* unreachable -- see progress_xs::on_rightparen() */
if (this->exs_type_ == exprstatetype::expr_progress
|| this->exs_type_ == exprstatetype::parenexpr) {
/* unreachable -- see progress_xs::on_rightparen() etc */
assert(false);
} else if (this->exs_type_ == exprstatetype::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);
}
}
@ -787,24 +745,11 @@ namespace xo {
*p_emit_expr = expr.promote();
return;
case exprstatetype::defexpr:
/* unreachable. redirects to define_xs::on_expr() */
case exprstatetype::parenexpr:
/* unreachable. redirects to define_xs::on_expr() etc */
assert(false);
return;
case exprstatetype::lparen_0: {
this->exs_type_ = exprstatetype::lparen_1; /* wants on_rightparen */
p_stack->push_exprstate(progress_xs::make(expr.promote()));
return;
}
case exprstatetype::lparen_1: {
this->gen_expr_ = expr.promote();
/* expect immediate incoming call, this time to on_rightparen() */
return;
}
case exprstatetype::expect_rhs_expression: {
std::unique_ptr<exprstate> self = p_stack->pop_exprstate(); /* NOT KOSHER. invalidates *this */
@ -852,13 +797,8 @@ namespace xo {
assert(false);
return;
case exprstatetype::defexpr:
/* unreachable - redirects to define_xs */
assert(false);
return;
case exprstatetype::lparen_0:
case exprstatetype::lparen_1:
/* NOT IMPLEMENTED */
case exprstatetype::parenexpr:
/* unreachable - redirects to define_xs etc */
assert(false);
return;

65
src/reader/paren_xs.cpp
View file

@ -5,6 +5,15 @@
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; }
@ -23,13 +32,45 @@ namespace xo {
bool
paren_xs::admits_leftparen() const { /*unreachable*/ return false; }
/** TODO: fixme **/
bool
paren_xs::admits_rightparen() const { return exprstate::admits_rightparen(); }
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;
}
/** TODO: fixme **/
bool
paren_xs::admits_f64() const { return exprstate::admits_f64(); }
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*/) {
@ -124,7 +165,7 @@ namespace xo {
xtag("state", *this)));
}
if (this->exs_type_ == exprstatetype::lparen_1) {
if (this->parenxs_type_ == parenexprstatetype::lparen_1) {
rp<Expression> expr = this->gen_expr_;
std::unique_ptr<exprstate> self = p_stack->pop_exprstate();
@ -164,15 +205,15 @@ namespace xo {
log && log(xtag("exstype", this->exs_type_),
xtag("expr", expr));
switch (this->exs_type_) {
case exprstatetype::lparen_0: {
this->exs_type_ = exprstatetype::lparen_1; /* wants on_rightparen */
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 exprstatetype::lparen_1: {
case parenexprstatetype::lparen_1: {
this->gen_expr_ = expr.promote();
/* expect immediate incoming call, this time to on_rightparen() */
@ -191,9 +232,9 @@ namespace xo {
exprstatestack * /*p_stack*/,
rp<Expression> * /*p_emit_expr*/)
{
switch(this->exs_type_) {
case exprstatetype::lparen_0:
case exprstatetype::lparen_1:
switch(this->parenxs_type_) {
case parenexprstatetype::lparen_0:
case parenexprstatetype::lparen_1:
/* NOT IMPLEMENTED */
assert(false);
return;