xo-expression2 stack: + mvp DGlobalSymtab impl

src/expression2/DGlobalSymtab.cpp

@@ -5,20 +5,108 @@
 
 #include "DGlobalSymtab.hpp"
 #include "DUniqueString.hpp"
+#include <xo/expression2/Expression.hpp>
+#include <xo/expression2/Variable.hpp>
+#include <xo/gc/GCObject.hpp>
+#include <xo/facet/FacetRegistry.hpp>
 #include <xo/indentlog/scope.hpp>
 
 namespace xo {
+    using xo::mm::AGCObject;
+
     namespace scm {
 
+#ifdef NOT_YET
+        DVariable *
+        DGlobalSymtab::lookup_binding(Binding ix) noexcept
+        {
+            assert(ix.i_link() == -1);
+            assert(ix.j_slot() >= 0);
+            assert(vars_);
+            assert(std::uint64_t(ix.j_slot()) < vars_->size());
+
+            auto var_gco = obj<AGCObject,DVariable>::from((*vars_)[ix.j_slot()]);;
+            auto var = var_gco.to_facet<AExpression>();
+
+            assert(var.data());
+
+            return var.data();
+        }
+#endif
+
+        DVariable *
+        DGlobalSymtab::lookup_variable(const DUniqueString * sym) const noexcept
+        {
+            Binding existing = this->lookup_binding(sym);
+
+            if (existing.is_null())
+                return nullptr;
+
+            auto var_gco = obj<AGCObject,DVariable>::from((*vars_)[existing.j_slot()]);
+            auto var = var_gco.to_facet<AExpression>();
+
+            assert(var.data());
+
+            return var.data();
+        }
+
+        DVariable *
+        DGlobalSymtab::establish_variable(obj<AAllocator> mm,
+                                          const DUniqueString * sym,
+                                          TypeRef typeref)
+        {
+            DVariable * var = this->lookup_variable(sym);
+
+            if (!var) {
+                assert(vars_);
+
+                DArray::size_type n = vars_->size();
+
+                /** make sure vars_ has room **/
+                if (n == vars_->capacity()) {
+                    // reallocate with more capacity
+                    DArray * vars_2x = DArray::copy(mm, vars_, vars_->capacity() * 2);
+
+                    assert(vars_2x);
+
+                    this->vars_ = vars_2x;
+                }
+
+                /** create new variable **/
+                Binding binding = Binding::global(n);
+                var = DVariable::make(mm, sym, typeref, binding);
+
+                if (!var) {
+                    // something terribly wrong
+                    assert(false);
+                    return var;
+                }
+
+                map_[sym] = binding.j_slot();
+
+                bool ok = vars_->push_back(obj<AGCObject,DVariable>(var));
+
+                if (!ok)
+                    assert(false);
+            }
+
+            return var;
+        }
+
         Binding
         DGlobalSymtab::lookup_binding(const DUniqueString * sym) const noexcept
         {
-            (void)sym;
+            assert(sym);
 
             scope log(XO_DEBUG(true), "stub");
             log && log(xtag("sym", std::string_view(*sym)));
 
-            return Binding();
+            auto ix = map_.find(sym);
+
+            if (ix == map_.end()) 
+                return Binding::null();
+
+            return Binding::global(ix->second);
         }
 
     } /*namespace scm*/