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

xo-expression xo-reader: parser improvements, prep type inf/unify

Browse source
This commit is contained in:
Roland Conybeare 2025-07-28 09:12:41 -04:00
commit f3fde735da
18 changed files with 274 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -261,6 +261,14 @@ namespace xo {
<< ">";
}
bool
expect_expr_xs::pretty_print(const xo::print::ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct(ppii, "expect_expr_xs",
refrtag("allow_defs", allow_defs_),
refrtag("cxl_on_rightbrace", cxl_on_rightbrace_));
}
} /*namespace scm*/
} /*namespace xo*/

38
xo-reader/src/reader/if_else_xs.cpp
View file

@ -164,6 +164,30 @@ namespace xo {
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)
@ -180,24 +204,18 @@ namespace xo {
case ifexprstatetype::n_ifexprstatetype:
// unreachable
assert(false);
return;
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);
return;
break;
case ifexprstatetype::if_4:
case ifexprstatetype::if_6: {
rp<IfExprAccess> if_expr = this->if_expr_;
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
TypeDescr td = nullptr;
if_expr->assign_valuetype(td);
p_psm->top_exprstate().on_expr(if_expr, p_psm);
return;
this->finish_and_continue(p_psm);
break;
}
}
}

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

@ -1,6 +1,7 @@
/* @file lambda_xs.cpp */
#include "lambda_xs.hpp"
#include "define_xs.hpp"
#include "parserstatemachine.hpp"
#include "exprstatestack.hpp"
#include "expect_formal_arglist_xs.hpp"
@ -156,9 +157,55 @@ namespace xo {
{
constexpr const char * c_self_name = "lambda_xs::on_typedescr";
assert(td);
if (lmxs_type_ == lambdastatetype::lm_3) {
this->lmxs_type_ = lambdastatetype::lm_4;
this->explicit_return_td_ = td;
this->lambda_td_ = Lambda::assemble_lambda_td(local_env_->argv(),
explicit_return_td_);
/* 1. at this point we know function signature (@ref lambda_td_)
* 2. if this lambda appears on the rhs of a define,
* propagate function signature to the define.
* 3. this makes recursive function definitions like this work
* without relying on type inference:
* def fact = lambda (n : i64) : i64 {
* if (n == 0) then
* 1
* else
* n * fact(n - 1)
* }
* 4. while parsing the body of the lambda, we want environment
* to already associate the lambda's signature with variable 'fact',
* so that when parser encounters 'fact(n - 1)' the expression has
* known valuetype.
*/
if ((p_psm->exprstate_stack_size() >= 3)
&& (p_psm->lookup_exprstate(1).exs_type() == exprstatetype::expect_rhs_expression)
&& (p_psm->lookup_exprstate(2).exs_type() == exprstatetype::defexpr)
&& (p_psm->env_stack_size() >= 2)
)
{
bp<LocalEnv> def_env = p_psm->lookup_envframe(1);
assert(def_env->n_arg() == 1);
bp<Variable> def_var = def_env->lookup_arg(0).get();
if (def_var->valuetype() == nullptr) {
def_var->assign_valuetype(lambda_td_);
} else {
/* don't need to unify here. if def already hasa a type,
* that's because it was explicitly specified.
* will discover any conflict after reporting parsed lambda
* to define_xs
*/
}
}
expect_expr_xs::start(p_psm);
/* control reenters via .on_expr() or .on_expr_with_semicolon() */
} else {
@ -194,7 +241,16 @@ namespace xo {
/* top env frame recorded arguments to this lambda */
p_psm->pop_envframe();
rp<Lambda> lm = Lambda::make_from_env(name, local_env_, explicit_return_td_, body_);
rp<Lambda> lm;
/* TODO: unify explicit_return_td_ with body_ */
if (lambda_td_) {
lm = Lambda::make(name, lambda_td_, local_env_, body_);
} else {
lm = Lambda::make_from_env(name, local_env_,
explicit_return_td_, body_);
}
p_psm->top_exprstate().on_expr(lm, p_psm);
p_psm->top_exprstate().on_semicolon_token(tk, p_psm);

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

@ -52,8 +52,7 @@ namespace xo {
const parser_result &
parser::include_token(const token_type & tk)
{
constexpr bool c_debug_flag = true;
scope log(XO_DEBUG(c_debug_flag), xtag("tk", tk));
scope log(XO_DEBUG(psm_.debug_flag()), xtag("tk", tk));
if (psm_.xs_stack_.empty()) {
throw std::runtime_error(tostr("parser::include_token",

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

@ -35,6 +35,11 @@ namespace xo {
return xs_stack_.top_exprstate();
}
const exprstate &
parserstatemachine::lookup_exprstate(size_t i) const {
return *xs_stack_[i];
}
void
parserstatemachine::push_exprstate(std::unique_ptr<exprstate> x) {
xs_stack_.push_exprstate(std::move(x));
@ -45,6 +50,11 @@ namespace xo {
return env_stack_.top_envframe();
}
bp<LocalEnv>
parserstatemachine::lookup_envframe(std::size_t i) const {
return env_stack_[i];
}
void
parserstatemachine::push_envframe(const rp<LocalEnv> & x) {
constexpr bool c_debug_flag = true;