xo-interpreter2: vsm stack: facet + gcobject + printable + init

src/interpreter2/CMakeLists.txt

@@ -3,11 +3,21 @@
 set(SELF_LIB xo_interpreter2)
 set(SELF_SRCS
     init_interpreter2.cpp
+    interpreter2_register_facets.cpp
+    interpreter2_register_types.cpp
+
     VirtualSchematikaMachine.cpp
-    VsmFrame.cpp
+
+    DVsmEvalArgsFrame.cpp
+    IGCObject_DVsmEvalArgsFrame.cpp
+    IPrintable_DVsmEvalArgsFrame.cpp
+
+    DVsmApplyFrame.cpp
+    IGCObject_DVsmApplyFrame.cpp
+    IPrintable_DVsmApplyFrame.cpp
+
     VsmInstr.cpp
     #IExpression_Any.cpp
-    #interpreter2_register_facets.cpp
     )
 
 xo_add_shared_library4(${SELF_LIB} ${PROJECT_NAME}Targets ${PROJECT_VERSION} 1 ${SELF_SRCS})

src/interpreter2/DVsmApplyFrame.cpp

@@ -0,0 +1,82 @@
+/** @file DVsmApplyFrame.cpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#include "DVsmApplyFrame.hpp"
+#include <xo/indentlog/print/pretty.hpp>
+
+namespace xo {
+    using xo::facet::typeseq;
+
+    namespace scm {
+
+        DVsmApplyFrame::DVsmApplyFrame(obj<AGCObject> old_parent,
+                                       VsmInstr old_cont,
+                                       DArray * args)
+        : VsmFrame(old_parent, old_cont),
+          args_{args}
+        {}
+
+        DVsmApplyFrame *
+        DVsmApplyFrame::make(obj<AAllocator> mm,
+                             obj<AGCObject> old_parent,
+                             VsmInstr old_cont,
+                             DArray * args)
+        {
+            DVsmApplyFrame * result = nullptr;
+
+            void * mem = mm.alloc(typeseq::id<DVsmApplyFrame>(),
+                                  sizeof(DVsmApplyFrame));
+
+            result = new (mem) DVsmApplyFrame(old_parent,
+                                              old_cont,
+                                              args);
+
+            assert(result);
+
+            return result;
+        }
+
+        std::size_t
+        DVsmApplyFrame::shallow_size() const noexcept
+        {
+            return sizeof(DVsmApplyFrame);
+        }
+
+        DVsmApplyFrame *
+        DVsmApplyFrame::shallow_copy(obj<AAllocator> mm) const noexcept
+        {
+            DVsmApplyFrame * copy = (DVsmApplyFrame *)mm.alloc_copy((std::byte *)this);
+
+            if (copy)
+                *copy = *this;
+
+            return copy;
+        }
+
+        std::size_t
+        DVsmApplyFrame::forward_children(obj<ACollector> gc) noexcept
+        {
+            // GC needs to locate AGCObject iface for each member
+
+            (void)gc;
+
+            return this->shallow_size();
+        }
+
+        bool
+        DVsmApplyFrame::pretty(const ppindentinfo & ppii) const
+        {
+            return ppii.pps()->pretty_struct
+                (ppii,
+                 "DVsmApplyFrame",
+                 refrtag("cont", cont_),
+                 refrtag("n_args", args_->size())
+                    );
+        }
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DVsmApplyFrame.cpp */

src/interpreter2/DVsmEvalArgsFrame.cpp

@@ -0,0 +1,77 @@
+/** @file DVsmEvalArgsFrame.cpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#include "DVsmEvalArgsFrame.hpp"
+#include <xo/indentlog/print/pretty.hpp>
+
+namespace xo {
+    using xo::facet::typeseq;
+    using xo::print::ppindentinfo;
+
+    namespace scm {
+
+        // ----- VsmEvalArgsFrame -----
+
+        DVsmEvalArgsFrame::DVsmEvalArgsFrame(obj<AGCObject> old_parent,
+                                             VsmInstr old_cont)
+        : VsmFrame(old_parent, old_cont)
+        {}
+
+        DVsmEvalArgsFrame *
+        DVsmEvalArgsFrame::make(obj<AAllocator> mm,
+                                obj<AGCObject> apply_frame,
+                                VsmInstr cont)
+        {
+            DVsmEvalArgsFrame * result = nullptr;
+
+            void * mem = mm.alloc(typeseq::id<DVsmEvalArgsFrame>(),
+                                  sizeof(DVsmEvalArgsFrame));
+
+            result = new (mem) DVsmEvalArgsFrame(apply_frame, cont);
+
+            assert(result);
+
+            return result;
+        }
+
+        std::size_t
+        DVsmEvalArgsFrame::shallow_size() const noexcept
+        {
+            return sizeof(DVsmEvalArgsFrame);
+        }
+
+        DVsmEvalArgsFrame *
+        DVsmEvalArgsFrame::shallow_copy(obj<AAllocator> mm) const noexcept
+        {
+            DVsmEvalArgsFrame * copy = (DVsmEvalArgsFrame *)mm.alloc_copy((std::byte *)this);
+
+            if (copy)
+                *copy = *this;
+
+            return copy;
+        }
+
+        std::size_t
+        DVsmEvalArgsFrame::forward_children(obj<ACollector> gc) noexcept
+        {
+            (void)gc;
+
+            return this->shallow_size();
+        }
+
+        bool
+        DVsmEvalArgsFrame::pretty(const ppindentinfo & ppii) const
+        {
+            return ppii.pps()->pretty_struct
+                (ppii,
+                 "DVsmEvalArgsFrame",
+                 refrtag("cont", cont_),
+                 refrtag("i_arg", i_arg_)
+                    );
+        }
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end VsmEvalArgsFrame.cpp */

src/interpreter2/IGCObject_DVsmApplyFrame.cpp

@@ -0,0 +1,39 @@
+/** @file IGCObject_DVsmApplyFrame.cpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DVsmApplyFrame.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_any.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DVsmApplyFrame.json5]
+**/
+
+#include "detail/IGCObject_DVsmApplyFrame.hpp"
+
+namespace xo {
+    namespace scm {
+        auto
+        IGCObject_DVsmApplyFrame::shallow_size(const DVsmApplyFrame & self) noexcept -> size_type
+        {
+            return self.shallow_size();
+        }
+
+        auto
+        IGCObject_DVsmApplyFrame::shallow_copy(const DVsmApplyFrame & self, obj<AAllocator> mm) noexcept -> Opaque
+        {
+            return self.shallow_copy(mm);
+        }
+
+        auto
+        IGCObject_DVsmApplyFrame::forward_children(DVsmApplyFrame & self, obj<ACollector> gc) noexcept -> size_type
+        {
+            return self.forward_children(gc);
+        }
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end IGCObject_DVsmApplyFrame.cpp */

src/interpreter2/IGCObject_DVsmEvalArgsFrame.cpp

@@ -0,0 +1,39 @@
+/** @file IGCObject_DVsmEvalArgsFrame.cpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DVsmEvalArgsFrame.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_any.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DVsmEvalArgsFrame.json5]
+**/
+
+#include "detail/IGCObject_DVsmEvalArgsFrame.hpp"
+
+namespace xo {
+    namespace scm {
+        auto
+        IGCObject_DVsmEvalArgsFrame::shallow_size(const DVsmEvalArgsFrame & self) noexcept -> size_type
+        {
+            return self.shallow_size();
+        }
+
+        auto
+        IGCObject_DVsmEvalArgsFrame::shallow_copy(const DVsmEvalArgsFrame & self, obj<AAllocator> mm) noexcept -> Opaque
+        {
+            return self.shallow_copy(mm);
+        }
+
+        auto
+        IGCObject_DVsmEvalArgsFrame::forward_children(DVsmEvalArgsFrame & self, obj<ACollector> gc) noexcept -> size_type
+        {
+            return self.forward_children(gc);
+        }
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end IGCObject_DVsmEvalArgsFrame.cpp */

src/interpreter2/IPrintable_DVsmApplyFrame.cpp

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

src/interpreter2/IPrintable_DVsmEvalArgsFrame.cpp

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

src/interpreter2/VirtualSchematikaMachine.cpp

@@ -4,6 +4,8 @@
  **/
 
 #include "VirtualSchematikaMachine.hpp"
+#include "VsmApplyFrame.hpp"
+#include "VsmEvalArgsFrame.hpp"
 #include <xo/expression2/ApplyExpr.hpp>
 #include <xo/expression2/Constant.hpp>
 #include <xo/gc/DX1Collector.hpp>
@@ -111,6 +113,17 @@ namespace xo {
         bool
         VirtualSchematikaMachine::execute_one()
         {
+            scope log(XO_DEBUG(true));
+            log && log(xtag("pc", pc_),
+                       xtag("cont", cont_));
+
+            obj<APrintable> stack_pr
+                = (FacetRegistry::instance()
+                   .try_variant<APrintable,AGCObject>(stack_));
+
+            if (stack_pr)
+                log && log(xtag("stack", stack_pr));
+
             switch (pc_.opcode()) {
             case vsm_opcode::halt:
             case vsm_opcode::N:
@@ -222,11 +235,13 @@ namespace xo {
 
             // TODO: check function signature
 
-            VsmApplyFrame * apply_frame
-                = VsmApplyFrame::make(mm_.to_op(), stack_, cont_, args);
+            auto apply_frame
+                = obj<AGCObject,DVsmApplyFrame>
+                (DVsmApplyFrame::make(mm_.to_op(), stack_, cont_, args));
 
-            VsmEvalArgsFrame * evalargs_frame
-                = VsmEvalArgsFrame::make(mm_.to_op(), apply_frame, VsmInstr::c_apply);
+            auto evalargs_frame
+                = obj<AGCObject,DVsmEvalArgsFrame>
+                (DVsmEvalArgsFrame::make(mm_.to_op(), apply_frame, VsmInstr::c_apply));
 
             this->stack_ = evalargs_frame;
 

src/interpreter2/VsmFrame.cpp

@@ -1,68 +0,0 @@
-/** @file VsmFrame.cpp
- *
- *  @author Roland Conybeare, Feb 2026
- **/
-
-#include "VsmFrame.hpp"
-
-namespace xo {
-    using xo::facet::typeseq;
-
-    namespace scm {
-
-        VsmApplyFrame::VsmApplyFrame(VsmFrame * old_parent,
-                                     VsmInstr old_cont,
-                                     DArray * args)
-        : VsmFrame(old_parent, old_cont),
-          args_{args}
-        {}            
-
-        VsmApplyFrame *
-        VsmApplyFrame::make(obj<AAllocator> mm,
-                            VsmFrame * old_parent,
-                            VsmInstr old_cont,
-                            DArray * args)
-        {
-            VsmApplyFrame * result = nullptr;
-
-            void * mem = mm.alloc(typeseq::id<VsmApplyFrame>(),
-                                  sizeof(VsmApplyFrame));
-
-            result = new (mem) VsmApplyFrame(old_parent,
-                                             old_cont,
-                                             args);
-
-            assert(result);
-
-            return result;
-        }
-
-        // ----- VsmEvalArgsFrame -----
-
-        VsmEvalArgsFrame::VsmEvalArgsFrame(VsmApplyFrame * old_parent,
-                                           VsmInstr old_cont)
-        : VsmFrame(old_parent, old_cont)
-        {}
-
-        VsmEvalArgsFrame *
-        VsmEvalArgsFrame::make(obj<AAllocator> mm,
-                               VsmApplyFrame * apply_frame,
-                               VsmInstr cont)
-        {
-            VsmEvalArgsFrame * result = nullptr;
-
-            void * mem = mm.alloc(typeseq::id<VsmEvalArgsFrame>(),
-                                  sizeof(VsmEvalArgsFrame));
-
-            result = new (mem) VsmEvalArgsFrame(apply_frame, cont);
-
-            assert(result);
-
-            return result;
-        }
-
-    } /*namespace scm*/
-} /*namespace xo*/
-
-/* end VsmFrame.cpp */
-

src/interpreter2/VsmInstr.cpp

@@ -7,6 +7,21 @@
 
 namespace xo {
     namespace scm {
+        const char *
+        vsm_opcode_descr(vsm_opcode x)
+        {
+            switch (x) {
+            case vsm_opcode::halt: return "halt";
+            case vsm_opcode::eval: return "eval";
+            case vsm_opcode::apply: return "apply";
+            case vsm_opcode::evalargs: return "evalargs";
+            case vsm_opcode::N:
+                break;
+            }
+
+            return "opcode?";
+        }
+
         VsmInstr
         VsmInstr::c_halt = VsmInstr(vsm_opcode::halt);
 

src/interpreter2/init_interpreter2.cpp

@@ -5,31 +5,23 @@
 
 #include "init_interpreter2.hpp"
 
-#ifdef NOT_YET
 #include "interpreter2_register_facets.hpp"
 #include "interpreter2_register_types.hpp"
-#endif
 
 #include <xo/reader2/init_reader2.hpp>
-#ifdef NOT_YET
 #include <xo/gc/CollectorTypeRegistry.hpp>
-#endif
 
 namespace xo {
-#ifdef NOT_YET
     using xo::scm::interpreter2_register_facets;
     using xo::scm::interpreter2_register_types;
     using xo::mm::CollectorTypeRegistry;
-#endif
 
     void
     InitSubsys<S_interpreter2_tag>::init()
     {
-#ifdef NOT_YET
         interpreter2_register_facets();
 
         CollectorTypeRegistry::instance().register_types(&interpreter2_register_types);
-#endif
     }
 
     InitEvidence

src/interpreter2/interpreter2_register_facets.cpp

@@ -0,0 +1,47 @@
+/** @file interpreter2_register_facets.cpp
+ *
+ *  @author Roland Conybeare, Feb 2026
+ **/
+
+#include "interpreter2_register_facets.hpp"
+
+#include "VsmApplyFrame.hpp"
+#include "VsmEvalArgsFrame.hpp"
+
+#include <xo/printable2/detail/APrintable.hpp>
+#include <xo/facet/FacetRegistry.hpp>
+#include <xo/reflectutil/typeseq.hpp>
+#include <xo/indentlog/scope.hpp>
+
+namespace xo {
+    using xo::mm::AGCObject;
+    using xo::print::APrintable;
+    using xo::facet::FacetRegistry;
+    using xo::reflect::typeseq;
+    using xo::xtag;
+
+    namespace scm {
+        bool
+        interpreter2_register_facets()
+        {
+            scope log(XO_DEBUG(true));
+
+            // VsmStackFrame
+            // +- VsmApplyFrame
+            // \- VsmEvalArgsFrame
+
+            FacetRegistry::register_impl<AGCObject, DVsmApplyFrame>();
+            FacetRegistry::register_impl<APrintable, DVsmApplyFrame>();
+
+            FacetRegistry::register_impl<AGCObject, DVsmEvalArgsFrame>();
+            FacetRegistry::register_impl<APrintable, DVsmEvalArgsFrame>();
+
+            log && log(xtag("DVsmApplyFrame.tseq", typeseq::id<DVsmApplyFrame>()));
+            log && log(xtag("DVsmEvalArgsFrame.tseq", typeseq::id<DVsmEvalArgsFrame>()));
+
+            return true;
+        }
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end interpreter2_register_facets.cpp */

src/interpreter2/interpreter2_register_types.cpp

@@ -0,0 +1,36 @@
+/** @file interpreter2_register_types.cpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#include "interpreter2_register_types.hpp"
+
+#include "VsmApplyFrame.hpp"
+#include "VsmEvalArgsFrame.hpp"
+
+#include <xo/indentlog/scope.hpp>
+
+namespace xo {
+    using xo::mm::ACollector;
+    using xo::mm::AGCObject;
+    using xo::facet::impl_for;
+    //using xo::facet::typeseq;
+    using xo::scope;
+
+    namespace scm {
+        bool
+        interpreter2_register_types(obj<ACollector> gc)
+        {
+            scope log(XO_DEBUG(true));
+
+            bool ok = true;
+
+            ok &= gc.install_type(impl_for<AGCObject, DVsmApplyFrame>());
+            ok &= gc.install_type(impl_for<AGCObject, DVsmEvalArgsFrame>());
+
+            return ok;
+        }
+    }
+} /*namespace xo*/
+
+/* end interpreter2_register_types.cpp */