openscad-cpp-evaluator 1.29.0__tar.gz → 1.30.0__tar.gz

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/CLAUDE.md

@@ -1569,6 +1569,21 @@ than the current pause point). Ported identically (same qualifier syntax, same e
 - `tools/cli/main.cpp` — a 3-line wrapper: builds `args` from `argv`, calls `runCli(args)` with the
   real `std::cin`/`std::cout`/`std::cerr`, returns its exit code.
 
+## Cancel and the module recursion limit (#554)
+
+- **`Evaluator::setCancelFlag(shared_ptr<atomic<bool>>)`** -- bound as `CancelSignal` /
+  `Evaluator(cancel_signal=...)`. Once the flag is set, from any thread, evaluate() throws
+  `EvalError("Render cancelled")` at its next check: the top of `checkDebug` (every interpreted
+  statement and loop pass already calls it, hooks or not), `pollCancel()` every 1,024 VM
+  instructions in `driveVm`, and each top-level node in `generateTreeImpl`. A single Manifold op
+  already under way still finishes. Sticky, unlike `setFastContinueInterruptFlag`'s test-and-clear.
+  A host's echo callback was the only way in before, so a script that printed nothing could not
+  be stopped at all.
+- **`kMaxModuleCallDepth = 16384`** nested user module calls, checked in `enterUserCall` against
+  `moduleCallDepth_` -- "Recursion detected calling module 'm'", OpenSCAD's wording. Functions
+  keep `kMaxVmCallStackDepth` (1e6). `module m() { m(); }` went from 4.2 s / 3.3 GB to stopping
+  at once; OpenSCAD 2026.02.01 stops the same script near 14,000.
+
 ## Coverage
 
 `Evaluator(coverage=true)` records which parts of a run's source actually executed and

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/bindings/module.cpp

@@ -503,10 +503,22 @@ nb::object coverageResultToPy(const std::optional<oscadeval::CoverageResult>& cr
     return result;
 }
 
+// A render's Cancel: .request() from any thread makes the evaluate() it was
+// passed to throw EvalError("Render cancelled") at its next check -- see
+// Evaluator::setCancelFlag. One per render; it is never cleared.
+class CancelSignal {
+public:
+    void request() { flag_->store(true, std::memory_order_relaxed); }
+    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);
+};
+
 nb::object evaluate(const std::string& path, nb::dict viewportParams,
                      std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, bool profile,
                      bool generate, bool strictCommas, bool coverage, bool keepMinuendColor,
-                     double flatPreviewHeight) {
+                     double flatPreviewHeight, CancelSignal* cancelSignal) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
@@ -535,6 +547,7 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
             oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(program.nodes, path, logFn);
             oscadeval::Evaluator ev(logFn, nullptr, manifoldCache, oscadeval::DebugHooks{}, profile, coverage);
             ev.keepMinuendColor = keepMinuendColor;
+            if (cancelSignal) ev.setCancelFlag(cancelSignal->flag());
             ev.setUsedFileGlobals(used.usedFileGlobals);
             oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
             std::vector<oscadeval::ColoredBody> raw = ev.evaluate(used.processedNodes, ctx, vp, generate);
@@ -924,6 +937,10 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
 
     // See FastContinueSignal's own doc comment, above -- only a
     // constructor and request() are ever called from Python.
+    nb::class_<CancelSignal>(m, "CancelSignal")
+        .def(nb::init<>())
+        .def("request", &CancelSignal::request);
+
     nb::class_<FastContinueSignal>(m, "FastContinueSignal")
         .def(nb::init<>())
         .def("request", &FastContinueSignal::request);
@@ -993,7 +1010,7 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
     m.def("evaluate", &evaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("manifold_cache") = nullptr,
           nb::arg("profile") = false, nb::arg("generate") = true, nb::arg("strict_commas") = false,
           nb::arg("coverage") = false, nb::arg("keep_minuend_color") = false,
-          nb::arg("flat_preview_height") = oscadeval::kTopLevel2dHeight,
+          nb::arg("flat_preview_height") = oscadeval::kTopLevel2dHeight, nb::arg("cancel_signal") = nullptr,
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit, "
           "geometry, coverage_result).\n"
           "coverage=True records which statements, branch arms and bodies ran: coverage_result is a dict "
@@ -1006,7 +1023,9 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "are populated.\n\n"
           "strict_commas=True makes a trailing comma in a call argument list or a let/for "
           "assignment list a syntax error, as OpenSCAD 2021.01 did. List literals and parameter "
-          "declarations keep theirs, which 2021.01 accepted too.");
+          "declarations keep theirs, which 2021.01 accepted too.\n\n"
+          "cancel_signal: a CancelSignal whose request(), from any thread, stops this call with "
+          "EvalError('Render cancelled') -- even for a script that prints nothing.");
     m.def("parse_decls", &parseDecls, nb::arg("path"),
           "Parse a .scad file; return top-level declaration (namespace, name, start, end, line, column, origin) tuples.");
     m.def("strip_slivers", &stripSliversPy, nb::arg("verts"), nb::arg("tris"),

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -703,6 +703,23 @@ public:
         fastContinueInterrupt_ = std::move(flag);
     }
 
+    // A host's Cancel button. Set from any thread; the running evaluate()
+    // then throws EvalError("Render cancelled") at its next check: every
+    // interpreted statement and loop pass (checkDebug, which all of them
+    // already call), every 1024th VM instruction, and between top-level
+    // generate-pass nodes. A single Manifold operation already under way
+    // still runs to its end. Before this existed a host could only stop a
+    // script from its echo callback, so one that printed nothing ran to
+    // completion however long that took (#554). Sticky: never cleared here.
+    void setCancelFlag(std::shared_ptr<std::atomic<bool>> flag) { cancel_ = std::move(flag); }
+    void checkCancel() const {
+        if (cancel_ && cancel_->load(std::memory_order_relaxed)) throw EvalError("Render cancelled");
+    }
+    // The VM's per-instruction form: one relaxed load per 1024 instructions.
+    void pollCancel() {
+        if (cancel_ && (++cancelTicks_ & 0x3FF) == 0) checkCancel();
+    }
+
     // Checks whether a debug pause should happen at `node` (via the
     // injected DebugHooks::debugHook, if any -- a no-op otherwise),
     // applying any `mods` the hook returns to `ctx.let_` and throwing
@@ -1759,6 +1776,16 @@ public:
     // recalibrating for real.
     static constexpr size_t kMaxVmCallStackDepth = 1'000'000;
 
+    // Nested user MODULE calls, of any modules. Functions keep
+    // kMaxVmCallStackDepth: a deep function recursion builds nothing, but a
+    // module frame holds its whole subtree, so `module m() { m(); }` used
+    // to run to a million frames and 3.3 GB before stopping. OpenSCAD stops
+    // the same script at ~14,000 ("Recursion detected calling module"),
+    // 45 MB; this is that order, and far past any real library (BOSL2
+    // nests tens deep). Checked in enterUserCall, which every module call
+    // -- interpreted or compiled -- goes through (#554).
+    static constexpr int kMaxModuleCallDepth = 16384;
+
     // Counts native C++ nesting of driveVm itself -- NOT logical call
     // depth (that's vmCallStack_.size()/callStack_.size(), both of which
     // grow just as much for a pure VM-internal Op::CallModule hop, which
@@ -2074,6 +2101,9 @@ private:
     // default) means hook-skippable mode, if ever engaged, can't be
     // interrupted from outside a hook call.
     std::shared_ptr<std::atomic<bool>> fastContinueInterrupt_;
+    // See setCancelFlag. nullptr (the default): nothing can cancel.
+    std::shared_ptr<std::atomic<bool>> cancel_;
+    unsigned cancelTicks_ = 0;
     // 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-1.29.0 → openscad_cpp_evaluator-1.30.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/python/openscad_cpp_evaluator/__init__.py

@@ -13,12 +13,12 @@ from dataclasses import dataclass, field
 from typing import Optional
 
 from . import _openscad_cpp_evaluator as _ext
-from ._openscad_cpp_evaluator import FastContinueSignal, ManifoldCache
+from ._openscad_cpp_evaluator import CancelSignal, FastContinueSignal, ManifoldCache
 
 __all__ = [
     "Evaluator", "ColoredBody", "EvalError", "ParseError", "OscObject", "parse", "to_renderable_bodies",
     "ManifoldCache", "CallSiteProfile", "ProfileResult", "format_csg_tree", "bodies_from_dicts",
-    "FastContinueSignal", "parse_ast", "parse_ast_string", "format_source",
+    "CancelSignal", "FastContinueSignal", "parse_ast", "parse_ast_string", "format_source",
     "check_mesh", "strip_slivers",
     "export_model", "export_extensions", "list_fonts",
 ]
@@ -565,7 +565,7 @@ class Evaluator:
 
     def __init__(self, echo_fn=None, debug_hook=None, error_break_fn=None, return_hook=None,
                  manifold_cache=None, profile=False, fast_continue_signal=None, coverage=False,
-                 keep_minuend_color=False, flat_preview_height=1.0):
+                 keep_minuend_color=False, flat_preview_height=1.0, cancel_signal=None):
         self._echo_fn = echo_fn
         self._debug_hook = debug_hook
         self._error_break_fn = error_break_fn
@@ -574,6 +574,11 @@ class Evaluator:
         self._profile = profile
         self._fast_continue_signal = fast_continue_signal
         self._coverage = coverage
+        # A CancelSignal: request() it from any thread and a running
+        # evaluate() raises EvalError("Render cancelled") -- the only way to
+        # stop a script that prints nothing. Plain path only; the debugger
+        # has its own stop.
+        self._cancel_signal = cancel_signal
         # keep_minuend_color=True: difference() paints the faces a
         # subtrahend exposes with the MINUEND's colour rather than the
         # subtrahend's (or the cut green). A viewer option; see
@@ -640,7 +645,7 @@ class Evaluator:
                  dyn_explicit, geometry, coverage_result) = _ext.evaluate(
                     source_path, vp, self._manifold_cache, self._profile, generate,
                     strict_commas, self._coverage, self._keep_minuend_color,
-                    self._flat_preview_height)
+                    self._flat_preview_height, self._cancel_signal)
                 # The evaluated bodies, still on the C++ side. Stashed like
                 # csg_tree/profile_result rather than returned, so
                 # evaluate()'s own 2-tuple result is unchanged -- callers

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/src/bytecode_vm.cpp

@@ -609,6 +609,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                 continue;
             }
 
+            ev.pollCancel();
             const Instruction& ins = f.code[f.pc];
             EvalContext& ctx = f.ctxChain.back();
             switch (ins.op) {

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/src/csg_generate.cpp

@@ -35,6 +35,7 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
     const auto& dispatch = generateDispatch();
     for (CSGNode* nodePtr : tree) {
         CSGNode& node = *nodePtr;
+        checkCancel();
 
         // ManifoldCache lookup: node.uncacheable (rands() taint, set
         // during resolve -- see csg_resolve.cpp) always forces a miss,

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/src/debug_profile.cpp

@@ -104,6 +104,7 @@ void Evaluator::checkDebug(const oscad::ASTNode& node, EvalContext& ctx, bool fo
     // injecting stops the user never wrote and corrupting lastStmtByDepth_'s
     // duplicate-collapse state below. Rides the existing null-hook
     // short-circuit so it costs nothing on the normal path.
+    checkCancel(); // every interpreted statement and loop pass comes through here
     if (measuring_ || !debugHooks_.debugHook) return;
     const oscad::Position& pos = node.position();
     const size_t stmtDepth = callStack_.size();

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/src/user_calls.cpp

@@ -733,6 +733,9 @@ Evaluator::UserCallHandle Evaluator::enterUserCall(const std::string& name, cons
         error("Recursion too deep while calling " + std::string(isModule ? "module" : "function") + " '" + name + "'",
               declNode);
     }
+    if (isModule && moduleCallDepth_ >= kMaxModuleCallDepth) {
+        error("Recursion detected calling module '" + name + "'", declNode);
+    }
     UserCallHandle h;
     h.kind = kind;
     h.declNode = &declNode;

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/tests/test_control_flow.cpp

@@ -3,6 +3,10 @@
 #include "test_helpers.hpp"
 
 #include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <memory>
+#include <thread>
 #include <gtest/gtest.h>
 
 using namespace oscadeval;
@@ -1204,6 +1208,101 @@ TEST(UserModule, DeepNonTailRecursionHitsAControlledErrorInterpreted) {
     }
 }
 
+// #554: a module recursing without end used to run to kMaxVmCallStackDepth
+// (a million frames, 3.3 GB); OpenSCAD stops it near 14,000.
+TEST(UserModule, EndlessModuleRecursionStopsAtTheModuleDepthLimit) {
+    ScopedVm vm(true);
+    try {
+        evalSrc("module m() { m(); }\nm();");
+        FAIL() << "expected EvalError";
+    } catch (const EvalError& e) {
+        EXPECT_NE(std::string(e.what()).find("Recursion detected calling module 'm'"), std::string::npos);
+    }
+}
+
+TEST(UserModule, ModuleRecursionJustUnderTheLimitSucceeds) {
+    ScopedVm vm(true);
+    Evaluated e = evalSrc("module recur(n) { if (n>0) recur(n-1); else cube(1); }\n"
+                          "recur(" + std::to_string(Evaluator::kMaxModuleCallDepth - 2) + ");");
+    EXPECT_EQ(e.bodies.size(), 1u);
+}
+
+// -- Evaluator::setCancelFlag (#554) ---------------------------------------
+
+namespace {
+std::string cancelledMessage(const std::string& src, std::shared_ptr<std::atomic<bool>> flag) {
+    auto ast = parseSrc(src);
+    auto scope = oscad::buildScopes(ast);
+    Evaluator ev;
+    ev.setCancelFlag(std::move(flag));
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    try {
+        ev.evaluate(ast, ctx);
+    } catch (const EvalError& e) {
+        return e.what();
+    }
+    return "";
+}
+} // namespace
+
+TEST(Cancel, AnArmedFlagStopsASilentScriptCompiledAndInterpreted) {
+    // Prints nothing, so a host's echo callback never gets a chance to stop it.
+    const std::string src = "function f(n) = n <= 0 ? 0 : 1 + f(n - 1);\n"
+                            "x = [for (i = [0:200]) f(20)];\ncube(1);";
+    for (bool useVm : {true, false}) {
+        ScopedVm vm(useVm);
+        EXPECT_EQ(cancelledMessage(src, std::make_shared<std::atomic<bool>>(true)), "Render cancelled") << useVm;
+        EXPECT_EQ(cancelledMessage(src, std::make_shared<std::atomic<bool>>(false)), "") << useVm;
+    }
+}
+
+TEST(Cancel, StopsTheGeneratePass) {
+    auto ast = parseSrc("cube(1);\nsphere(1);");
+    auto scope = oscad::buildScopes(ast);
+    Evaluator ev;
+    auto flag = std::make_shared<std::atomic<bool>>(false);
+    ev.setCancelFlag(flag);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    auto tree = ev.resolveTree(ast, ctx);
+    flag->store(true);
+    EXPECT_THROW(ev.generateTree(tree), EvalError);
+}
+
+TEST(Cancel, AnotherThreadStopsARunningExpression) {
+    ScopedVm vm(true);
+    // ~minutes of silent work uncancelled; must stop within moments of the request.
+    auto flag = std::make_shared<std::atomic<bool>>(false);
+    std::thread canceller([flag] {
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        flag->store(true);
+    });
+    const auto t0 = std::chrono::steady_clock::now();
+    const std::string msg = cancelledMessage("function f(n) = n <= 0 ? 0 : 1 + f(n - 1);\n"
+                                             "x = [for (i = [0:99999], j = [0:9999]) f(20)];", flag);
+    const auto elapsed = std::chrono::steady_clock::now() - t0;
+    canceller.join();
+    EXPECT_EQ(msg, "Render cancelled");
+    EXPECT_LT(elapsed, std::chrono::seconds(2));
+}
+
+TEST(Cancel, AnotherThreadStopsARunningScriptCompiledAndInterpreted) {
+    for (bool useVm : {true, false}) {
+        ScopedVm vm(useVm);
+        auto flag = std::make_shared<std::atomic<bool>>(false);
+        std::thread canceller([flag] {
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+            flag->store(true);
+        });
+        const auto t0 = std::chrono::steady_clock::now();
+        const std::string msg = cancelledMessage("module m(n) { if (n > 0) m(n - 1); }\n"
+                                                 "for (i = [0:99999], j = [0:9999]) m(20);", flag);
+        const auto elapsed = std::chrono::steady_clock::now() - t0;
+        canceller.join();
+        EXPECT_EQ(msg, "Render cancelled") << useVm;
+        EXPECT_LT(elapsed, std::chrono::seconds(2)) << useVm;
+    }
+}
+
 TEST(UserModule, DefaultParameterApplied) {
     Evaluated e = evalSrc("module box(size=5) { cube(size); }\nbox();");
     manifold::Box bbox = e.bodies[0].body->BoundingBox();

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/tests/test_csg_tree.cpp

@@ -189,12 +189,13 @@ TEST(CsgTree, LinearExtrudeNestsItsChildUnderneath) {
 // caught DURING resolve, at tree-construction time, not by a later walk.
 
 TEST(CsgTree, BareModuleRecursionStaysTreeDepthOneRegardlessOfCallDepth) {
-    ScopedVm vm(true); // 20,000-deep recursion needs the compiled path
-    // Splicing collapses every level away -- 20,000 calls deep, but the
+    ScopedVm vm(true); // 16,000-deep recursion needs the compiled path
+    // Splicing collapses every level away -- 16,000 calls deep (just under
+    // kMaxModuleCallDepth), but the
     // FINAL tree is still just the one leaf cube. Proves the new guard
     // (kMaxCsgTreeDepth = 2000) doesn't false-positive on the shape Stage
     // 2's own deep-recursion tests already rely on.
-    Evaluated e = evalSrc("module recur(n) { if (n>0) recur(n-1); else cube(1); }\nrecur(20000);");
+    Evaluated e = evalSrc("module recur(n) { if (n>0) recur(n-1); else cube(1); }\nrecur(16000);");
     ASSERT_EQ(e.tree.size(), 1u);
     EXPECT_EQ(e.tree[0]->kind, "cube");
     EXPECT_EQ(e.tree[0]->treeDepth, 1);

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/tests/test_python_bindings.py

@@ -1155,3 +1155,25 @@ print("errors:", errors); sys.exit(1 if errors else 0)
     src.write_text("".join(f"x{i} = [{i}, {i} + 1, \"s{i}\"];\n" for i in range(200)))
     r = subprocess.run([sys.executable, "-c", code, str(src)], capture_output=True, text=True, timeout=300)
     assert r.returncode == 0, (r.returncode, r.stdout[-500:], r.stderr[-1500:])
+
+
+def test_a_cancel_signal_stops_a_silent_script_from_another_thread(tmp_path):
+    """#554: a script that prints nothing never reaches a host's echo
+    callback, the only place Cancel could act before. CancelSignal.request()
+    reaches the evaluator directly; evaluate() releases the GIL, so the
+    requesting thread gets to run while it works."""
+    import threading
+    import time
+    from openscad_cpp_evaluator import CancelSignal, EvalError
+    src = tmp_path / "silent.scad"
+    src.write_text("function f(n) = n <= 0 ? 0 : 1 + f(n - 1);\n"
+                   "x = [for (i = [0:99999], j = [0:9999]) f(20)];\n")
+    signal = CancelSignal()
+    threading.Timer(0.1, signal.request).start()
+    t0 = time.perf_counter()
+    try:
+        Evaluator(cancel_signal=signal).evaluate(str(src))
+        raise AssertionError("expected EvalError")
+    except EvalError as e:
+        assert "Render cancelled" in str(e), e
+    assert time.perf_counter() - t0 < 5

{openscad_cpp_evaluator-1.29.0 → openscad_cpp_evaluator-1.30.0}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.29.0"
+version = "1.30.0"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },