xo-expression2 xo-reader2: local symtab stack in PSM

xo-reader2/src/reader2/DExpectFormalArglistSsm.cpp

@@ -126,6 +126,10 @@ namespace xo {
                 this->on_comma_token(tk, p_psm);
                 return;
 
+            case tokentype::tk_rightparen:
+                this->on_rightparen_token(tk, p_psm);
+                return;
+
                 // all the not-yet-handled cases
             case tokentype::tk_lambda:
             case tokentype::tk_def:
@@ -139,7 +143,6 @@ namespace xo {
             case tokentype::tk_bool:
             case tokentype::tk_semicolon:
             case tokentype::tk_invalid:
-            case tokentype::tk_rightparen:
             case tokentype::tk_leftbracket:
             case tokentype::tk_rightbracket:
             case tokentype::tk_leftbrace:
@@ -300,20 +303,22 @@ namespace xo {
                                           this->get_expect_str());
         }
 
-#ifdef NOT_YET
         void
-        expect_formal_arglist_xs::on_rightparen_token(const token_type & tk,
-                                                      parserstatemachine * p_psm)
+        DExpectFormalArglistSsm::on_rightparen_token(const Token & tk,
+                                                     ParserStateMachine * p_psm)
         {
-            if (farglxs_type_ == formalarglstatetype::argl_1b) {
-                std::unique_ptr<exprstate> self = p_psm->pop_exprstate();
+            if (fastate_ == formalarglstatetype::argl_1b) {
+                DArray * args = argl_;
 
-                p_psm->top_exprstate().on_formal_arglist(this->argl_, p_psm);
-            } else {
-                exprstate::on_rightparen_token(tk, p_psm);
+                p_psm->pop_ssm();
+                p_psm->on_parsed_formal_arglist(args);
+                return;
             }
+
+            p_psm->illegal_input_on_token("DExpectFormalArglistSsm::on_rightparen_token",
+                                          tk,
+                                          this->get_expect_str());
         }
-#endif
 
         bool
         DExpectFormalArglistSsm::pretty(const ppindentinfo & ppii) const

xo-reader2/src/reader2/DLambdaSsm.cpp

@@ -9,6 +9,9 @@
 #include "ssm/ISyntaxStateMachine_DExpectFormalArglistSsm.hpp"
 #include "ParserStateMachine.hpp"
 #include "syntaxstatetype.hpp"
+#include <xo/expression2/DVariable.hpp>
+#include <xo/expression2/detail/IExpression_DVariable.hpp>
+//#include <xo/expression2/symtab/ISymbolTable_DLocalSymtab.hpp>
 #include <xo/printable2/Printable.hpp>
 #include <xo/facet/FacetRegistry.hpp>
 #include <xo/arena/DArena.hpp>
@@ -28,6 +31,7 @@
 namespace xo {
     using xo::print::APrintable;
     using xo::mm::AAllocator;
+    using xo::mm::AGCObject;
     using xo::facet::FacetRegistry;
     using xo::reflect::typeseq;
 
@@ -353,6 +357,54 @@ namespace xo {
         DLambdaSsm::on_parsed_formal_arglist(DArray * arglist,
                                              ParserStateMachine * p_psm)
         {
+            if (lmstate_ == lambdastatetype::lm_1) {
+                this->lmstate_ = lambdastatetype::lm_2;
+                /// something with top env frame ?
+
+                /// TODO: arena-friendly non-gc-aware vector;
+                //        use instead of DArray for arglist.
+                //        something like DTypedArray<T>
+
+                /// create LocalSymtab from arglist
+
+                DLocalSymtab * symtab
+                    = DLocalSymtab::_make_empty(p_psm->expr_alloc(),
+                                                p_psm->local_symtab(),
+                                                arglist->size());
+                assert(symtab);
+
+                for (DArray::size_type i = 0, n = arglist->size(); i < n; ++i) {
+                    obj<AGCObject> param = arglist->at(i);
+
+                    // sad! runtime poly conversion from obj<AGCObject>
+                    // We on need this because of (suboptimally) using DArray to store arglist
+
+                    obj<AExpression> param_expr
+                        = FacetRegistry::instance().variant<AExpression,AGCObject>(param);
+                    obj<AExpression,DVariable> param_var
+                        = obj<AExpression,DVariable>::from(param_expr);
+
+                    assert(param_expr.data());
+                    assert(param_var.data());
+
+                    Binding b = symtab->append_var(p_psm->expr_alloc(),
+                                                   param_var.data()->name(),
+                                                   param_var.data()->typeref());
+
+                    assert(b.is_local());
+
+                    this->local_symtab_ = symtab;
+                }
+
+                // stash env frame: records local variables while we handle lambda body
+
+                p_psm->push_local_symtab(symtab);
+
+                // control reenters via .on_colon_token() / .on_leftbrace_token()
+
+                return;
+            }
+
             p_psm->illegal_parsed_formal_arglist("DLambdaSsm::on_parsed_formal_arglist",
                                                  arglist,
                                                  this->get_expect_str());

xo-reader2/src/reader2/ParserStack.cpp

@@ -70,7 +70,7 @@ namespace xo {
             std::size_t i_frame = 0;
 
             while (frame) {
-                char buf[80];
+                char buf[32];
                 snprintf(buf, sizeof(buf), "[%lu]", i_frame);
 
                 auto ssm = (FacetRegistry::instance().variant

xo-reader2/src/reader2/ParserStateMachine.cpp

@@ -88,6 +88,20 @@ namespace xo {
             return stringtable_.intern(str);
         }
 
+        void
+        ParserStateMachine::push_local_symtab(DLocalSymtab * symtab)
+        {
+            this->local_symtab_ = symtab;
+        }
+
+        void
+        ParserStateMachine::pop_local_symtab()
+        {
+            assert(local_symtab_);
+
+            this->local_symtab_ = local_symtab_->parent();
+        }
+
         void
         ParserStateMachine::upsert_var(DVariable * var)
         {
@@ -310,6 +324,12 @@ namespace xo {
                                        xtag("expecting", expect_str),
                                        xtag("ssm", ssm_name),
                                        xtag("via", "ParserStateMachine::illegal_parsed_formal_arglist"));
+
+            assert(expr_alloc_);
+
+            auto errmsg = DString::from_str(expr_alloc_, errmsg_string);
+
+            this->capture_error(ssm_name, errmsg);
         }
 
         void