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

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

@@ -819,9 +819,15 @@ grep for `ponytail:`.
   geometric-correctness test in Phase 3, not a hypothetical.
 - `include/openscad_cpp_evaluator/segments.hpp`, `src/builtins/segments.cpp` — `$fn`/`$fa`/`$fs` ->
   circular-shape segment count (`fnSegments`/`fnSegmentsFromCtx`), used by sphere/cylinder/circle.
-- `include/openscad_cpp_evaluator/css_colors.hpp`, `src/css_colors.cpp` — the 148-entry CSS/SVG
-  color-name table (mechanically ported from the Python reference's own generated table) plus hex
-  parsing, backing `color()`'s string-name argument.
+- `include/openscad_cpp_evaluator/css_colors.hpp`, `src/css_colors.cpp`, `src/xkcd_colors.{hpp,cpp}` —
+  `parseColor`, OpenSCAD's `parse_color` (ColorUtil.cc): CSS Color Level 4 names (148, with
+  `rebeccapurple`) plus `transparent` (alpha 0), `"xkcd:<name>"` over the 949 xkcd survey names
+  (generated from OpenSCAD's `XkcdColors.h`, CC0), all case-insensitive, then strict `#rgb` /
+  `#rgba` / `#rrggbb` / `#rrggbbaa`. `color()` (`src/builtins/color.cpp`) follows `builtin_color`:
+  an unreadable string warns `Unable to parse color "…"` and sets NO colour (children keep their
+  own, or the outer one) -- it used to draw white; a list fills missing channels with 1 and warns
+  outside 0..1; a numeric `alpha` replaces any alpha, a 4-list's included (checked on the 2026.02.01
+  binary's 3MF export). `cssColor` (white fallback) is only for SVG/PDF export options.
 - `src/builtins/{primitives_2d,primitives_3d,transforms,color,booleans,modifiers,control}.cpp` —
   one file per builtin group, each a `ResolveFn`/`GenerateFn` pair (or a few, where several builtin
   names share one pair — circle/square/polygon, translate/rotate/scale/mirror/multmatrix/resize,
@@ -1563,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.28.6 → openscad_cpp_evaluator-1.30.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.28.6 → 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.30.0/include/openscad_cpp_evaluator/css_colors.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <array>
+#include <optional>
+#include <string>
+
+namespace oscadeval {
+
+// A colour string as OpenSCAD's parse_color reads it (ColorUtil.cc):
+// a CSS Color Level 4 name or OpenSCAD's "transparent" (alpha 0), an
+// "xkcd:<name>" from the xkcd colour survey, all case-insensitive; else
+// "#rgb", "#rgba", "#rrggbb" or "#rrggbbaa". Nothing if it is none of
+// those -- color() then warns and leaves its children's colour alone.
+std::optional<std::array<double, 4>> parseColor(const std::string& text);
+
+// parseColor with the alpha replaced, and white for anything unparseable.
+// For export options (SVG/PDF fill and stroke), which have no warning path.
+std::array<double, 4> cssColor(const std::string& name, double alpha = 1.0);
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.28.6 → 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.28.6 → 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.28.6"
+version = "1.30.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.28.6 → 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.28.6 → openscad_cpp_evaluator-1.30.0}/src/CMakeLists.txt

@@ -11,6 +11,7 @@ add_library(openscad_cpp_evaluator STATIC
   bytecode_vm.cpp
   colored_body.cpp
   css_colors.cpp
+  xkcd_colors.cpp
   csg_resolve.cpp
   coverage.cpp
   csg_generate.cpp

{openscad_cpp_evaluator-1.28.6 → openscad_cpp_evaluator-1.30.0}/src/builtins/color.cpp

@@ -1,38 +1,63 @@
 #include "builtins.hpp"
 
+#include <cstdio>
+
 #include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/css_colors.hpp"
 #include "openscad_cpp_evaluator/evaluator.hpp"
 
 namespace oscadeval {
 
-// color(c = [1,1,1,1], alpha = 1) -- c is a CSS/hex color name, an [r,g,b]
-// (alpha from the separate `alpha` argument), or an [r,g,b,a] (alpha taken
-// from the list itself, the separate `alpha` argument is ignored in that
-// case). Sets the color on ctx for every descendant statement. Mirrors
-// _resolve_color/_generate_color.
+// color(c, alpha), as OpenSCAD's builtin_color (ColorNode.cc):
+// - a string goes through parseColor (CSS / "xkcd:" names, hex with or
+//   without alpha); one it cannot read warns "Unable to parse color" and
+//   leaves the children's colour alone -- inherited from outside, not reset;
+// - a list fills [r, g, b, a] in order, 1.0 for any it lacks, warning on a
+//   component outside 0..1;
+// - a numeric `alpha` then replaces the alpha of whatever `c` gave -- even a
+//   4-element list's, and even "#rrggbbaa"'s -- warning when outside 0..1;
+// - anything else for `c`, or no `c` at all, sets no colour (OpenSCAD's
+//   unset Color4f is (-1,-1,-1,-1), which is not a colour).
+
+namespace {
+std::string oneDecimal(double v) {
+    char buf[64];
+    std::snprintf(buf, sizeof buf, "%.1f", v);
+    return buf;
+}
+} // namespace
 
 BuiltinWrapParams computeColorParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
-    const Value defaultC =
-        Value{std::make_shared<const ValueList>(ValueList{{Value{1.0}, Value{1.0}, Value{1.0}, Value{1.0}}})};
-    Value cArg = getArg(args, 0, "c", defaultC);
-    const double alpha = toDoubleLenient(getArg(args, 1, "alpha", Value{1.0}));
+    const Value cArg = getArg(args, 0, "c");
+    const Value alphaArg = getArg(args, 1, "alpha");
 
-    std::array<double, 4> rgba{1.0, 1.0, 1.0, 1.0};
+    std::optional<std::array<double, 4>> rgba;
     if (const std::string* s = std::get_if<std::string>(&cArg)) {
-        rgba = cssColor(*s, alpha);
+        rgba = parseColor(*s);
+        if (!rgba) ev.warn("Unable to parse color \"" + *s + "\"", &node.position());
     } else if (const ListPtr* l = std::get_if<ListPtr>(&cArg); l && *l) {
         const auto& items = (*l)->items;
-        if (items.size() == 3) {
-            rgba = {toDoubleLenient(items[0]), toDoubleLenient(items[1]), toDoubleLenient(items[2]), alpha};
-        } else if (items.size() >= 4) {
-            rgba = {toDoubleLenient(items[0]), toDoubleLenient(items[1]), toDoubleLenient(items[2]),
-                     toDoubleLenient(items[3])};
+        std::array<double, 4> c{1.0, 1.0, 1.0, 1.0};
+        for (size_t i = 0; i < 4; ++i) {
+            if (i < items.size()) c[i] = toDoubleLenient(items[i]);
+            if (c[i] > 1 || c[i] < 0)
+                ev.warn("color() expects numbers between 0.0 and 1.0. Value of " + oneDecimal(c[i]) +
+                            " is out of range",
+                        &node.position());
         }
+        rgba = c;
+    }
+    if (const double* a = std::get_if<double>(&alphaArg)) {
+        if (rgba) (*rgba)[3] = *a;
+        if (*a < 0.0 || *a > 1.0)
+            ev.warn("color() expects alpha between 0.0 and 1.0. Value of " + oneDecimal(*a) + " is out of range",
+                    &node.position());
     }
 
-    EvalContext childCtx = effCtx.childCtx(nullptr, std::optional<std::array<double, 4>>(rgba));
+    // No colour: the child context inherits the outer one (childCtx's
+    // nullopt), and generateColor passes the children through untouched.
+    EvalContext childCtx = effCtx.childCtx(nullptr, rgba);
     CSGParams params;
     params["rgba"] = colorToValue(rgba);
     return BuiltinWrapParams{std::move(params), std::move(childCtx)};
@@ -70,6 +95,8 @@ std::shared_ptr<const std::vector<ColoredBody>> recolorParts(const std::vector<C
 std::vector<ColoredBody> generateColor(Evaluator& ev, const CSGParams& params,
                                         const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode&) {
     const auto rgba = valueToColor(params.at("rgba"));
+    // An unreadable colour sets none: the children keep their own.
+    if (!rgba) return flattenCsgTree(children);
     std::vector<ColoredBody> result;
     for (ColoredBody b : flattenCsgTree(children)) {
         b.color = rgba;

{openscad_cpp_evaluator-1.28.6 → 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.28.6 → 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.28.6 → openscad_cpp_evaluator-1.30.0}/src/css_colors.cpp

@@ -1,16 +1,18 @@
 #include "openscad_cpp_evaluator/css_colors.hpp"
+#include "xkcd_colors.hpp"
 
 #include <cctype>
+#include <optional>
 #include <unordered_map>
 
 namespace oscadeval {
 
 namespace {
 
-// Generated (not hand-transcribed) from the Python reference's own
-// _css_colors.py, itself generated from a live PySide6 install -- see that
-// file's docstring for the regeneration recipe and the Qt-vs-CSS3 list
-// discrepancy (British-spelling aliases included, `rebeccapurple` excluded).
+// Originally generated from the Python reference's _css_colors.py (itself
+// from a live PySide6 install). Now OpenSCAD's own WebColors.h list: every
+// RGB here matches it, `rebeccapurple` (CSS Color Level 4) is added, and
+// `transparent`, which needs an alpha of 0, is handled in parseColor.
 const std::unordered_map<std::string, std::array<double, 3>>& colorTable() {
     static const std::unordered_map<std::string, std::array<double, 3>> table = {
         {"aliceblue", {0.9411764740943909, 0.9725490212440491, 1.0}},
@@ -132,6 +134,7 @@ const std::unordered_map<std::string, std::array<double, 3>>& colorTable() {
         {"plum", {0.8666666746139526, 0.6274510025978088, 0.8666666746139526}},
         {"powderblue", {0.6901960968971252, 0.8784313797950745, 0.9019607901573181}},
         {"purple", {0.501960813999176, 0.0, 0.501960813999176}},
+        {"rebeccapurple", {0.4, 0.2, 0.6}},
         {"red", {1.0, 0.0, 0.0}},
         {"rosybrown", {0.7372549176216125, 0.5607843399047852, 0.5607843399047852}},
         {"royalblue", {0.2549019753932953, 0.4117647111415863, 0.8823529481887817}},
@@ -153,7 +156,6 @@ const std::unordered_map<std::string, std::array<double, 3>>& colorTable() {
         {"teal", {0.0, 0.501960813999176, 0.501960813999176}},
         {"thistle", {0.8470588326454163, 0.7490196228027344, 0.8470588326454163}},
         {"tomato", {1.0, 0.38823530077934265, 0.27843138575553894}},
-        {"transparent", {0.0, 0.0, 0.0}},
         {"turquoise", {0.250980406999588, 0.8784313797950745, 0.8156862854957581}},
         {"violet", {0.9333333373069763, 0.5098039507865906, 0.9333333373069763}},
         {"wheat", {0.9607843160629272, 0.8705882430076599, 0.7019608020782471}},
@@ -171,38 +173,44 @@ std::string toLower(const std::string& s) {
     return r;
 }
 
-int hexDigit(char c) {
-    if (c >= '0' && c <= '9') return c - '0';
-    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
-    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
-    return 0;
+// OpenSCAD's parse_hex_color (ColorUtil.cc): "#rgb", "#rgba", "#rrggbb" or
+// "#rrggbbaa", every character after '#' a hex digit, or nothing at all.
+std::optional<std::array<double, 4>> parseHex(const std::string& hex) {
+    const bool shortForm = hex.size() == 4 || hex.size() == 5;
+    const bool longForm = hex.size() == 7 || hex.size() == 9;
+    if ((!shortForm && !longForm) || hex[0] != '#') return std::nullopt;
+    for (size_t i = 1; i < hex.size(); ++i)
+        if (!std::isxdigit(static_cast<unsigned char>(hex[i]))) return std::nullopt;
+    const size_t stride = shortForm ? 1 : 2;
+    const double channelMax = shortForm ? 15.0 : 255.0;
+    std::array<double, 4> rgba{0.0, 0.0, 0.0, 1.0};
+    for (size_t i = 0; i < (hex.size() - 1) / stride; ++i)
+        rgba[i] = std::stoi(hex.substr(1 + i * stride, stride), nullptr, 16) / channelMax;
+    return rgba;
 }
 
 } // namespace
 
-std::array<double, 4> cssColor(const std::string& name, double alpha) {
-    if (!name.empty() && name[0] == '#') {
-        const std::string h = name.substr(1);
-        if (h.size() == 6) {
-            const double r = (hexDigit(h[0]) * 16 + hexDigit(h[1])) / 255.0;
-            const double g = (hexDigit(h[2]) * 16 + hexDigit(h[3])) / 255.0;
-            const double b = (hexDigit(h[4]) * 16 + hexDigit(h[5])) / 255.0;
-            return {r, g, b, alpha};
-        }
-        if (h.size() == 3) {
-            const double r = hexDigit(h[0]) / 15.0;
-            const double g = hexDigit(h[1]) / 15.0;
-            const double b = hexDigit(h[2]) / 15.0;
-            return {r, g, b, alpha};
-        }
-        return {1.0, 1.0, 1.0, alpha};
+std::optional<std::array<double, 4>> parseColor(const std::string& text) {
+    // OpenSCAD's parse_color: a name first (case-insensitive; "xkcd:" reaches
+    // the xkcd survey table, falling back to the CSS table), then hex.
+    const std::string name = toLower(text);
+    if (name.rfind("xkcd:", 0) == 0) {
+        const auto& xk = xkcdColorTable();
+        if (auto it = xk.find(name.substr(5)); it != xk.end())
+            return std::array<double, 4>{it->second[0] / 255.0, it->second[1] / 255.0, it->second[2] / 255.0, 1.0};
     }
+    // OpenSCAD's own addition to the CSS list: fully transparent black.
+    if (name == "transparent") return std::array<double, 4>{0.0, 0.0, 0.0, 0.0};
+    if (auto it = colorTable().find(name); it != colorTable().end())
+        return std::array<double, 4>{it->second[0], it->second[1], it->second[2], 1.0};
+    return parseHex(text);
+}
 
-    auto it = colorTable().find(toLower(name));
-    if (it != colorTable().end()) {
-        return {it->second[0], it->second[1], it->second[2], alpha};
-    }
-    return {1.0, 1.0, 1.0, alpha};
+std::array<double, 4> cssColor(const std::string& name, double alpha) {
+    auto c = parseColor(name);
+    if (!c) return {1.0, 1.0, 1.0, alpha};
+    return {(*c)[0], (*c)[1], (*c)[2], alpha};
 }
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.28.6 → 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.28.6 → 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;