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

{openscad_cpp_evaluator-1.28.4 → openscad_cpp_evaluator-1.28.6}/PKG-INFO

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

{openscad_cpp_evaluator-1.28.4 → openscad_cpp_evaluator-1.28.6}/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.4 → openscad_cpp_evaluator-1.28.6}/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.28.6/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.28.4 → openscad_cpp_evaluator-1.28.6}/pyproject.toml

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

{openscad_cpp_evaluator-1.28.4 → openscad_cpp_evaluator-1.28.6}/src/builtins/primitives_3d.cpp

@@ -53,11 +53,18 @@ struct BoundaryEdges {
     // three bad edges in a few thousand triangles cannot be found by eye,
     // which is what happened in BelfrySCAD #521 / issue #187.
     std::optional<std::pair<uint32_t, uint32_t>> first;
+    // An edge both of whose faces run it the SAME way: the mesh is closed
+    // but a face is wound backwards. Named so the author knows which face
+    // to flip (BelfrySCAD #566, where "not closed -- 0 boundary edges"
+    // described a closed tetrahedron with two reversed faces).
+    size_t misoriented = 0;
+    std::optional<std::pair<uint32_t, uint32_t>> firstMisoriented;
 };
 
 template <typename M>
 BoundaryEdges findBoundaryEdges(const M& mesh) {
     std::map<std::pair<uint32_t, uint32_t>, int> uses;
+    std::map<std::pair<uint32_t, uint32_t>, int> forward;  // uses running low -> high
     for (size_t i = 0; i + 2 < mesh.triVerts.size(); i += 3) {
         const uint32_t v[3] = {static_cast<uint32_t>(mesh.triVerts[i]),
                                 static_cast<uint32_t>(mesh.triVerts[i + 1]),
@@ -65,6 +72,7 @@ BoundaryEdges findBoundaryEdges(const M& mesh) {
         for (int e = 0; e < 3; ++e) {
             const uint32_t a = v[e], b = v[(e + 1) % 3];
             ++uses[{std::min(a, b), std::max(a, b)}];
+            if (a < b) ++forward[{a, b}];
         }
     }
     BoundaryEdges out;
@@ -75,7 +83,16 @@ BoundaryEdges findBoundaryEdges(const M& mesh) {
     // A cluster of open edges is nearly always one hole, so the first is
     // usually representative of the rest.
     for (const auto& [edge, count] : uses) {
-        if (count % 2 == 0) continue;
+        if (count % 2 == 0) {
+            // Closed here; consistently wound only if the uses split evenly
+            // between the two directions.
+            const auto f = forward.find(edge);
+            if ((f == forward.end() ? 0 : f->second) * 2 != count) {
+                ++out.misoriented;
+                if (!out.firstMisoriented) out.firstMisoriented = edge;
+            }
+            continue;
+        }
         ++out.count;
         if (!out.first) out.first = edge;
     }
@@ -857,10 +874,22 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
             // Name one of them. Where the hole IS is the only part of this
             // message an author can act on; the count alone just says to go
             // looking, across the whole mesh.
-            const std::string where =
-                open.first ? ", first at " + describeEdge(mesh, *open.first) : std::string();
-            ev.warn("polyhedron: mesh is not closed -- " + std::to_string(open.count) +
-                        " boundary edge(s)" + where +
+            std::string what;
+            if (open.count) {
+                what = "mesh is not closed -- " + std::to_string(open.count) + " boundary edge(s)" +
+                       (open.first ? ", first at " + describeEdge(mesh, *open.first) : std::string());
+            } else if (open.misoriented) {
+                // Closed, but some faces wound backwards: "not closed -- 0
+                // boundary edge(s)" contradicted itself (BelfrySCAD #566).
+                what = "faces are not consistently wound -- " + std::to_string(open.misoriented) +
+                       " edge(s) run the same way by both faces sharing them" +
+                       (open.firstMisoriented ? ", first at " + describeEdge(mesh, *open.firstMisoriented)
+                                              : std::string()) +
+                       "; reverse the point order of the faces on one side of it";
+            } else {
+                what = "mesh is not a valid solid (" + checkMesh(mesh).summary() + ")";
+            }
+            ev.warn("polyhedron: " + what +
                         // "drawing it as a surface" was read by a reporter as
                         // the HOLE being surfaced over -- i.e. as automatic
                         // repair hiding their defect. Nothing is repaired: the
@@ -868,7 +897,8 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
                         // object as the thing being drawn, and say what it is
                         // NOT, since "surface" alone does not imply "not solid"
                         // to someone who did not know it could be either.
-                        "; drawing the object as an open surface rather than a "
+                        (open.count ? "; drawing the object as an open surface rather than a "
+                                    : "; drawing the object as a surface rather than a ") +
                         "solid -- nothing is patched. hull() can still "
                         "use its points, but it cannot take part in union/difference/intersection",
                     &node.position());

{openscad_cpp_evaluator-1.28.4 → openscad_cpp_evaluator-1.28.6}/tests/test_primitives.cpp

@@ -442,6 +442,22 @@ TEST(SphereStyle, StyleRespectsFnAndRadius) {
 // cube()'s size as OpenSCAD 2026.02.01 reads it: undef, absent or explicit,
 // is the default of 1; anything but a number or three numbers warns and
 // falls back to 1. Explicit undef built a zero-size cube -- nothing at all.
+// BelfrySCAD #566: a closed tetrahedron with two faces wound backwards was
+// reported as "mesh is not closed -- 0 boundary edge(s)". It is closed; say
+// what is actually wrong, name an edge, and still draw it.
+TEST(Primitives, PolyhedronWithReversedFacesSaysSo) {
+    std::vector<std::string> log;
+    Evaluated e = evalSrc("polyhedron([[0,0,0], [10,0,0], [0,10,0], [0,0,10]],\n"
+                          "           [[0,1,2], [0,1,3], [0,2,3], [1,2,3]]);",
+                          [&](const std::string& m) { log.push_back(m); });
+    ASSERT_EQ(log.size(), 1u);
+    EXPECT_NE(log[0].find("faces are not consistently wound -- 4 edge(s)"), std::string::npos) << log[0];
+    EXPECT_NE(log[0].find("first at [0, 0, 0] - [10, 0, 0]"), std::string::npos) << log[0];
+    EXPECT_EQ(log[0].find("not closed"), std::string::npos) << log[0];
+    EXPECT_EQ(log[0].find("open surface"), std::string::npos) << log[0];
+    ASSERT_EQ(e.bodies.size(), 1u);  // still drawn, as a display-only surface
+}
+
 TEST(Primitives, CubeBadSizeIsAUnitCube) {
     const std::pair<const char*, const char*> cases[] = {
         {"undef", ""},

{openscad_cpp_evaluator-1.28.4 → openscad_cpp_evaluator-1.28.6}/tests/test_python_bindings.py

@@ -1121,3 +1121,37 @@ def test_a_viewer_can_ask_for_a_thin_2d_slab_and_export_keeps_1(tmp_path):
     nverts = int(lines[1].split()[0])
     zs = [float(l.split()[2]) for l in lines[2:2 + nverts]]
     assert abs(max(zs) - min(zs) - 1.0) < 1e-6, "export is the 1-unit slab"
+
+
+def test_parsing_from_two_threads_at_once_is_safe(tmp_path):
+    """BelfrySCAD's render worker parses its file (`parse`) while the UI
+    thread parses the buffer for the Customizer (`parse_ast_string`); the
+    parser's flex scanner is global state, and the two used to collide --
+    an intermittent 0xC0000005 on Windows. The parser now serialises it
+    (openscad_cpp_parser #12). Run in a subprocess, since the failure mode
+    is a crash, not an exception."""
+    import subprocess
+    code = r'''
+import sys, threading
+from openscad_cpp_evaluator import parse, parse_ast_string
+path = sys.argv[1]
+errors = []
+def by_path():
+    try:
+        for _ in range(300): parse(path)
+    except Exception as e: errors.append(repr(e))
+def by_string():
+    try:
+        for i in range(300):
+            ast = parse_ast_string("a%d = [1, 2, 3];\nb = a%d;\n" % (i, i))
+            assert len(ast) == 2, ast
+    except Exception as e: errors.append(repr(e))
+threads = [threading.Thread(target=f) for f in (by_path, by_string, by_path, by_string)]
+for t in threads: t.start()
+for t in threads: t.join()
+print("errors:", errors); sys.exit(1 if errors else 0)
+'''
+    src = tmp_path / "m.scad"
+    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:])

{openscad_cpp_evaluator-1.28.4 → openscad_cpp_evaluator-1.28.6}/uv.lock

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