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

xo-reader: prefer xo::bp spelling to xo::ref::brw

Browse source
This commit is contained in:
Roland Conybeare 2025-07-05 13:54:34 -05:00
commit 53b6adeef1
26 changed files with 152 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

13
xo-reader/src/reader/define_xs.cpp
View file

@ -58,7 +58,7 @@ namespace xo {
{}
void
define_xs::on_expr(ref::brw<Expression> expr,
define_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
@ -90,7 +90,7 @@ namespace xo {
}
void
define_xs::on_expr_with_semicolon(ref::brw<Expression> expr,
define_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
this->on_expr(expr, p_psm);
@ -186,11 +186,16 @@ namespace xo {
log && log("defxs_type", defxs_type_);
if (this->defxs_type_ == defexprstatetype::def_6) {
rp<Expression> expr = this->def_expr_;
rp<DefineExprAccess> def_expr = this->def_expr_;
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
p_psm->top_exprstate().on_expr(expr, p_psm);
/* remember variable binding in lexical context,
* so we can refer to it later
*/
p_psm->upsert_var(def_expr->lhs_variable());
p_psm->top_exprstate().on_expr(def_expr, p_psm);
} else {
exprstate::on_semicolon_token(tk, p_psm);
}

14
xo-reader/src/reader/envframe.cpp
View file

@ -20,6 +20,20 @@ namespace xo {
return nullptr;
}
void
envframe::upsert(bp<Variable> target) {
for (auto & var : this->argl_) {
if (var->name() == target->name()) {
/* replace existing variable -- may change type */
var = target.promote();
return;
}
}
/* here: target not already present in this frame, append it */
this->argl_.push_back(target.promote());
}
void
envframe::print(std::ostream & os) const {
os << "<envframe"

8
xo-reader/src/reader/envframestack.cpp
View file

@ -66,6 +66,14 @@ namespace xo {
return nullptr;
}
void
envframestack::upsert(bp<Variable> x) {
/* upsert should always happen in the innermost lexical context.
* We are providing new variable binding (perhaps shadowing an existing binding)
*/
this->top_envframe().upsert(x);
}
void
envframestack::print(std::ostream & os) const {
os << "<envframestack"

4
xo-reader/src/reader/expect_expr_xs.cpp
View file

@ -203,7 +203,7 @@ namespace xo {
}
void
expect_expr_xs::on_expr(ref::brw<Expression> expr,
expect_expr_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
@ -218,7 +218,7 @@ namespace xo {
} /*on_expr*/
void
expect_expr_xs::on_expr_with_semicolon(ref::brw<Expression> expr,
expect_expr_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;

42
xo-reader/src/reader/exprseq_xs.cpp
View file

@ -4,9 +4,11 @@
#include "parserstatemachine.hpp"
#include "exprstatestack.hpp"
#include "exprseq_xs.hpp"
#include "expect_expr_xs.hpp"
//#include "expect_expr_xs.hpp"
#include "progress_xs.hpp"
#include "define_xs.hpp"
#include "expect_symbol_xs.hpp"
#include "xo/expression/Constant.hpp"
namespace xo {
namespace scm {
@ -47,17 +49,41 @@ namespace xo {
void
exprseq_xs::on_symbol_token(const token_type & tk,
parserstatemachine * /*p_psm*/)
parserstatemachine * p_psm)
{
constexpr const char * c_self_name = "exprseq_xs::on_symbol_token";
this->illegal_input_error(c_self_name, tk);
if (xseqtype_ == exprseqtype::toplevel_interactive)
{
/* In interactive session, allow top-level variable reference.
* This could be:
* a; // variable references
* a = 1; // single assignment
* a == 1; // rhs expression
* a + b; // rhs expression
* Variable must have been defined!
*/
rp<Variable> var = p_psm->lookup_var(tk.text());
if (var.get()) {
progress_xs::start(var, p_psm);
} else {
this->unknown_variable_error(c_self_name, tk);
}
} else {
/* policy: don't allow variable references as toplevel expressions
* unless interactive session
*/
this->illegal_input_error(c_self_name, tk);
}
}
void
exprseq_xs::on_i64_token(const token_type & tk,
parserstatemachine * p_psm)
{
using xo::ast::Constant;
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
@ -65,9 +91,11 @@ namespace xo {
if (xseqtype_ == exprseqtype::toplevel_interactive)
{
expect_expr_xs::start(p_psm);
p_psm->top_exprstate().on_i64_token(tk, p_psm);
progress_xs::start(Constant<int64_t>::make(tk.i64_value()), p_psm);
} else {
/* policy: don't allow literals as toplevel expressions
* unless interactive session.
*/
this->illegal_input_error(c_self_name, tk);
}
}
@ -82,7 +110,7 @@ namespace xo {
}
void
exprseq_xs::on_expr(ref::brw<Expression> expr,
exprseq_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
/* toplevel expression sequence accepts an
@ -95,7 +123,7 @@ namespace xo {
} /*on_expr*/
void
exprseq_xs::on_expr_with_semicolon(ref::brw<Expression> expr,
exprseq_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
/* toplevel expression sequence accepts an

21
xo-reader/src/reader/exprstate.cpp
View file

@ -58,8 +58,13 @@ namespace xo {
void
exprstate::on_def_token(const token_type & tk,
parserstatemachine * /*p_psm*/)
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()));
this->illegal_input_error("exprstate::on_def_token", tk);
}
@ -387,7 +392,7 @@ namespace xo {
}
void
exprstate::on_expr(ref::brw<Expression> expr,
exprstate::on_expr(bp<Expression> expr,
parserstatemachine * /*p_psm*/)
{
constexpr bool c_debug_flag = true;
@ -400,7 +405,7 @@ namespace xo {
} /*on_expr*/
void
exprstate::on_expr_with_semicolon(ref::brw<Expression> expr,
exprstate::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * /*p_psm*/)
{
constexpr bool c_debug_flag = true;
@ -454,6 +459,16 @@ namespace xo {
xtag("token", tk),
xtag("state", *this)));
}
void
exprstate::unknown_variable_error(const char * self_name,
const token_type & tk) const
{
throw std::runtime_error
(tostr(self_name,
": unknown variable name",
xtag("var", tk.text())));
}
} /*namespace scm*/
} /*namespace xo*/

4
xo-reader/src/reader/lambda_xs.cpp
View file

@ -71,7 +71,7 @@ namespace xo {
}
void
lambda_xs::on_expr(ref::brw<Expression> expr,
lambda_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
if (lmxs_type_ == lambdastatetype::lm_2) {
@ -83,7 +83,7 @@ namespace xo {
}
void
lambda_xs::on_expr_with_semicolon(ref::brw<Expression> expr,
lambda_xs::on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm)
{
this->on_expr(expr, p_psm);

4
xo-reader/src/reader/let1_xs.cpp
View file

@ -54,13 +54,13 @@ namespace xo {
{}
void
let1_xs::on_expr(ref::brw<Expression> expr,
let1_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
ref::brw<DefineExpr> def_expr = DefineExpr::from(expr);
bp<DefineExpr> def_expr = DefineExpr::from(expr);
if (def_expr) {
/** nested_start: control returns via

2
xo-reader/src/reader/paren_xs.cpp
View file

@ -195,7 +195,7 @@ namespace xo {
}
void
paren_xs::on_expr(ref::brw<Expression> expr,
paren_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;

9
xo-reader/src/reader/parser.cpp
View file

@ -24,6 +24,15 @@ namespace xo {
namespace scm {
// ----- parser -----
parser::parser()
: xs_stack_{}, env_stack_{}
{
/* top-level environment. initially empty */
envframe toplevel_env;
this->env_stack_.push_envframe(toplevel_env);
}
bool
parser::has_incomplete_expr() const {
return !xs_stack_.empty();

9
xo-reader/src/reader/parserstatemachine.cpp
View file

@ -15,6 +15,11 @@ namespace xo {
return p_env_stack_->lookup(x);
}
void
parserstatemachine::upsert_var(bp<Variable> x) {
p_env_stack_->upsert(x);
}
std::unique_ptr<exprstate>
parserstatemachine::pop_exprstate() {
return p_stack_->pop_exprstate();
@ -49,7 +54,7 @@ namespace xo {
}
void
parserstatemachine::on_expr(ref::brw<Expression> x)
parserstatemachine::on_expr(bp<Expression> x)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));
@ -62,7 +67,7 @@ namespace xo {
}
void
parserstatemachine::on_expr_with_semicolon(ref::brw<Expression> x)
parserstatemachine::on_expr_with_semicolon(bp<Expression> x)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));

6
xo-reader/src/reader/progress_xs.cpp
View file

@ -118,7 +118,7 @@ namespace xo {
case optype::op_assign:
{
ref::brw<Variable> lhs = Variable::from(this->lhs_);
bp<Variable> lhs = Variable::from(this->lhs_);
if (!lhs) {
throw std::runtime_error
@ -158,7 +158,7 @@ namespace xo {
}
void
progress_xs::on_expr(ref::brw<Expression> expr,
progress_xs::on_expr(bp<Expression> expr,
parserstatemachine * /*p_psm*/)
{
/* note: previous token probably an operator,
@ -218,7 +218,7 @@ namespace xo {
progress_xs::on_semicolon_token(const token_type & /*tk*/,
parserstatemachine * p_psm)
{
/* note: implementation parllels .on_rightparen_token() */
/* note: implementation parallels .on_rightparen_token() */
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag));

4
xo-reader/src/reader/sequence_xs.cpp
View file

@ -32,7 +32,7 @@ namespace xo {
{}
void
sequence_xs::on_expr(ref::brw<Expression> expr,
sequence_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
{
constexpr bool c_debug_flag = true;
@ -67,7 +67,7 @@ namespace xo {
* helpful to have nested seequence_xs that propagates '}'
* instead of swallowing it.
*/
ref::brw<DefineExpr> def_expr = DefineExpr::from(expr);
bp<DefineExpr> def_expr = DefineExpr::from(expr);
if (def_expr) {
/** nested_start: control returns via