wow there is something wrong, check debug mode!

CMakeLists.txt

@@ -27,7 +27,7 @@ macro(compile_options target_name)
     sanitizers(${target_name})
 endmacro()
 
-project(blt-gp VERSION 0.3.13)
+project(blt-gp VERSION 0.3.14)
 
 include(CTest)
 

include/blt/gp/stack.h

@@ -168,11 +168,11 @@ namespace blt::gp
             const auto ptr = static_cast<char*>(allocate_bytes_for_size(aligned_size<NO_REF>()));
             std::memcpy(ptr, &t, sizeof(NO_REF));
 
-            if constexpr (gp::detail::has_func_drop_ephemeral_v<T>)
+            // if constexpr (gp::detail::has_func_drop_ephemeral_v<T>)
-            {
+            // {
-                const auto* ref_counter_ptr = new std::atomic_uint64_t(1); // NOLINT
+                // const auto* ref_counter_ptr = new std::atomic_uint64_t(1); // NOLINT
-                std::memcpy(ptr + sizeof(NO_REF), &ref_counter_ptr, sizeof(std::atomic_uint64_t*));
+                // std::memcpy(ptr + sizeof(NO_REF), &ref_counter_ptr, sizeof(std::atomic_uint64_t*));
-            }
+            // }
         }
 
         template <typename T, typename NO_REF = NO_REF_T<T>>

include/blt/gp/tree.h

@@ -171,7 +171,7 @@ namespace blt::gp
     public:
         explicit tree_t(gp_program& program);
 
-        tree_t(const tree_t& copy): func(copy.func)
+        tree_t(const tree_t& copy): m_program(copy.m_program)
         {
             copy_fast(copy);
         }
@@ -180,6 +180,7 @@ namespace blt::gp
         {
             if (this == &copy)
                 return *this;
+            m_program = copy.m_program;
             copy_fast(copy);
             return *this;
         }
@@ -245,12 +246,14 @@ namespace blt::gp
         void insert_operator(const op_container_t& container)
         {
             operations.emplace_back(container);
+            handle_operator_inserted(operations.back());
         }
 
         template <typename... Args>
         void emplace_operator(Args&&... args)
         {
             operations.emplace_back(std::forward<Args>(args)...);
+            handle_operator_inserted(operations.back());
         }
 
         [[nodiscard]] tracked_vector<op_container_t>& get_operations()
@@ -405,17 +408,26 @@ namespace blt::gp
         }
 
     private:
+        void handle_operator_inserted(const op_container_t& op);
+
         template <typename T, std::enable_if_t<!(std::is_pointer_v<T> || std::is_null_pointer_v<T>), bool>  = true>
         [[nodiscard]] evaluation_context& evaluate(const T& context) const
         {
-            return (*func)(*this, const_cast<void*>(static_cast<const void*>(&context)));
+            return evaluate(const_cast<void*>(static_cast<const void*>(&context)));
         }
 
         [[nodiscard]] evaluation_context& evaluate() const
         {
-            return (*func)(*this, nullptr);
+            return evaluate(nullptr);
         }
 
+        [[nodiscard]] evaluation_context& evaluate(void* ptr) const;
+
+        tracked_vector<op_container_t> operations;
+        stack_allocator values;
+        gp_program* m_program;
+
+    protected:
         template <typename Context, typename Operator>
         static void execute(void* context, stack_allocator& write_stack, stack_allocator& read_stack, Operator& operation)
         {
@@ -457,10 +469,6 @@ namespace blt::gp
         {
             call_jmp_table_internal<Context>(op, context, write_stack, read_stack, std::index_sequence_for<Operators...>(), operators...);
         }
-
-        tracked_vector<op_container_t> operations;
-        stack_allocator values;
-        detail::eval_func_t* func;
     };
 
     struct fitness_t

src/generators.cpp

@@ -69,10 +69,7 @@ namespace blt::gp
             max_depth = std::max(max_depth, top.depth);
             
             if (args.program.is_operator_ephemeral(top.id))
-            {
-                info.func(nullptr, tree.get_values(), tree.get_values());
                 continue;
-            }
             
             for (const auto& child : info.argument_types)
                 std::forward<Func>(perChild)(args.program, tree_generator, child, top.depth + 1);

src/transformers.cpp

@@ -352,8 +352,9 @@ namespace blt::gp
                 auto copy = c;
                 try
                 {
-                    const auto& result = copy.evaluate(*static_cast<char*>(detail::debug::context_ptr));
+                    // TODO a work around for the whole needing to access a now private function
-                    blt::black_box(result);
+                    // const auto& result = copy.evaluate(*static_cast<char*>(detail::debug::context_ptr));
+                    // blt::black_box(result);
                 } catch (...)
                 {
                     std::cout << "This occurred at point " << begin_point << " ending at (old) " << end_point << "\n";

src/tree.cpp

@@ -25,7 +25,7 @@
 namespace blt::gp
 {
     // this one will copy previous bytes over
-    template<typename T>
+    template <typename T>
     blt::span<blt::u8> get_pointer_for_size(blt::size_t size)
     {
         static blt::span<blt::u8> buffer{nullptr, 0};
@@ -87,7 +87,8 @@ namespace blt::gp
                 indent++;
                 arguments_left.emplace(info.argc.argc);
                 out << name << return_type << end_indent(pretty_print);
-            } else
+            }
+            else
             {
                 if (print_literals)
                 {
@@ -96,10 +97,12 @@ namespace blt::gp
                     {
                         program.get_print_func(v.id())(out, reversed);
                         reversed.pop_bytes(v.type_size());
-                    } else
+                    }
+                    else
                         out << name;
                     out << return_type << end_indent(pretty_print);
-                } else
+                }
+                else
                     create_indent(out, indent, pretty_print) << name << return_type << end_indent(pretty_print);
             }
 
@@ -112,7 +115,8 @@ namespace blt::gp
                     indent--;
                     create_indent(out, indent, pretty_print) << ")" << end_indent(pretty_print);
                     continue;
-                } else
+                }
+                else
                 {
                     if (!pretty_print)
                         out << " ";
@@ -130,7 +134,8 @@ namespace blt::gp
                 indent--;
                 create_indent(out, indent, pretty_print) << ")" << end_indent(pretty_print);
                 continue;
-            } else
+            }
+            else
             {
                 BLT_ERROR("Failed to print tree correctly!");
                 break;
@@ -196,7 +201,8 @@ namespace blt::gp
             if (type.argc.argc > 0)
                 children_left += type.argc.argc;
             start++;
-        } while (children_left > 0);
+        }
+        while (children_left > 0);
 
         return start;
     }
@@ -216,15 +222,30 @@ namespace blt::gp
             if (children_left <= 0)
                 break;
             --start;
-        } while (true);
+        }
+        while (true);
 
         return start;
     }
 
+    void tree_t::handle_operator_inserted(const op_container_t& op)
+    {
+        if (m_program->is_operator_ephemeral(op.id()))
+        {
+            // Ephemeral values have corresponding insertions into the stack
+            m_program->get_operator_info(op.id()).func(nullptr, values, values);
+        }
+    }
+
+    evaluation_context& tree_t::evaluate(void* ptr) const
+    {
+        return m_program->get_eval_func()(*this, ptr);
+    }
+
     bool tree_t::check(gp_program& program, void* context) const
     {
         blt::size_t bytes_expected = 0;
-        auto bytes_size = values.size().total_used_bytes;
+        const auto bytes_size = values.size().total_used_bytes;
 
         for (const auto& op : get_operations())
         {
@@ -287,32 +308,33 @@ namespace blt::gp
             if (current_point == 0)
             {
                 // first child.
-                prev = {static_cast<ptrdiff_t>(parent_node + 1),
+                prev = {
-                        find_endpoint(program, static_cast<ptrdiff_t>(parent_node + 1))};
+                    static_cast<ptrdiff_t>(parent_node + 1),
+                    find_endpoint(program, static_cast<ptrdiff_t>(parent_node + 1))
+                };
                 vec.push_back(prev);
                 continue;
-            } else
+            }
             prev = vec[current_point - 1];
             child_t next = {prev.end, find_endpoint(program, prev.end)};
             vec.push_back(next);
         }
     }
 
-    tree_t::tree_t(gp_program& program): func(&program.get_eval_func())
+    tree_t::tree_t(gp_program& program): m_program(&program)
     {
-    
     }
 
     void tree_t::clear(gp_program& program)
     {
-        auto* f = &program.get_eval_func();
+        auto* f = &program;
-        if (f != func)
+        if (&program != m_program)
-            func = f;
+            m_program = f;
         for (const auto& op : operations)
         {
             if (op.has_ephemeral_drop())
             {
-
+                // TODO:
             }
         }
         operations.clear();

tests/drop_test.cpp

@@ -47,7 +47,7 @@ struct drop_type
         ++ephemeral_construct;
     }
 
-    void drop()
+    void drop() const
     {
         if (!ephemeral)
             ++normal_drop;