From 1628d8f44cea04497e351fff4e36fe5391ba6475 Mon Sep 17 00:00:00 2001 From: Roland Conybeare Date: Sat, 17 Aug 2024 13:26:57 -0400 Subject: [PATCH] xo-reader: feat: mvp lambda parsing [untested] --- .../xo/reader/expect_formal_arglist_xs.hpp | 47 ++++++++--- include/xo/reader/expect_formal_xs.hpp | 7 +- src/reader/expect_formal_arglist_xs.cpp | 78 ++++++++++++++++++- src/reader/expect_formal_xs.cpp | 12 ++- src/reader/lambda_xs.cpp | 19 ++--- 5 files changed, 135 insertions(+), 28 deletions(-) diff --git a/include/xo/reader/expect_formal_arglist_xs.hpp b/include/xo/reader/expect_formal_arglist_xs.hpp index 88b0adc1..501d945f 100644 --- a/include/xo/reader/expect_formal_arglist_xs.hpp +++ b/include/xo/reader/expect_formal_arglist_xs.hpp @@ -11,34 +11,63 @@ namespace xo { namespace scm { + /** + * ( name(1) : type(1) , ..., ) + * ^ ^ ^ ^ ^ + * | | | | | + * | | | | argl_1b + * | argl_1a | argla + * argl_0 argl_1b + * + * argl_0 --on_leftparen_token()--> argl_1a + * argl_1a --on_formal()--> argl_1b + * argl_1b -+-on_comma_token()--> argl_1a + * \-on_rightparen_token()--> (done) + **/ enum class formalarglstatetype { invalid = -1, argl_0, - argl_1, + argl_1a, + argl_1b, n_formalarglstatetype, }; + extern const char * + formalarglstatetype_descr(formalarglstatetype x); + + inline std::ostream & + operator<< (std::ostream & os, formalarglstatetype x) { + os << formalarglstatetype_descr(x); + return os; + } + /** @class expect_formal_arglist * @brief parser state-machine for a formal parameter list - * - * ( name(1) : type(1), ..., ) - * ^ - * | - * argl_0 **/ class expect_formal_arglist_xs : public exprstate { + public: + using Variable = xo::ast::Variable; + public: expect_formal_arglist_xs(); static std::unique_ptr make(); - const std::vector & argl() const { return argl_; } - virtual void on_leftparen_token(const token_type & tk, exprstatestack * p_stack, rp * p_emit_expr) override; + virtual void on_formal(const rp & formal, + exprstatestack * p_stack, + rp * p_emit_expr) override; + virtual void on_comma_token(const token_type & tk, + exprstatestack * p_stack, + rp * p_emit_expr) override; + virtual void on_rightparen_token(const token_type & tk, + exprstatestack * p_stack, + rp * p_emit_expr) override; + virtual void print(std::ostream & os) const override; private: /** parsing state-machine state **/ @@ -46,7 +75,7 @@ namespace xo { /** populate with (parmaeter-name, parameter-type) list * as they're encountered **/ - std::vector argl_; + std::vector> argl_; }; } /*namespace scm*/ } /*namespace xo*/ diff --git a/include/xo/reader/expect_formal_xs.hpp b/include/xo/reader/expect_formal_xs.hpp index 557ffa61..b4c046b9 100644 --- a/include/xo/reader/expect_formal_xs.hpp +++ b/include/xo/reader/expect_formal_xs.hpp @@ -17,6 +17,9 @@ namespace xo { * | formal_1 * formal_0 * + * formal_0 --on_symbol()--> formal_1 + * formal_1 --on_colon_token()--> formal_2 + * formal_2 --on_typedescr()--> (done) **/ enum class formalstatetype { invalid = -1, @@ -44,6 +47,8 @@ namespace xo { public: expect_formal_xs() = default; + static std::unique_ptr make(); + virtual void on_symbol(const std::string & symbol_name, exprstatestack * p_stack, rp * p_emit_expr) override; @@ -68,7 +73,7 @@ namespace xo { private: /** parsing state-machine state **/ - formalstatetype formalxs_type_; + formalstatetype formalxs_type_ = formalstatetype::formal_0; /** populate with {parameter-name, parameter-type} * as they're encountered **/ diff --git a/src/reader/expect_formal_arglist_xs.cpp b/src/reader/expect_formal_arglist_xs.cpp index c540dbd3..473cfb0c 100644 --- a/src/reader/expect_formal_arglist_xs.cpp +++ b/src/reader/expect_formal_arglist_xs.cpp @@ -4,9 +4,30 @@ */ #include "expect_formal_arglist_xs.hpp" +#include "expect_formal_xs.hpp" +#include "xo/expression/Variable.hpp" +#include "xo/indentlog/print/vector.hpp" namespace xo { namespace scm { + const char * + formalarglstatetype_descr(formalarglstatetype x) { + switch (x) { + case formalarglstatetype::invalid: + return "invalid"; + case formalarglstatetype::argl_0: + return "argl_0"; + case formalarglstatetype::argl_1a: + return "argl_1a"; + case formalarglstatetype::argl_1b: + return "argl_1b"; + case formalarglstatetype::n_formalarglstatetype: + break; + } + + return "?formalarglstatetype"; + } + std::unique_ptr expect_formal_arglist_xs::make() { return std::make_unique @@ -23,13 +44,62 @@ namespace xo { rp * p_emit_expr) { if (farglxs_type_ == formalarglstatetype::argl_0) { - this->farglxs_type_ = formalarglstatetype::argl_1; - return; + this->farglxs_type_ = formalarglstatetype::argl_1a; + p_stack->push_exprstate(expect_formal_xs::make()); + } else { + exprstate::on_leftparen_token(tk, p_stack, p_emit_expr); } - - exprstate::on_leftparen_token(tk, p_stack, p_emit_expr); } + void + expect_formal_arglist_xs::on_formal(const rp & formal, + exprstatestack * p_stack, + rp * p_emit_expr) + { + if (farglxs_type_ == formalarglstatetype::argl_1a) { + this->farglxs_type_ = formalarglstatetype::argl_1b; + this->argl_.push_back(formal); + } else { + exprstate::on_formal(formal, p_stack, p_emit_expr); + } + } + + void + expect_formal_arglist_xs::on_comma_token(const token_type & tk, + exprstatestack * p_stack, + rp * p_emit_expr) + { + if (farglxs_type_ == formalarglstatetype::argl_1b) { + this->farglxs_type_ = formalarglstatetype::argl_1a; + p_stack->push_exprstate(expect_formal_xs::make()); + } else { + exprstate::on_comma_token(tk, p_stack, p_emit_expr); + } + } + + void + expect_formal_arglist_xs::on_rightparen_token(const token_type & tk, + exprstatestack * p_stack, + rp * p_emit_expr) + { + if (farglxs_type_ == formalarglstatetype::argl_1b) { + std::unique_ptr self = p_stack->pop_exprstate(); + + p_stack->top_exprstate().on_formal_arglist(this->argl_, + p_stack, p_emit_expr); + } else { + exprstate::on_rightparen_token(tk, p_stack, p_emit_expr); + } + } + + void + expect_formal_arglist_xs::print(std::ostream & os) const { + os << ""; + } } /*namespace scm*/ } /*namespace xo*/ diff --git a/src/reader/expect_formal_xs.cpp b/src/reader/expect_formal_xs.cpp index 5ec91987..9d69b137 100644 --- a/src/reader/expect_formal_xs.cpp +++ b/src/reader/expect_formal_xs.cpp @@ -4,8 +4,10 @@ */ #include "expect_formal_xs.hpp" +#include "xo/expression/Variable.hpp" namespace xo { + using xo::ast::Variable; using xo::reflect::TypeDescr; namespace scm{ @@ -26,6 +28,11 @@ namespace xo { return "???formalstatetype"; } + std::unique_ptr + expect_formal_xs::make() { + return std::make_unique(expect_formal_xs()); + } + void expect_formal_xs::on_symbol(const std::string & symbol_name, exprstatestack * p_stack, @@ -64,7 +71,10 @@ namespace xo { std::unique_ptr self = p_stack->pop_exprstate(); - //p_stack->top_exprstate().on_formal(result_, p_stack, p_emit_expr); + rp var = Variable::make(result_.name(), + result_.td()); + + p_stack->top_exprstate().on_formal(var, p_stack, p_emit_expr); } else { exprstate::on_typedescr(td, p_stack, p_emit_expr); } diff --git a/src/reader/lambda_xs.cpp b/src/reader/lambda_xs.cpp index e38d5718..a4a19845 100644 --- a/src/reader/lambda_xs.cpp +++ b/src/reader/lambda_xs.cpp @@ -24,12 +24,9 @@ namespace xo { if (lmxs_type_ == lambdastatetype::lm_0) { this->lmxs_type_ = lambdastatetype::lm_1; p_stack->push_exprstate(expect_formal_arglist_xs::make()); - return; + } else { + exprstate::on_lambda_token(tk, p_stack, p_emit_expr); } - - exprstate::on_lambda_token(tk, - p_stack, - p_emit_expr); } void @@ -41,12 +38,9 @@ namespace xo { this->lmxs_type_ = lambdastatetype::lm_2; this->argl_ = argl; p_stack->push_exprstate(expect_expr_xs::expect_rhs_expression()); - return; + } else { + exprstate::on_formal_arglist(argl, p_stack, p_emit_expr); } - - exprstate::on_formal_arglist(argl, - p_stack, - p_emit_expr); } void @@ -57,10 +51,9 @@ namespace xo { if (lmxs_type_ == lambdastatetype::lm_2) { this->lmxs_type_ = lambdastatetype::lm_3; this->body_ = expr.promote(); - return; + } else { + exprstate::on_expr(expr, p_stack, p_emit_expr); } - - exprstate::on_expr(expr, p_stack, p_emit_expr); } void