xo-reader2 xo-expression2: + DLambdaSsm [WIP]
This commit is contained in:
parent
5357407151
commit
fdf2cc8439
13 changed files with 880 additions and 1 deletions
409
src/reader2/DLambdaSsm.cpp
Normal file
409
src/reader2/DLambdaSsm.cpp
Normal file
|
|
@ -0,0 +1,409 @@
|
|||
/** @file lambda_xs.cpp
|
||||
*
|
||||
* @author Roland Conybeare, Jan 2026
|
||||
**/
|
||||
|
||||
#include "DLambdaSsm.hpp"
|
||||
#include "ssm/ISyntaxStateMachine_DLambdaSsm.hpp"
|
||||
#include "ParserStateMachine.hpp"
|
||||
#include "syntaxstatetype.hpp"
|
||||
#include <xo/printable2/Printable.hpp>
|
||||
#include <xo/facet/FacetRegistry.hpp>
|
||||
#include <xo/arena/DArena.hpp>
|
||||
|
||||
#ifdef NOT_YET
|
||||
#include "define_xs.hpp"
|
||||
#include "parserstatemachine.hpp"
|
||||
#include "exprstatestack.hpp"
|
||||
#include "expect_formal_arglist_xs.hpp"
|
||||
#include "expect_expr_xs.hpp"
|
||||
#include "expect_type_xs.hpp"
|
||||
#include "pretty_expression.hpp"
|
||||
#include "pretty_variable.hpp"
|
||||
#include "xo/expression/Lambda.hpp"
|
||||
#endif
|
||||
|
||||
namespace xo {
|
||||
using xo::print::APrintable;
|
||||
using xo::facet::FacetRegistry;
|
||||
using xo::reflect::typeseq;
|
||||
|
||||
namespace scm {
|
||||
const char *
|
||||
lambdastatetype_descr(lambdastatetype x) {
|
||||
switch(x) {
|
||||
case lambdastatetype::invalid: return "invalid";
|
||||
case lambdastatetype::lm_0: return "lm_0";
|
||||
case lambdastatetype::lm_1: return "lm_1";
|
||||
case lambdastatetype::lm_2: return "lm_2";
|
||||
case lambdastatetype::lm_3: return "lm_3";
|
||||
case lambdastatetype::lm_4: return "lm_4";
|
||||
case lambdastatetype::lm_5: return "lm_5";
|
||||
default: break;
|
||||
}
|
||||
|
||||
return "???lambdastatetype";
|
||||
}
|
||||
|
||||
// ----- lambda_xs - ----
|
||||
|
||||
DLambdaSsm::DLambdaSsm()
|
||||
{}
|
||||
|
||||
obj<ASyntaxStateMachine,DLambdaSsm>
|
||||
DLambdaSsm::make(DArena & parser_mm)
|
||||
{
|
||||
return obj<ASyntaxStateMachine,DLambdaSsm>(_make(parser_mm));
|
||||
}
|
||||
|
||||
DLambdaSsm *
|
||||
DLambdaSsm::_make(DArena & parser_mm)
|
||||
{
|
||||
void * mem = parser_mm.alloc(typeseq::id<DLambdaSsm>(),
|
||||
sizeof(DLambdaSsm));
|
||||
|
||||
return new (mem) DLambdaSsm();
|
||||
}
|
||||
|
||||
void
|
||||
DLambdaSsm::start(ParserStateMachine * p_psm)
|
||||
{
|
||||
p_psm->push_ssm(DLambdaSsm::make(p_psm->parser_alloc()));
|
||||
p_psm->on_token(Token::lambda_token());
|
||||
}
|
||||
|
||||
syntaxstatetype
|
||||
DLambdaSsm::ssm_type() const noexcept
|
||||
{
|
||||
return syntaxstatetype::lambdaexpr;
|
||||
}
|
||||
|
||||
std::string_view
|
||||
DLambdaSsm::get_expect_str() const noexcept
|
||||
{
|
||||
/*
|
||||
* lambda (x : f64) : f64 { ... } ;
|
||||
* ^ ^ ^ ^ ^ ^
|
||||
* | | | | | lm_5
|
||||
* | | | | lm_4:expect_expression
|
||||
* | | | lm_3
|
||||
* | | lm_2
|
||||
* | lm_1:
|
||||
* expect_expression
|
||||
*/
|
||||
switch (this->lmstate_) {
|
||||
case lambdastatetype::invalid:
|
||||
case lambdastatetype::n_lambdastatetype:
|
||||
assert(false); // impossible
|
||||
break;
|
||||
case lambdastatetype::lm_0:
|
||||
return "lambda";
|
||||
case lambdastatetype::lm_1:
|
||||
return "lambda-params";
|
||||
case lambdastatetype::lm_2:
|
||||
return "colon|lambda-body";
|
||||
case lambdastatetype::lm_3:
|
||||
return "type";
|
||||
case lambdastatetype::lm_4:
|
||||
return "lambda-body";
|
||||
case lambdastatetype::lm_5:
|
||||
return "semicolon";
|
||||
}
|
||||
|
||||
return "?expect";
|
||||
}
|
||||
|
||||
void
|
||||
DLambdaSsm::on_token(const Token & tk,
|
||||
ParserStateMachine * p_psm)
|
||||
{
|
||||
p_psm->illegal_input_on_token("DLambdaSsm::on_token",
|
||||
tk,
|
||||
this->get_expect_str());
|
||||
}
|
||||
|
||||
#ifdef NOT_YET
|
||||
void
|
||||
lambda_xs::on_lambda_token(const token_type & tk,
|
||||
parserstatemachine * p_psm)
|
||||
{
|
||||
if (lmxs_type_ == lambdastatetype::lm_0) {
|
||||
this->lmxs_type_ = lambdastatetype::lm_1;
|
||||
expect_formal_arglist_xs::start(p_psm);
|
||||
} else {
|
||||
exprstate::on_lambda_token(tk, p_psm);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
lambda_xs::on_formal_arglist(const std::vector<rp<Variable>> & argl,
|
||||
parserstatemachine * p_psm)
|
||||
{
|
||||
if (lmxs_type_ == lambdastatetype::lm_1) {
|
||||
this->lmxs_type_ = lambdastatetype::lm_2;
|
||||
this->parent_env_ = p_psm->top_envframe().promote();
|
||||
this->local_env_ = LocalSymtab::make(argl, parent_env_);
|
||||
|
||||
p_psm->push_envframe(local_env_);
|
||||
|
||||
//expect_expr_xs::start(p_psm);
|
||||
} else {
|
||||
exprstate::on_formal_arglist(argl, p_psm);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
lambda_xs::on_expr_with_semicolon(bp<Expression> expr,
|
||||
parserstatemachine * p_psm)
|
||||
{
|
||||
this->on_expr(expr, p_psm);
|
||||
this->on_semicolon_token(token_type::semicolon(), p_psm);
|
||||
}
|
||||
|
||||
void
|
||||
lambda_xs::on_colon_token(const token_type & tk,
|
||||
parserstatemachine * p_psm)
|
||||
{
|
||||
constexpr const char * c_self_name = "lambda_xs::on_colon_token";
|
||||
|
||||
if (lmxs_type_ == lambdastatetype::lm_2) {
|
||||
this->lmxs_type_ = lambdastatetype::lm_3;
|
||||
expect_type_xs::start(p_psm);
|
||||
/* control reenters via .on_typedescr() */
|
||||
} else {
|
||||
this->illegal_input_on_token(c_self_name, tk, this->get_expect_str(), p_psm);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
lambda_xs::on_leftbrace_token(const token_type & tk,
|
||||
parserstatemachine * p_psm)
|
||||
{
|
||||
constexpr const char * c_self_name = "lambda_xs::on_leftbrace_token";
|
||||
|
||||
if (lmxs_type_ == lambdastatetype::lm_2)
|
||||
this->lmxs_type_ = lambdastatetype::lm_4;
|
||||
|
||||
if (lmxs_type_ == lambdastatetype::lm_4) {
|
||||
expect_expr_xs::start(p_psm);
|
||||
/* want { to start expr sequence, that finishes on matching } */
|
||||
p_psm->on_leftbrace_token(token_type::leftbrace());
|
||||
} else {
|
||||
this->illegal_input_on_token(c_self_name, tk, this->get_expect_str(), p_psm);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
DLambdaSsm::on_parsed_typedescr(TypeDescr td,
|
||||
ParserStateMachine * p_psm)
|
||||
{
|
||||
p_psm->illegal_input_on_typedescr("DLambdaSsm::on_parsed_typedescr",
|
||||
td,
|
||||
this->get_expect_str());
|
||||
}
|
||||
|
||||
#ifdef NOT_YET
|
||||
void
|
||||
lambda_xs::on_typedescr(TypeDescr td,
|
||||
parserstatemachine * p_psm)
|
||||
{
|
||||
constexpr const char * c_self_name = "lambda_xs::on_typedescr";
|
||||
scope log(XO_DEBUG(p_psm->debug_flag()));
|
||||
|
||||
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)
|
||||
)
|
||||
{
|
||||
const define_xs * def_xs = dynamic_cast<const define_xs*>(&(p_psm->lookup_exprstate(2)));
|
||||
|
||||
assert(def_xs);
|
||||
|
||||
bp<Variable> def_var = def_xs->lhs_variable();
|
||||
|
||||
if (def_var->valuetype() == nullptr) {
|
||||
log && log("assign discovered lambda type T to enclosing define",
|
||||
xtag("lhs", def_var.get()),
|
||||
xtag("T", print::unq(this->lambda_td_->canonical_name())));
|
||||
|
||||
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 {
|
||||
this->illegal_input_on_type(c_self_name, td, this->get_expect_str(), p_psm);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
DLambdaSsm::on_parsed_symbol(std::string_view sym,
|
||||
ParserStateMachine * p_psm)
|
||||
{
|
||||
p_psm->illegal_input_on_symbol("DLambdaSsm::on_parsed_sybol",
|
||||
sym,
|
||||
this->get_expect_str());
|
||||
}
|
||||
|
||||
void
|
||||
DLambdaSsm::on_parsed_expression_with_semicolon(obj<AExpression> expr,
|
||||
ParserStateMachine * p_psm)
|
||||
{
|
||||
p_psm->illegal_parsed_expression
|
||||
("DLambdaSsm::on_parsed_expression_with_semicolon",
|
||||
expr,
|
||||
this->get_expect_str());
|
||||
}
|
||||
|
||||
void
|
||||
DLambdaSsm::on_parsed_expression(obj<AExpression> expr,
|
||||
ParserStateMachine * p_psm)
|
||||
{
|
||||
p_psm->illegal_parsed_expression("DLambdaSsm::on_parsed_expression",
|
||||
expr,
|
||||
this->get_expect_str());
|
||||
}
|
||||
|
||||
#ifdef NOT_YET
|
||||
void
|
||||
lambda_xs::on_expr(bp<Expression> expr,
|
||||
parserstatemachine * p_psm)
|
||||
{
|
||||
constexpr const char * c_self_name = "lambda_xs::on_expr";
|
||||
|
||||
if (lmxs_type_ == lambdastatetype::lm_4) {
|
||||
this->lmxs_type_ = lambdastatetype::lm_5;
|
||||
this->body_ = expr.promote();
|
||||
} else {
|
||||
this->illegal_input_on_expr(c_self_name, expr, this->get_expect_str(), p_psm);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
lambda_xs::on_semicolon_token(const token_type & tk,
|
||||
parserstatemachine * p_psm)
|
||||
{
|
||||
if (lmxs_type_ == lambdastatetype::lm_5) {
|
||||
/* done! */
|
||||
|
||||
std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
|
||||
|
||||
std::string name = Variable::gensym("lambda");
|
||||
|
||||
/* top env frame recorded arguments to this lambda */
|
||||
p_psm->pop_envframe();
|
||||
|
||||
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);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
exprstate::on_semicolon_token(tk, p_psm);
|
||||
}
|
||||
|
||||
void
|
||||
lambda_xs::on_f64_token(const token_type & tk,
|
||||
parserstatemachine * p_psm)
|
||||
{
|
||||
constexpr const char * c_self_name = "lambda_xs::on_f64_token";
|
||||
|
||||
/* f64 literal can begin lambda body, otherwise illegal.
|
||||
* for example:
|
||||
* def foo = lambda (x: bool) 3.14;
|
||||
*/
|
||||
if (lmxs_type_ == lambdastatetype::lm_2) {
|
||||
/* omitting return type.
|
||||
* omitting left brace.
|
||||
*/
|
||||
this->lmxs_type_ = lambdastatetype::lm_4;
|
||||
|
||||
expect_expr_xs::start(p_psm);
|
||||
p_psm->on_f64_token(tk);
|
||||
} else {
|
||||
this->illegal_input_on_token(c_self_name, tk, this->get_expect_str(), p_psm);
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: on_i64_token, on_bool token
|
||||
|
||||
void
|
||||
lambda_xs::print(std::ostream & os) const {
|
||||
os << "<lambda_xs"
|
||||
<< xtag("lmxs_type", lmxs_type_)
|
||||
<< ">";
|
||||
}
|
||||
#endif
|
||||
|
||||
bool
|
||||
DLambdaSsm::pretty(const ppindentinfo & ppii) const
|
||||
{
|
||||
obj<APrintable> body
|
||||
= FacetRegistry::instance().variant<APrintable,
|
||||
AExpression>(body_);
|
||||
|
||||
if (body) {
|
||||
return ppii.pps()->pretty_struct
|
||||
(ppii,
|
||||
"DLambdaSsm",
|
||||
refrtag("lmstate", lmstate_),
|
||||
refrtag("body", body));
|
||||
} else {
|
||||
return ppii.pps()->pretty_struct
|
||||
(ppii,
|
||||
"DLambdaSsm",
|
||||
refrtag("lmstate", lmstate_));
|
||||
}
|
||||
}
|
||||
|
||||
} /*namespace scm*/
|
||||
} /*namespace xo*/
|
||||
|
||||
/* end DLambdaSsm.cpp */
|
||||
Loading…
Add table
Add a link
Reference in a new issue