openscad-cpp-evaluator 0.6.0__tar.gz → 0.7.0__tar.gz

{openscad_cpp_evaluator-0.6.0 → openscad_cpp_evaluator-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 0.6.0
+Version: 0.7.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-0.6.0 → openscad_cpp_evaluator-0.7.0}/bindings/module.cpp

@@ -27,6 +27,7 @@
 
 #include "openscad_cpp_parser/api.hpp"
 
+#include <atomic>
 #include <cstdint>
 #include <exception>
 #include <memory>
@@ -362,17 +363,20 @@ using GetChildrenPositionsFn = std::function<const std::optional<std::vector<std
 // exactly where it already computes should_pause, without needing to
 // widen hook()'s existing (cmd, mods) return-tuple contract -- mirrors
 // generate_partial/get_children_positions's own "extra kwarg the Python
-// side may or may not call" shape.
-using SetFastContinueFn = std::function<void(std::optional<std::unordered_map<std::string, std::set<int>>>)>;
+// side may or may not call" shape. `hookSkippable` mirrors
+// setFastContinueBreakpoints's own second parameter exactly -- see its
+// doc comment for why this is narrower than "breakpoints is accurate."
+using SetFastContinueFn = std::function<void(std::optional<std::unordered_map<std::string, std::set<int>>>, bool)>;
 
 // Wraps a SetFastContinueFn as a Python callable taking either a
 // dict[str, set[int]]/dict[str, list[int]] (origin -> breakpoint lines) or
-// None. Mirrors generatePartialTrampoline's own shape.
+// None, plus a hook_skippable bool (default False). Mirrors
+// generatePartialTrampoline's own shape.
 nb::object setFastContinueTrampoline(const SetFastContinueFn& setFastContinue) {
     return nb::cpp_function(
-        [&setFastContinue](nb::object breakpoints) {
+        [&setFastContinue](nb::object breakpoints, bool hookSkippable) {
             if (breakpoints.is_none()) {
-                setFastContinue(std::nullopt);
+                setFastContinue(std::nullopt, hookSkippable);
                 return;
             }
             std::unordered_map<std::string, std::set<int>> bp;
@@ -381,7 +385,7 @@ nb::object setFastContinueTrampoline(const SetFastContinueFn& setFastContinue) {
                 for (nb::handle line : v) lines.insert(nb::cast<int>(line));
                 bp.emplace(nb::cast<std::string>(k), std::move(lines));
             }
-            setFastContinue(std::move(bp));
+            setFastContinue(std::move(bp), hookSkippable);
         },
         // Without .none(), nanobind rejects a Python `None` argument for an
         // `nb::object`-typed parameter registered this ad-hoc way (unlike a
@@ -391,9 +395,33 @@ nb::object setFastContinueTrampoline(const SetFastContinueFn& setFastContinue) {
         // was called with breakpoints=None (DebugSession's own
         // _apply_fast_continue calls it with None whenever fast-continue
         // mode isn't safe right now -- see debugger.py).
-        nb::arg("breakpoints").none());
+        nb::arg("breakpoints").none(), nb::arg("hook_skippable") = false);
 }
 
+// Python-visible handle onto a lock-free, GIL-free interrupt flag -- see
+// Evaluator::setFastContinueInterruptFlag's own doc comment (evaluator.hpp)
+// for why this exists at all: debug_evaluate() runs as one single blocking
+// call with the GIL released for its whole duration, so there is no live,
+// Python-callable Evaluator handle DebugSession.pause()/set_breakpoints()
+// (running on the MAIN/GUI thread) could otherwise invoke directly to
+// interrupt hook-skippable mode. A caller creates ONE of these before
+// calling debug_evaluate() (passing it as fast_continue_signal), keeps it
+// around for the whole debug session, and calls .request() from the main
+// thread any time a hook-skippable checkDebug() call needs to stop
+// skipping and actually consult Python again -- Pause, or a breakpoint
+// being toggled in an editor tab while a render is mid-flight. Nothing
+// else needs to read it back on the Python side; C++ test-and-clears it
+// (see checkDebug's own doc comment, debug_profile.cpp) the moment it acts
+// on it, so there's no separate "acknowledge" step.
+class FastContinueSignal {
+public:
+    void request() { flag_->store(true, std::memory_order_release); }
+    const std::shared_ptr<std::atomic<bool>>& flag() const { return flag_; }
+
+private:
+    std::shared_ptr<std::atomic<bool>> flag_ = std::make_shared<std::atomic<bool>>(false);
+};
+
 // GIL held (reacquired by the caller). `getFrame`/`callStack`/`generatePartial`/
 // `getChildrenPositions` are valid only for this synchronous call, so their
 // closures are only ever invoked from within the Python hook, before it returns.
@@ -470,7 +498,8 @@ void callPyReturnHook(nb::handle returnHook, const std::string& name, const osca
 // blocks on the Python side (threading.Event) so the GUI thread keeps running.
 nb::object debugEvaluate(const std::string& path, nb::dict viewportParams, nb::callable debugHook,
                           nb::callable errorBreak, nb::callable echoFn,
-                          std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, nb::object returnHook) {
+                          std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, nb::object returnHook,
+                          FastContinueSignal* fastContinueSignal) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
@@ -501,8 +530,8 @@ nb::object debugEvaluate(const std::string& path, nb::dict viewportParams, nb::c
             return evPtr->lastChildrenPositions();
         };
         SetFastContinueFn setFastContinue =
-            [&evPtr](std::optional<std::unordered_map<std::string, std::set<int>>> breakpoints) {
-            evPtr->setFastContinueBreakpoints(std::move(breakpoints));
+            [&evPtr](std::optional<std::unordered_map<std::string, std::set<int>>> breakpoints, bool hookSkippable) {
+            evPtr->setFastContinueBreakpoints(std::move(breakpoints), hookSkippable);
         };
         oscadeval::DebugHooks hooks;
         hooks.debugHook = [&](int line, int depth, bool forced, bool exprLevel, const std::string& origin,
@@ -528,6 +557,7 @@ nb::object debugEvaluate(const std::string& path, nb::dict viewportParams, nb::c
             oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(ast, path, echoCpp);
             oscadeval::Evaluator ev(echoCpp, nullptr, manifoldCache, hooks, false);
             evPtr = &ev;
+            if (fastContinueSignal) ev.setFastContinueInterruptFlag(fastContinueSignal->flag());
             oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
             bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp));
             collectIdSpans(ev, idSpans);
@@ -602,6 +632,12 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
         .def(nb::init<>())
         .def("clear", &oscadeval::ManifoldCache::clear);
 
+    // See FastContinueSignal's own doc comment, above -- only a
+    // constructor and request() are ever called from Python.
+    nb::class_<FastContinueSignal>(m, "FastContinueSignal")
+        .def(nb::init<>())
+        .def("request", &FastContinueSignal::request);
+
     m.def("evaluate", &evaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("manifold_cache") = nullptr,
           nb::arg("profile") = false,
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).");
@@ -609,6 +645,6 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "Parse a .scad file; return top-level declaration (namespace, name, start, end, line, column, origin) tuples.");
     m.def("debug_evaluate", &debugEvaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("debug_hook"),
           nb::arg("error_break"), nb::arg("echo_fn"), nb::arg("manifold_cache") = nullptr,
-          nb::arg("return_hook") = nb::none(),
+          nb::arg("return_hook") = nb::none(), nb::arg("fast_continue_signal") = nullptr,
           "Evaluate with the debugger wired in; returns (bodies, [], id_to_node, dyn, dyn_explicit). Callbacks fire under the GIL.");
 }

{openscad_cpp_evaluator-0.6.0 → openscad_cpp_evaluator-0.7.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -15,6 +15,7 @@
 
 #include "openscad_cpp_parser/ast.hpp"
 
+#include <atomic>
 #include <chrono>
 #include <cstdint>
 #include <functional>
@@ -329,12 +330,61 @@ public:
     // exception at all" (today's original, always-safe behavior) --
     // e.g. the instant a step command starts or a pause is requested.
     // Cheap to call as often as the debugger's own state changes: this
-    // just updates one member, no cache invalidation needed (chunkEligibleNow
-    // is re-checked on every lookupOrCompileChunk/lookupCompiledLiteralChunk
-    // call, not cached itself -- only the compiled bytecode ITSELF, which
-    // never depends on debugger state, is cached forever).
-    void setFastContinueBreakpoints(std::optional<std::unordered_map<std::string, std::set<int>>> breakpoints) {
+    // just updates two members, no cache invalidation needed (chunkEligibleNow/
+    // checkDebug are re-checked on every call, not cached themselves -- only
+    // the compiled bytecode ITSELF, which never depends on debugger state,
+    // is cached forever).
+    //
+    // `hookSkippable`: a STRICTLY narrower claim than "breakpoints is
+    // accurate" above -- true only when NOTHING needs to inspect a
+    // statement-level checkpoint's own line/depth at all, not just "nothing
+    // needs to inspect it unless it's a compiled function's entry." This is
+    // false for step_over/step_out even though THEY also pass a real
+    // breakpoints set (chunkEligibleNow/useBytecodeVm still apply for them):
+    // both need checkDebug() to keep calling into the debug hook on every
+    // statement so the caller's own step_hit logic (line/depth comparison
+    // against the step's own starting point) can run -- there is no way to
+    // decide that in advance the way a breakpoint LOCATION can be. Only a
+    // plain "Continue" with no step pending can safely skip the call
+    // entirely for a line with no breakpoint -- see checkDebug's own doc
+    // comment (debug_profile.cpp) for where this is actually consulted.
+    void setFastContinueBreakpoints(std::optional<std::unordered_map<std::string, std::set<int>>> breakpoints,
+                                     bool hookSkippable = false) {
         fastContinueBreakpoints_ = std::move(breakpoints);
+        fastContinueHookSkippable_ = hookSkippable;
+    }
+
+    // The other half of hook-skippable mode's safety net. checkDebug()'s
+    // whole premise (see its own doc comment, debug_profile.cpp) is that it
+    // can skip calling into Python for a line with no breakpoint -- but the
+    // caller that decided that (DebugSession, on the MAIN/GUI thread) needs
+    // a way to say "actually, don't skip the very next one" from OUTSIDE any
+    // hook call, since debug_evaluate() runs as one single blocking call
+    // with the GIL released for its whole duration: there is no live,
+    // Python-callable Evaluator handle to invoke setFastContinueBreakpoints
+    // on directly the way a synchronous API would allow. A user clicking
+    // Pause, or toggling a breakpoint in an editor tab, while a hook-
+    // skippable render is mid-flight needs to take effect on the very next
+    // checkpoint, not "whenever a breakpoint happens to be hit next" (which,
+    // in hook-skippable mode, could be never, for a script with none set).
+    //
+    // `flag` is a plain shared_ptr<atomic<bool>> -- lock-free and GIL-free
+    // by construction, so the caller (bindings/module.cpp wraps it in a
+    // small Python-visible class) can set it from the main thread at any
+    // moment with no synchronization needed beyond the atomic itself.
+    // checkDebug() atomically test-and-clears it (exchange) on every call
+    // that would otherwise skip: if it was set, this call falls through and
+    // actually invokes the Python hook instead, which re-derives and pushes
+    // fresh breakpoints/hookSkippable state via its own existing logic --
+    // clearing it here (not from Python) means there's no separate
+    // "acknowledge" round-trip needed. Never itself compared against
+    // anything else; nullptr (the default, and what a plain debugger
+    // attach that never wires this up leaves it at) simply means hook-
+    // skippable mode -- if ever engaged at all -- can't be interrupted this
+    // way, which is only actually reachable if a caller opts into
+    // hookSkippable=true above without also providing this.
+    void setFastContinueInterruptFlag(std::shared_ptr<std::atomic<bool>> flag) {
+        fastContinueInterrupt_ = std::move(flag);
     }
 
     // Checks whether a debug pause should happen at `node` (via the
@@ -952,6 +1002,16 @@ private:
     // setter leaves it at) means "no fast-continue exception" -- exactly
     // today's original, always-safe behavior.
     std::optional<std::unordered_map<std::string, std::set<int>>> fastContinueBreakpoints_;
+    // See setFastContinueBreakpoints's own doc comment for why this is a
+    // separate, narrower flag from fastContinueBreakpoints_ itself -- false
+    // (the default) whenever a debugger is attached without explicitly
+    // opting in, matching today's always-safe "checkDebug always calls the
+    // hook" behavior.
+    bool fastContinueHookSkippable_ = false;
+    // See setFastContinueInterruptFlag's own doc comment. nullptr (the
+    // default) means hook-skippable mode, if ever engaged, can't be
+    // interrupted from outside a hook call.
+    std::shared_ptr<std::atomic<bool>> fastContinueInterrupt_;
     // The root EvalContext resolveTree() was called with -- lets
     // checkDebug()'s locals snapshot fall back to top-level script
     // variables when paused inside a nested user call, the same way the

{openscad_cpp_evaluator-0.6.0 → openscad_cpp_evaluator-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "0.6.0"
+version = "0.7.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-0.6.0 → openscad_cpp_evaluator-0.7.0}/python/openscad_cpp_evaluator/__init__.py

@@ -13,11 +13,12 @@ from dataclasses import dataclass
 from typing import Optional
 
 from . import _openscad_cpp_evaluator as _ext
-from ._openscad_cpp_evaluator import ManifoldCache
+from ._openscad_cpp_evaluator import FastContinueSignal, ManifoldCache
 
 __all__ = [
     "Evaluator", "ColoredBody", "EvalError", "ParseError", "OscObject", "parse", "to_renderable_bodies",
     "ManifoldCache", "CallSiteProfile", "ProfileResult", "format_csg_tree", "bodies_from_dicts",
+    "FastContinueSignal",
 ]
 
 
@@ -317,6 +318,16 @@ class Evaluator:
     `return_hook`: fires after a user function/function-literal call
     computes its result, before returning -- (name, value, depth). Only
     meaningful with debug_hook set (the plain evaluate() path never calls it).
+    `fast_continue_signal`: an optional FastContinueSignal the caller keeps
+    across the whole debug session and calls `.request()` on (e.g. from
+    DebugSession.pause()/set_breakpoints(), BelfrySCAD's own debugger.py)
+    any time a checkDebug() checkpoint skipped via hook-skippable fast-
+    continue mode (see debug_hook's own `set_fast_continue(breakpoints,
+    hook_skippable)` kwarg) needs to stop skipping and consult Python
+    again -- there is no other way to reach a running debug_evaluate() call
+    from outside a hook invocation, since it runs as one single blocking
+    call with the GIL released for its duration. Only meaningful with
+    debug_hook set; ignored otherwise.
 
     After evaluate() returns, `self.csg_tree` (list of _CSGNode, see
     format_csg_tree), `self.dyn` (dict of every currently-visible
@@ -328,13 +339,14 @@ class Evaluator:
     """
 
     def __init__(self, echo_fn=None, debug_hook=None, error_break_fn=None, return_hook=None,
-                 manifold_cache=None, profile=False):
+                 manifold_cache=None, profile=False, fast_continue_signal=None):
         self._echo_fn = echo_fn
         self._debug_hook = debug_hook
         self._error_break_fn = error_break_fn
         self._return_hook = return_hook
         self._manifold_cache = manifold_cache
         self._profile = profile
+        self._fast_continue_signal = fast_continue_signal
         self.csg_tree = []
         self.profile_result = None
         self.dyn = {}
@@ -350,7 +362,7 @@ class Evaluator:
                     source_path, vp, self._debug_hook,
                     self._error_break_fn or (lambda *a, **k: None),
                     self._echo_fn or (lambda _m: None),
-                    self._manifold_cache, self._return_hook)
+                    self._manifold_cache, self._return_hook, self._fast_continue_signal)
                 self.csg_tree = []
                 self.profile_result = None
             else:

{openscad_cpp_evaluator-0.6.0 → openscad_cpp_evaluator-0.7.0}/src/bytecode_vm.cpp

@@ -664,10 +664,38 @@ Value runCompiledFunctionFromBound(Evaluator& ev, const CompiledChunk& chunk, co
 // *stack* growth (what this trampoline exists to eliminate) for heap
 // growth instead -- O(iteration count) EvalContext objects, bounded by
 // available RAM rather than a ~few-MB thread stack.
+namespace {
+// Tears a trampoline's own `chain` down back-to-front on EVERY exit path --
+// normal return OR exception unwind (recordTailCallHop's own recursion-guard
+// error is the exact case that matters: an infinite tail-recursive function
+// with no base case throws out of the loop entirely, bypassing any teardown
+// code placed after it). Relying on `chain` simply falling out of scope
+// instead is NOT equivalent: std::vector<T>'s own element-destruction order
+// is unspecified by the standard -- libc++ destroys back-to-front (matching
+// ScopeTrailStorage::popLevel's own "scan from the back" doc comment, which
+// assumes the level being popped is usually the most recently pushed one --
+// O(1) per pop that way), but libstdc++ destroys front-to-back, the
+// adversarial order for that same scan -- each pop then walks almost the
+// entire remaining vector, turning an intended O(N) teardown into a real,
+// measured O(N^2) (see issue #50: an N-scaling experiment plus a minimal
+// repro proving libc++/libstdc++ disagree on std::vector<T>::clear()'s
+// destruction order for identical source). Popping back-to-front explicitly,
+// via a destructor that always runs before `chain`'s own, is correct AND
+// O(N) on every standard library and every exit path, not just the ones
+// that happen to agree with libc++ and return normally.
+struct ChainTeardown {
+    std::vector<EvalContext>& chain;
+    ~ChainTeardown() {
+        while (!chain.empty()) chain.pop_back();
+    }
+};
+} // namespace
+
 Value runCompiledFunctionTrampoline(Evaluator& ev, const CompiledChunk& chunk,
                                      const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
                                      EvalContext& callerCtx, EvalContext& childCtx) {
     std::vector<EvalContext> chain{childCtx};
+    ChainTeardown teardown{chain};
     TailCallRequest req;
     Value result = runCompiledFunction(ev, chunk, arguments, callerCtx, chain.back(), &req);
     unsigned recursionGuard = 0;
@@ -689,6 +717,7 @@ Value runCompiledFunctionTrampoline(Evaluator& ev, const CompiledChunk& chunk,
 Value runCompiledFunctionFromBoundTrampoline(Evaluator& ev, const CompiledChunk& chunk, const BoundArgs& bound,
                                               EvalContext& childCtx) {
     std::vector<EvalContext> chain{childCtx};
+    ChainTeardown teardown{chain};
     TailCallRequest req;
     Value result = runCompiledFunctionFromBound(ev, chunk, bound, chain.back(), &req);
     unsigned recursionGuard = 0;

{openscad_cpp_evaluator-0.6.0 → openscad_cpp_evaluator-0.7.0}/src/debug_profile.cpp

@@ -77,6 +77,36 @@ std::vector<DebugFrame> Evaluator::buildDebugFrames(const EvalContext* ctx) cons
 void Evaluator::checkDebug(const oscad::ASTNode& node, EvalContext& ctx, bool forced, bool exprLevel) {
     if (!debugHooks_.debugHook) return;
     const oscad::Position& pos = node.position();
+    // Fast-continue's hook-skippable mode (setFastContinueBreakpoints' own
+    // doc comment): a plain "Continue" with no step pending needs the debug
+    // hook called ONLY for a line that actually has a breakpoint -- every
+    // other checkpoint is guaranteed to do nothing (no forced/breakpoint/
+    // step_hit condition on the Python side can possibly fire), so skip the
+    // call (and the childStatementPositions/getFrame setup below, all
+    // wasted work otherwise) entirely rather than crossing into Python just
+    // to be told "continue". `forced` (the explicit breakpoint() builtin)
+    // always bypasses this, matching its own "bypasses nothing" contract.
+    // Never applies to step_over/step_out (hookSkippable is false for those
+    // even though they also set a real breakpoints set, see the setter's
+    // own doc comment) or step_into/step_to_child (fastContinueBreakpoints_
+    // itself is nullopt then) -- both need every statement inspected.
+    if (!forced && fastContinueHookSkippable_ && fastContinueBreakpoints_) {
+        // Test-and-clear: if the main thread requested an interrupt (Pause,
+        // or a breakpoint edit -- see setFastContinueInterruptFlag's own doc
+        // comment) since the last checkDebug() call, this call falls
+        // through and actually invokes the hook below instead of skipping,
+        // regardless of whether THIS specific line has a breakpoint --
+        // that's what lets the hook's own logic (pause_now, or a freshly
+        // updated breakpoints dict) run at all in hook-skippable mode.
+        const bool interrupted =
+            fastContinueInterrupt_ && fastContinueInterrupt_->exchange(false, std::memory_order_acq_rel);
+        if (!interrupted) {
+            auto originIt = fastContinueBreakpoints_->find(pos.origin);
+            if (originIt == fastContinueBreakpoints_->end() || !originIt->second.count(pos.line)) {
+                return;
+            }
+        }
+    }
     const int depth = static_cast<int>(callStack_.size());
     const DebugFramesFn getFrame = [this, &ctx]() { return buildDebugFrames(&ctx); };
     lastChildrenPositions_ = childStatementPositions(node);

{openscad_cpp_evaluator-0.6.0 → openscad_cpp_evaluator-0.7.0}/src/user_calls.cpp

@@ -443,6 +443,32 @@ Value Evaluator::evalFunctionBodyTrampoline(const oscad::Expression& bodyExpr, E
     // dropped there) if memory ever measurably matters more than this
     // simpler all-or-nothing approach.
     std::vector<EvalContext> chain{ctx};
+    // Tears `chain` down back-to-front on EVERY exit path -- normal return
+    // OR exception unwind (recordTailCallHop's own recursion-guard error,
+    // below, is the exact case that matters: an infinite tail-recursive
+    // function with no base case throws out of this loop entirely,
+    // bypassing any teardown code placed after it). Relying on `chain`
+    // simply falling out of scope instead is NOT equivalent: std::vector<T>'s
+    // own element-destruction order is unspecified by the standard --
+    // libc++ destroys back-to-front (matching ScopeTrailStorage::popLevel's
+    // own "scan from the back" doc comment, which assumes the level being
+    // popped is usually the most recently pushed one -- O(1) per pop that
+    // way), but libstdc++ destroys front-to-back, the adversarial order for
+    // that same scan -- each pop then walks almost the entire remaining
+    // vector, turning an intended O(N) teardown into a real, measured
+    // O(N^2) (see issue #50: an N-scaling experiment plus a minimal repro
+    // proving libc++/libstdc++ disagree on std::vector<T>::clear()'s
+    // destruction order for identical source). Popping back-to-front
+    // explicitly, via a destructor that always runs before `chain`'s own,
+    // is correct AND O(N) on every standard library and every exit path,
+    // not just the ones that happen to agree with libc++ and return
+    // normally.
+    struct ChainTeardown {
+        std::vector<EvalContext>& chain;
+        ~ChainTeardown() {
+            while (!chain.empty()) chain.pop_back();
+        }
+    } teardown{chain};
     unsigned recursionGuard = 0;
     while (true) {
         auto result = simplifyTailStep(*expr, ctx);

{openscad_cpp_evaluator-0.6.0 → openscad_cpp_evaluator-0.7.0}/tests/test_debug_hooks.cpp

@@ -6,8 +6,12 @@
 #include <gtest/gtest.h>
 
 #include <algorithm>
+#include <atomic>
+#include <memory>
 #include <ostream>
+#include <set>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 using namespace oscadeval;
@@ -230,6 +234,122 @@ TEST(DebugHooks, NoHooksInstalledMeansZeroOverheadCodePathStillWorks) {
     EXPECT_EQ(e.bodies.size(), 1u);
 }
 
+// ---------------------------------------------------------------------------
+// Fast-continue's hook-skippable mode (issue found via BelfrySCAD's own
+// nurbs.scad-heavy debug session: 462k checkDebug() calls survived even
+// with per-function VM fast-continue fully engaged, since module/geometry
+// evaluation never compiles and every one of those still crossed into
+// Python just to be told "continue"). See setFastContinueBreakpoints's own
+// doc comment (evaluator.hpp) for the full contract.
+// ---------------------------------------------------------------------------
+
+TEST(DebugHooks, FastContinueHookSkippableSkipsCheckpointsWithNoMatchingBreakpoint) {
+    int calls = 0;
+    DebugHooks hooks;
+    hooks.debugHook = [&](int, int, bool, bool, const std::string&, const std::vector<CallStackFrame>&, const DebugFramesFn&) {
+        ++calls;
+        return DebugAction{};
+    };
+    Evaluator ev(EchoFn{}, nullptr, nullptr, hooks);
+    ev.setFastContinueBreakpoints(std::unordered_map<std::string, std::set<int>>{}, /*hookSkippable=*/true);
+    auto ast = parseSrc("cube(1);\ntranslate([1,0,0]) sphere(r=1,$fn=8);\necho(\"x\");");
+    auto scope = oscad::buildScopes(ast);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    ev.evaluate(ast, ctx);
+    // Same script as HookFiresOnceForEachStatementAtEveryNestingLevel (7
+    // checkpoints without fast-continue) -- with hook-skippable mode and no
+    // breakpoints anywhere, every single one is a plain C++ skip.
+    EXPECT_EQ(calls, 0);
+}
+
+TEST(DebugHooks, FastContinueHookSkippableStillFiresAtMatchingBreakpointLine) {
+    std::vector<int> firedLines;
+    DebugHooks hooks;
+    hooks.debugHook = [&](int line, int, bool, bool, const std::string&, const std::vector<CallStackFrame>&, const DebugFramesFn&) {
+        firedLines.push_back(line);
+        return DebugAction{};
+    };
+    Evaluator ev(EchoFn{}, nullptr, nullptr, hooks);
+    ev.setFastContinueBreakpoints(std::unordered_map<std::string, std::set<int>>{{"<string>", {2}}}, /*hookSkippable=*/true);
+    auto ast = parseSrc("cube(1);\ntranslate([1,0,0]) sphere(r=1,$fn=8);\necho(\"x\");");
+    auto scope = oscad::buildScopes(ast);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    ev.evaluate(ast, ctx);
+    // Every line-2 checkpoint (translate itself, its 3 expr-level [1,0,0]
+    // list elements, and the nested sphere child -- 5 total, matching
+    // HookFiresOnceForEachStatementAtEveryNestingLevel's own sequence)
+    // survives the skip; line 1 (cube) and line 3 (echo) have no
+    // breakpoint and are skipped entirely.
+    EXPECT_EQ(firedLines, (std::vector<int>{2, 2, 2, 2, 2}));
+}
+
+TEST(DebugHooks, FastContinueNotHookSkippableStillFiresEveryCheckpoint) {
+    int calls = 0;
+    DebugHooks hooks;
+    hooks.debugHook = [&](int, int, bool, bool, const std::string&, const std::vector<CallStackFrame>&, const DebugFramesFn&) {
+        ++calls;
+        return DebugAction{};
+    };
+    Evaluator ev(EchoFn{}, nullptr, nullptr, hooks);
+    // Mirrors step_over/step_out: a real (here, empty) breakpoints set is
+    // provided -- so chunkEligibleNow/useBytecodeVm still apply -- but
+    // hookSkippable stays false, since both need checkDebug() to keep
+    // calling into the hook on every statement so their own step_hit logic
+    // (line/depth comparison against the step's own starting point) can
+    // run; there is no way to decide that in advance.
+    ev.setFastContinueBreakpoints(std::unordered_map<std::string, std::set<int>>{}, /*hookSkippable=*/false);
+    auto ast = parseSrc("cube(1);\ntranslate([1,0,0]) sphere(r=1,$fn=8);\necho(\"x\");");
+    auto scope = oscad::buildScopes(ast);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    ev.evaluate(ast, ctx);
+    EXPECT_EQ(calls, 7); // unaffected -- same total as HookFiresOnceForEachStatementAtEveryNestingLevel
+}
+
+TEST(DebugHooks, FastContinueInterruptFlagForcesTheNextCheckpointThrough) {
+    std::vector<int> firedLines;
+    DebugHooks hooks;
+    hooks.debugHook = [&](int line, int, bool, bool, const std::string&, const std::vector<CallStackFrame>&, const DebugFramesFn&) {
+        firedLines.push_back(line);
+        return DebugAction{};
+    };
+    Evaluator ev(EchoFn{}, nullptr, nullptr, hooks);
+    ev.setFastContinueBreakpoints(std::unordered_map<std::string, std::set<int>>{}, /*hookSkippable=*/true);
+    // Pre-armed, as if Pause (or a breakpoint edit) was requested from the
+    // main thread before this run even started -- see
+    // setFastContinueInterruptFlag's own doc comment (evaluator.hpp) for
+    // why this exists: there is no other way to reach a running
+    // debug_evaluate() call from outside a hook invocation.
+    auto flag = std::make_shared<std::atomic<bool>>(true);
+    ev.setFastContinueInterruptFlag(flag);
+    auto ast = parseSrc("cube(1);\ntranslate([1,0,0]) sphere(r=1,$fn=8);\necho(\"x\");");
+    auto scope = oscad::buildScopes(ast);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    ev.evaluate(ast, ctx);
+    // Only the FIRST checkpoint (line 1, cube) fires -- checkDebug's own
+    // test-and-clear means the flag is consumed there, so every subsequent
+    // checkpoint goes back to being skipped normally (no breakpoints
+    // anywhere).
+    EXPECT_EQ(firedLines, (std::vector<int>{1}));
+    EXPECT_FALSE(flag->load());
+}
+
+TEST(DebugHooks, ForcedBreakpointBuiltinAlwaysFiresEvenInHookSkippableMode) {
+    int forcedCalls = 0, normalCalls = 0;
+    DebugHooks hooks;
+    hooks.debugHook = [&](int, int, bool forced, bool, const std::string&, const std::vector<CallStackFrame>&, const DebugFramesFn&) {
+        (forced ? forcedCalls : normalCalls)++;
+        return DebugAction{};
+    };
+    Evaluator ev(EchoFn{}, nullptr, nullptr, hooks);
+    ev.setFastContinueBreakpoints(std::unordered_map<std::string, std::set<int>>{}, /*hookSkippable=*/true);
+    auto ast = parseSrc("cube(1);\nbreakpoint();\nsphere(r=1,$fn=8);");
+    auto scope = oscad::buildScopes(ast);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    ev.evaluate(ast, ctx);
+    EXPECT_EQ(forcedCalls, 1); // breakpoint() always bypasses hook-skippable mode
+    EXPECT_EQ(normalCalls, 0); // cube/breakpoint()-as-statement/sphere: no breakpoint line matches, all skipped
+}
+
 // ---------------------------------------------------------------------------
 // Full parity with the Python reference's _check_debug call sites.
 //

{openscad_cpp_evaluator-0.6.0 → openscad_cpp_evaluator-0.7.0}/tests/test_tail_calls.cpp

@@ -19,6 +19,7 @@
 
 #include "test_helpers.hpp"
 
+#include <chrono>
 #include <gtest/gtest.h>
 
 using namespace oscadeval;
@@ -126,17 +127,6 @@ TEST(TailCalls, NonTailRecursionIsUnaffectedByTheTrampoline) {
 }
 
 TEST(TailCalls, InfiniteTailRecursionHitsTheIterationCapInsteadOfHanging) {
-#ifndef __APPLE__
-    // Skipped on non-Apple platforms: this drives the interpreter trampoline
-    // to the full 1,000,000-iteration recursion-guard cap, which is O(N)
-    // under Clang/libc++ (~1s) but a confirmed O(N^2) under GCC/libstdc++
-    // (and, empirically, MSVC's STL too) -- 25-50+ minutes instead of
-    // seconds. See https://github.com/BelfrySCAD/openscad_cpp_evaluator/issues/50
-    // for the full investigation (peak RSS/CPU/instruction-count evidence
-    // and an N-scaling experiment proving the asymptotic-complexity gap).
-    // Re-enable once that's root-caused and fixed.
-    GTEST_SKIP() << "O(N^2) under this toolchain -- see issue #50";
-#endif
     ScopedVm vm(false);
     Evaluator ev;
     auto ast = parseSrc("function loop(n) = loop(n + 1);\nresult = loop(0);");
@@ -150,11 +140,6 @@ TEST(TailCalls, InfiniteTailRecursionHitsTheIterationCapInsteadOfHanging) {
 }
 
 TEST(TailCalls, InfiniteTailRecursionErrorMentionsTheFunctionName) {
-#ifndef __APPLE__
-    // See InfiniteTailRecursionHitsTheIterationCapInsteadOfHanging's own
-    // comment just above -- same O(N^2)-under-this-toolchain issue (#50).
-    GTEST_SKIP() << "O(N^2) under this toolchain -- see issue #50";
-#endif
     ScopedVm vm(false);
     Evaluator ev;
     auto ast = parseSrc("function loop(n) = loop(n + 1);\nresult = loop(0);");
@@ -169,6 +154,34 @@ TEST(TailCalls, InfiniteTailRecursionErrorMentionsTheFunctionName) {
     }
 }
 
+TEST(TailCalls, InfiniteTailRecursionHitsTheCapInBoundedWallTime) {
+    // Regression tripwire for issue #50: evalFunctionBodyTrampoline's own
+    // `chain` (every hop's EvalContext, kept alive for $-var ancestry --
+    // see its own doc comment) used to rely on std::vector<EvalContext>'s
+    // OWN destructor to tear itself down, whose element-destruction order
+    // is unspecified by the standard. libstdc++ (GCC) and, per CI evidence,
+    // MSVC destroy front-to-back -- the adversarial order for
+    // ScopeTrailStorage::popLevel's "scan from the back" optimization
+    // (its own doc comment), turning an intended O(N) teardown into a
+    // real, measured O(N^2): the exact same 1,000,000-iteration script
+    // below took 25-50+ minutes on GCC/MSVC CI runners before the fix
+    // (an explicit back-to-front teardown, immune to the underlying
+    // vector's own unspecified order), vs ~1s on Clang/libc++ throughout.
+    // ponytail: generous fixed ceiling, not a strict perf target -- trips
+    // only on a real regression (this exact O(N^2) reintroduced), not
+    // machine noise; raise if a slower CI runner ever needs it.
+    ScopedVm vm(false);
+    Evaluator ev;
+    auto ast = parseSrc("function loop(n) = loop(n + 1);\nresult = loop(0);");
+    auto scope = oscad::buildScopes(ast);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    const auto start = std::chrono::steady_clock::now();
+    EXPECT_THROW(ev.resolveTree(ast, ctx), EvalError);
+    const double ms = std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start).count();
+    constexpr double kCeilingMs = 30000.0;
+    EXPECT_LT(ms, kCeilingMs) << "took " << ms << "ms -- possible O(N^2) regression, see issue #50";
+}
+
 TEST(TailCalls, ErrorThrownDeepInATailChainProducesABoundedTrace) {
     ScopedVm vm(false);
     Evaluator ev;