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

{openscad_cpp_evaluator-1.28.5 → openscad_cpp_evaluator-1.29.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,

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

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

{openscad_cpp_evaluator-1.28.5 → openscad_cpp_evaluator-1.29.0}/external/openscad_cpp_parser/src/api.cpp

@@ -119,10 +119,25 @@ std::vector<std::unique_ptr<ASTNode>> parseAst(const std::string& code, const st
 
     ParserDriver driver(origin);
     driver.strictCommas = g_strictCommas;
-    lexerBeginString(code);
-    yy::parser parser(driver);
-    int rc = parser.parse();
-    lexerEnd();
+    int rc;
+    {
+        // The flex scanner is global state (grammar/lexer_api.hpp), so two
+        // threads parsing at once lexed each other's input and crashed -- in
+        // BelfrySCAD, a render worker parsing its file while the UI thread
+        // parsed the buffer for the Customizer: an intermittent 0xC0000005
+        // on Windows. One parse at a time; a parse is milliseconds, and the
+        // shared file cache means a library is parsed once, not per thread.
+        // ponytail: a global lock; a reentrant scanner (%option reentrant +
+        // a yyscan_t through the driver) if parsing ever needs to scale.
+        static std::mutex scannerMutex;
+        std::lock_guard<std::mutex> lock(scannerMutex);
+        struct EndLexer {   // lexerEnd() even when parse() throws
+            ~EndLexer() { lexerEnd(); }
+        } endLexer;
+        lexerBeginString(code);
+        yy::parser parser(driver);
+        rc = parser.parse();
+    }
 
     if (rc != 0 || driver.hadError) {
         throw ParseError(formatSyntaxError(driver, code, origin, sourceMap));
@@ -409,11 +424,11 @@ FileAstPtr parseFileShared(const std::string& absPath, bool includeComments) {
             return it->second.ast;
     }
 
-    // Parsed OUTSIDE the lock: parsing a library takes tens of
-    // milliseconds, and holding a global lock across it would serialise
-    // every thread. Two threads racing the same file both parse and one
-    // result is dropped -- wasteful once, never wrong, and far cheaper than
-    // the alternative.
+    // Parsed outside THIS lock, so a cache lookup never waits behind a
+    // parse. (parseAst serialises the scanner itself: this comment once
+    // called concurrent parses "never wrong", and they were -- the scanner
+    // is global state.) Two threads racing the same file each parse it in
+    // turn and one result is dropped: wasteful once, never wrong.
     auto parsed = std::make_shared<const FileAst>(parseSingleFile(absPath, includeComments));
     std::lock_guard<std::mutex> lock(g_astCacheMutex);
     CacheEntry& entry = g_astCache[key];

{openscad_cpp_evaluator-1.28.5 → openscad_cpp_evaluator-1.29.0}/external/openscad_cpp_parser/tests/CMakeLists.txt

@@ -27,6 +27,7 @@ add_executable(oscad_tests
   test_node_str.cpp
   test_render_expression.cpp
   test_strict_commas.cpp
+  test_concurrent_parse.cpp
 )
 target_link_libraries(oscad_tests PRIVATE openscad_cpp_parser GTest::gtest_main)
 

openscad_cpp_evaluator-1.29.0/external/openscad_cpp_parser/tests/test_concurrent_parse.cpp

@@ -0,0 +1,56 @@
+// The flex scanner is non-reentrant, global state (grammar/lexer_api.hpp),
+// so two threads parsing at once used to lex each other's input. In
+// BelfrySCAD that was an intermittent 0xC0000005 on Windows: a render worker
+// parsing its file while the UI thread parsed the buffer for the Customizer.
+// parseAst now serialises the scanner. Every thread here parses its OWN
+// source and checks it got its own tree back, so corruption fails the test
+// even where it does not crash.
+#include "openscad_cpp_parser/api.hpp"
+
+#include <gtest/gtest.h>
+
+#include <atomic>
+#include <string>
+#include <thread>
+#include <vector>
+
+using namespace oscad;
+
+namespace {
+std::string sourceFor(int thread, int round) {
+    // Different identifiers and lengths per thread, so a lexer reading
+    // another thread's buffer produces a different tree, not an equal one.
+    std::string name = "v" + std::to_string(thread) + "_" + std::to_string(round);
+    std::string src;
+    for (int i = 0; i < 20 + thread; ++i) {
+        src += name + "_" + std::to_string(i) + " = [" + std::to_string(i) + ", " +
+               std::to_string(thread) + ", \"s" + std::to_string(round) + "\"];\n";
+    }
+    return src;
+}
+} // namespace
+
+TEST(ConcurrentParse, ThreadsParsingAtOnceEachGetTheirOwnTree) {
+    constexpr int kThreads = 8, kRounds = 150;
+    std::atomic<int> wrong{0};
+    std::vector<std::thread> threads;
+    for (int t = 0; t < kThreads; ++t) {
+        threads.emplace_back([t, &wrong] {
+            for (int r = 0; r < kRounds; ++r) {
+                const std::string src = sourceFor(t, r);
+                try {
+                    auto ast = parseAst(src);
+                    const auto* first = ast.empty() ? nullptr : dynamic_cast<const Assignment*>(ast[0].get());
+                    const std::string want = "v" + std::to_string(t) + "_" + std::to_string(r) + "_0";
+                    if (ast.size() != static_cast<size_t>(20 + t) || !first || first->name->name != want) {
+                        ++wrong;
+                    }
+                } catch (...) {
+                    ++wrong;   // a syntax error from lexing another thread's input
+                }
+            }
+        });
+    }
+    for (auto& th : threads) th.join();
+    EXPECT_EQ(wrong.load(), 0);
+}

openscad_cpp_evaluator-1.29.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.5 → openscad_cpp_evaluator-1.29.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.28.5 → openscad_cpp_evaluator-1.29.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.5 → openscad_cpp_evaluator-1.29.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.5 → openscad_cpp_evaluator-1.29.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