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

xo-reader2 xo-expression2: + DLambdaSsm [WIP]

Browse source
This commit is contained in:
Roland Conybeare 2026-01-28 10:57:55 -05:00
commit c9011c1296
17 changed files with 896 additions and 11 deletions
Download patch file Download diff file Expand all files Collapse all files

14
xo-expression2/include/xo/expression2/DConstant.hpp
View file

@ -44,18 +44,26 @@ namespace xo {
bool is_resolved() const noexcept { return typeref_.is_resolved(); }
exprtype extype() const noexcept { return exprtype::constant; }
obj<AGCObject> value() const noexcept { return value_; }
TypeDescr value_td() const noexcept { return typeref_.td(); }
TaggedPtr value_tp() const noexcept { return TaggedPtr(typeref_.td(), value_.data()); }
/** @defgroup scm-constant-expression-facet **/
///@{
exprtype extype() const noexcept { return exprtype::constant; }
TypeRef typeref() const noexcept { return typeref_; }
TypeDescr valuetype() const noexcept { return typeref_.td(); }
obj<AGCObject> value() const noexcept { return value_; }
void assign_valuetype(TypeDescr td) noexcept { typeref_.resolve(td); }
///@}
/** @defgroup scm-constant-printable-facet **/
///@{
bool pretty(const ppindentinfo & ppii) const;
///@}
private:
static TypeDescr _lookup_td(typeseq tseq);

4
xo-expression2/include/xo/expression2/DLambdaExpr.hpp
View file

@ -34,14 +34,12 @@ namespace xo {
DLocalSymtab * local_symtab,
obj<AExpression> body);
#ifdef NOT_YET
/** create instance using memory from @p mm **/
static obj<AExpression,DLambdaExpr> make(obj<AAllocator> mm,
TypeRef typeref,
const DUniqueString * name,
DLocalSymtab * local_symtab,
obj<AExpression> body);
#endif
/** create instance, using memory from @p mm **/
static DLambdaExpr * _make(obj<AAllocator> mm,
@ -53,6 +51,8 @@ namespace xo {
/** @defgroup scm-lambdaexpr-methods **/
///@{
DLocalSymtab * local_symtab() const noexcept { return local_symtab_; }
// get_free_variables()
// visit_preorder()
// visit_layer()

6
xo-expression2/src/expression2/DLambdaExpr.cpp
View file

@ -4,7 +4,7 @@
**/
#include "DLambdaExpr.hpp"
// #include "detail/IExpression_DLambdaExpr.hpp"
#include "detail/IExpression_DLambdaExpr.hpp"
#include <xo/alloc2/Allocator.hpp>
#include <xo/printable2/Printable.hpp>
#include <xo/facet/FacetRegistry.hpp>
@ -53,7 +53,6 @@ namespace xo {
{
}
#ifdef NOT_YET
obj<AExpression,DLambdaExpr>
DLambdaExpr::make(obj<AAllocator> mm,
TypeRef typeref,
@ -62,9 +61,8 @@ namespace xo {
obj<AExpression> body)
{
return obj<AExpression,DLambdaExpr>(_make(mm, typeref,
name, local_symtab, body);
name, local_symtab, body));
}
#endif
DLambdaExpr *
DLambdaExpr::_make(obj<AAllocator> mm,

26
xo-reader2/CMakeLists.txt
View file

@ -86,6 +86,32 @@ xo_add_genfacetimpl(
# ----------------------------------------------------------------
# note: manual target; generated code committed to git
xo_add_genfacetimpl(
TARGET xo-reader2-facetimpl-syntaxstatemachine-lambdassm
FACET_PKG xo_reader2
FACET SyntaxStateMachine
REPR LambdaSsm
INPUT idl/ISyntaxStateMachine_DLambdaSsm.json5
OUTPUT_HPP_DIR include/xo/reader2
OUTPUT_IMPL_SUBDIR ssm
OUTPUT_CPP_DIR src/reader2
)
# note: manual target; generated code committed to git
xo_add_genfacetimpl(
TARGET xo-reader2-facetimpl-printable-lambdassm
FACET_PKG xo_printable2
FACET Printable
REPR LambdaSsm
INPUT idl/IPrintable_DLambdaSsm.json5
OUTPUT_HPP_DIR include/xo/reader2
OUTPUT_IMPL_SUBDIR ssm
OUTPUT_CPP_DIR src/reader2
)
# ----------------------------------------------------------------
# note: manual target; generated code committed to git
xo_add_genfacetimpl(
TARGET xo-reader2-facetimpl-syntaxstatemachine-ifelsessm

13
xo-reader2/idl/IPrintable_DLambdaSsm.json5 Normal file
View file

@ -0,0 +1,13 @@
{
mode: "implementation",
includes: [ "<xo/printable2/Printable.hpp>",
"<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
local_types: [],
namespace1: "xo",
namespace2: "scm",
facet_idl: "idl/Printable.json5",
brief: "provide APrintable interface for DLambdaSsm",
using_doxygen: true,
repr: "DLambdaSsm",
doc: [ "implement APrintable for DLambdaSsm" ],
}

13
xo-reader2/idl/ISyntaxStateMachine_DLambdaSsm.json5 Normal file
View file

@ -0,0 +1,13 @@
{
mode: "implementation",
includes: [ "\"SyntaxStateMachine.hpp\"",
"\"ssm/ISyntaxStateMachine_Xfer.hpp\"" ],
local_types: [ ],
namespace1: "xo",
namespace2: "scm",
facet_idl: "idl/SyntaxStateMachine.json5",
brief: "provide ASyntaxStateMachine interface for DLambdaSsm",
using_doxygen: true,
repr: "DLambdaSsm",
doc: [ "implement ASyntaxStateMachine for DLambdaSsm" ],
}

2
xo-reader2/include/xo/reader2/DDefineSsm.hpp
View file

@ -102,7 +102,7 @@ namespace xo {
/** @defgroup scm-definessm-access-methods **/
///@{
/** identify define-expression state **/
/** identify this nested state machine **/
defexprstatetype defstate() const noexcept { return defstate_; }
///@}

186
xo-reader2/include/xo/reader2/DLambdaSsm.hpp Normal file
View file

@ -0,0 +1,186 @@
/** @file DLambdaSsm.hpp
*
* Author: Roland Conybeare
**/
#pragma once
#include "SyntaxStateMachine.hpp"
#include <xo/expression2/DLambdaExpr.hpp>
#include <xo/expression2/SymbolTable.hpp>
//#include <xo/expression2/DLocalSymtab.hpp>
namespace xo {
namespace scm {
class ParserStateMachine;
/**
* @text
*
* lambda ( name(1) : type(1), ..., ) : type body-expr ;
* ^ ^ ^ ^ ^ ^
* | | | | lm_4 lm_5
* | | | lm_3
* lm_0 lm_1 lm_2
*
* lm_0 --on_lambda_token()--> lm_1
* lm_1 --on_formal_arglist()--> lm_2
* lm_2 --on_expr()--> lm_3
* lm_5 --on_semicolon_token()--> (done)
*
* @endtext
**/
enum class lambdastatetype {
invalid = -1,
lm_0,
lm_1,
lm_2,
lm_3,
lm_4,
lm_5,
n_lambdastatetype
};
extern const char *
lambdastatetype_descr(lambdastatetype x);
inline std::ostream &
operator<< (std::ostream & os, lambdastatetype x) {
os << lambdastatetype_descr(x);
return os;
}
/** @class DLambdaSsm
* @brief parsing state-machine for a lambda-expression
**/
class DLambdaSsm {
public:
//using DSymbolTable = xo::scm::DSymbolTable;
using DLocalSymtab = xo::scm::DLocalSymtab;
using DArena = xo::mm::DArena;
using TypeDescr = xo::reflect::TypeDescr;
using ppindentinfo = xo::print::ppindentinfo;
public:
/** @defgroup scm-lambdassm-ctors **/
///@{
DLambdaSsm();
/** create instance using memory from @p parser_mm **/
static obj<ASyntaxStateMachine,DLambdaSsm> make(DArena & parser_mm);
/** create instance using memory from @p parser_mm **/
static DLambdaSsm * _make(DArena & parser_mm);
///@}
/** @defgroup scm-lambdassm-methods **/
///@{
static void start(ParserStateMachine * p_psm);
///@}
/** @defgroup scm-lambdassm-syntaxstatemachine-facet **/
///@{
/** identify this nested state machine **/
syntaxstatetype ssm_type() const noexcept;
/** text describing expected/allowed input to this ssm in current state.
* Intended to drive error messages
**/
std::string_view get_expect_str() const noexcept;
/** update this ssm for incoming token @p tk **/
void on_token(const Token & tk,
ParserStateMachine * p_psm);
/** update this ssm when nested parser
* emits expression @p expr
**/
void on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm);
/** update this ssm when nested parser
* emits expression @p expr
**/
void on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm);
/** update this ssm when nested parser
* emits @p td.
**/
void on_parsed_symbol(std::string_view sym,
ParserStateMachine * p_psm);
/** update this ssm when nested parser
* emits @p td.
**/
void on_parsed_typedescr(TypeDescr td,
ParserStateMachine * p_psm);
#ifdef NOT_YET
virtual const char * get_expect_str() const override;
virtual void on_lambda_token(const token_type & tk,
parserstatemachine * p_psm) override;
virtual void on_typedescr(TypeDescr td,
parserstatemachine * p_psm) override;
virtual void on_formal_arglist(const std::vector<rp<Variable>> & argl,
parserstatemachine * p_psm) override;
virtual void on_expr(bp<Expression> expr,
parserstatemachine * p_psm) override;
virtual void on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm) override;
virtual void on_leftbrace_token(const token_type & tk,
parserstatemachine * p_psm) override;
virtual void on_colon_token(const token_type & tk,
parserstatemachine * p_psm) override;
virtual void on_semicolon_token(const token_type & tk,
parserstatemachine * p_psm) override;
virtual void on_f64_token(const token_type & tk,
parserstatemachine * p_psm) final override;
virtual void print(std::ostream & os) const override;
virtual bool pretty_print(const print::ppindentinfo & ppii) const override;
#endif
///@}
/** @defgroup scm-lambdassm-printable-facet **/
///@{
/** pretty-printing support **/
bool pretty(const ppindentinfo & ppii) const;
///@}
private:
/** parsing state-machine state **/
lambdastatetype lmstate_ = lambdastatetype::lm_0;
#ifdef NOT_YET
/** lambda environment (for formal parameters) **/
DLocalSymtab * local_symtab_ = nullptr;
/** explicit return type (if supplied) **/
TypeDescr explicit_return_td_ = nullptr;
/** lambda signature (when known) **/
TypeDescr lambda_td_ = nullptr;
#endif
/** body expression **/
obj<AExpression> body_;
/** parent environment **/
obj<ASymbolTable> parent_symtab_;
};
} /*namespace scm*/
} /*namespace xo*/
/* end DLambdaSsm.hpp */

62
xo-reader2/include/xo/reader2/ssm/IPrintable_DLambdaSsm.hpp Normal file
View file

@ -0,0 +1,62 @@
/** @file IPrintable_DLambdaSsm.hpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [/Users/roland/proj/xo-umbrella2/xo-facet/codegen/genfacet]
* arguments:
* --input [idl/IPrintable_DLambdaSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_repr.hpp.j2]
* 3. idl for facet methods
* [idl/IPrintable_DLambdaSsm.json5]
**/
#pragma once
#include "Printable.hpp"
#include <xo/printable2/Printable.hpp>
#include <xo/printable2/detail/IPrintable_Xfer.hpp>
#include "DLambdaSsm.hpp"
namespace xo { namespace scm { class IPrintable_DLambdaSsm; } }
namespace xo {
namespace facet {
template <>
struct FacetImplementation<xo::print::APrintable,
xo::scm::DLambdaSsm>
{
using ImplType = xo::print::IPrintable_Xfer
<xo::scm::DLambdaSsm,
xo::scm::IPrintable_DLambdaSsm>;
};
}
}
namespace xo {
namespace scm {
/** @class IPrintable_DLambdaSsm
**/
class IPrintable_DLambdaSsm {
public:
/** @defgroup scm-printable-dlambdassm-type-traits **/
///@{
using ppindentinfo = xo::print::APrintable::ppindentinfo;
using Copaque = xo::print::APrintable::Copaque;
using Opaque = xo::print::APrintable::Opaque;
///@}
/** @defgroup scm-printable-dlambdassm-methods **/
///@{
// const methods
/** Pretty-printing support for this object.
See [xo-indentlog/xo/indentlog/pretty.hpp] **/
static bool pretty(const DLambdaSsm & self, const ppindentinfo & ppii);
// non-const methods
///@}
};
} /*namespace scm*/
} /*namespace xo*/
/* end */

73
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DLambdaSsm.hpp Normal file
View file

@ -0,0 +1,73 @@
/** @file ISyntaxStateMachine_DLambdaSsm.hpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [/Users/roland/proj/xo-umbrella2/xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DLambdaSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_repr.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DLambdaSsm.json5]
**/
#pragma once
#include "SyntaxStateMachine.hpp"
#include "SyntaxStateMachine.hpp"
#include "ssm/ISyntaxStateMachine_Xfer.hpp"
#include "DLambdaSsm.hpp"
namespace xo { namespace scm { class ISyntaxStateMachine_DLambdaSsm; } }
namespace xo {
namespace facet {
template <>
struct FacetImplementation<xo::scm::ASyntaxStateMachine,
xo::scm::DLambdaSsm>
{
using ImplType = xo::scm::ISyntaxStateMachine_Xfer
<xo::scm::DLambdaSsm,
xo::scm::ISyntaxStateMachine_DLambdaSsm>;
};
}
}
namespace xo {
namespace scm {
/** @class ISyntaxStateMachine_DLambdaSsm
**/
class ISyntaxStateMachine_DLambdaSsm {
public:
/** @defgroup scm-syntaxstatemachine-dlambdassm-type-traits **/
///@{
using TypeDescr = xo::scm::ASyntaxStateMachine::TypeDescr;
using Copaque = xo::scm::ASyntaxStateMachine::Copaque;
using Opaque = xo::scm::ASyntaxStateMachine::Opaque;
///@}
/** @defgroup scm-syntaxstatemachine-dlambdassm-methods **/
///@{
// const methods
/** identify a type of syntax state machine **/
static syntaxstatetype ssm_type(const DLambdaSsm & self) noexcept;
/** text describing expected/allowed input to this ssm in current state **/
static std::string_view get_expect_str(const DLambdaSsm & self) noexcept;
// non-const methods
/** operate state machine for incoming token @p tk **/
static void on_token(DLambdaSsm & self, const Token & tk, ParserStateMachine * p_psm);
/** update stat machine for incoming parsed symbol @p sym **/
static void on_parsed_symbol(DLambdaSsm & self, std::string_view sym, ParserStateMachine * p_psm);
/** operate state machine for incoming type description @p td **/
static void on_parsed_typedescr(DLambdaSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/
static void on_parsed_expression(DLambdaSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr followed by semicolon **/
static void on_parsed_expression_with_semicolon(DLambdaSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
///@}
};
} /*namespace scm*/
} /*namespace xo*/
/* end */

3
xo-reader2/include/xo/reader2/syntaxstatetype.hpp
View file

@ -33,6 +33,9 @@ namespace xo {
/** handle define-expression. See @ref DDefineSsm **/
defexpr,
/** handle lambda-expression. See @ref DLambdaSsm **/
lambdaexpr,
/** handle ifelse-expression. See @ref DIfElseSsm **/
ifelseexpr,

4
xo-reader2/src/reader2/CMakeLists.txt
View file

@ -29,6 +29,10 @@ set(SELF_SRCS
ISyntaxStateMachine_DIfElseSsm.cpp
IPrintable_DIfElseSsm.cpp
DLambdaSsm.cpp
ISyntaxStateMachine_DLambdaSsm.cpp
IPrintable_DLambdaSsm.cpp
DExpectSymbolSsm.cpp
ISyntaxStateMachine_DExpectSymbolSsm.cpp
IPrintable_DExpectSymbolSsm.cpp

409
xo-reader2/src/reader2/DLambdaSsm.cpp Normal file
View 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 */

28
xo-reader2/src/reader2/IPrintable_DLambdaSsm.cpp Normal file
View file

@ -0,0 +1,28 @@
/** @file IPrintable_DLambdaSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [/Users/roland/proj/xo-umbrella2/xo-facet/codegen/genfacet]
* arguments:
* --input [idl/IPrintable_DLambdaSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/IPrintable_DLambdaSsm.json5]
**/
#include "ssm/IPrintable_DLambdaSsm.hpp"
namespace xo {
namespace scm {
auto
IPrintable_DLambdaSsm::pretty(const DLambdaSsm & self, const ppindentinfo & ppii) -> bool
{
return self.pretty(ppii);
}
} /*namespace scm*/
} /*namespace xo*/
/* end IPrintable_DLambdaSsm.cpp */

60
xo-reader2/src/reader2/ISyntaxStateMachine_DLambdaSsm.cpp Normal file
View file

@ -0,0 +1,60 @@
/** @file ISyntaxStateMachine_DLambdaSsm.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [/Users/roland/proj/xo-umbrella2/xo-facet/codegen/genfacet]
* arguments:
* --input [idl/ISyntaxStateMachine_DLambdaSsm.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/ISyntaxStateMachine_DLambdaSsm.json5]
**/
#include "ssm/ISyntaxStateMachine_DLambdaSsm.hpp"
namespace xo {
namespace scm {
auto
ISyntaxStateMachine_DLambdaSsm::ssm_type(const DLambdaSsm & self) noexcept -> syntaxstatetype
{
return self.ssm_type();
}
auto
ISyntaxStateMachine_DLambdaSsm::get_expect_str(const DLambdaSsm & self) noexcept -> std::string_view
{
return self.get_expect_str();
}
auto
ISyntaxStateMachine_DLambdaSsm::on_token(DLambdaSsm & self, const Token & tk, ParserStateMachine * p_psm) -> void
{
self.on_token(tk, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::on_parsed_symbol(DLambdaSsm & self, std::string_view sym, ParserStateMachine * p_psm) -> void
{
self.on_parsed_symbol(sym, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::on_parsed_typedescr(DLambdaSsm & self, TypeDescr td, ParserStateMachine * p_psm) -> void
{
self.on_parsed_typedescr(td, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::on_parsed_expression(DLambdaSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DLambdaSsm::on_parsed_expression_with_semicolon(DLambdaSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_semicolon(expr, p_psm);
}
} /*namespace scm*/
} /*namespace xo*/
/* end ISyntaxStateMachine_DLambdaSsm.cpp */

2
xo-reader2/src/reader2/syntaxstatetype.cpp
View file

@ -23,6 +23,8 @@ namespace xo {
return "expect-rhs-expression";
case syntaxstatetype::defexpr:
return "defexpr";
case syntaxstatetype::lambdaexpr:
return "lambdaexpr";
case syntaxstatetype::ifelseexpr:
return "ifelseexpr";
case syntaxstatetype::progress:

2
xo-tokenizer2/include/xo/tokenizer2/Token.hpp
View file

@ -134,7 +134,7 @@ namespace xo {
/** token representing keyword @c def **/
static Token def_token() { return Token(tokentype::tk_def); }
/** token representing keyword @c lambda **/
static Token lambda() { return Token(tokentype::tk_lambda); }
static Token lambda_token() { return Token(tokentype::tk_lambda); }
/** token representing keyword @c if **/
static Token if_token() { return Token(tokentype::tk_if); }
/** token representing keyword @c then **/