openscad-cpp-evaluator 1.22.0__tar.gz → 1.24.0__tar.gz

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/external/openscad_cpp_parser/include/openscad_cpp_parser/api.hpp

@@ -136,9 +136,14 @@ struct LibraryFileResult {
 LibraryFileResult getASTFromLibraryFile(const std::string& currFile, const std::string& libFile,
                                          bool includeComments = false, bool processIncludes = true);
 
-// OpenSCAD's library search path: (1) directory of currFile, (2)
-// OPENSCADPATH env var (':'-separated on POSIX, ';' on Windows), (3)
-// platform default library dir.
+// OpenSCAD's library search path, in order: (1) directory of currFile,
+// (2) each OPENSCADPATH entry (':'-separated on POSIX, ';' on Windows),
+// (3) the user's own libraries folder, (4) libraries shipped beside this
+// binary. OPENSCADPATH ADDS to (3) and (4) rather than replacing them,
+// which is what OpenSCAD's own parser_init() does.
+std::vector<std::string> librarySearchDirs(const std::string& currFile);
+
+// The first entry of librarySearchDirs() that holds `libFile`.
 std::optional<std::string> findLibraryFile(const std::string& currFile, const std::string& libFile);
 
 // A file's statements with its `include <...>` directives resolved, where

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/external/openscad_cpp_parser/src/CMakeLists.txt

@@ -38,7 +38,16 @@ target_include_directories(openscad_cpp_parser PRIVATE
   ${CMAKE_CURRENT_SOURCE_DIR}/grammar
   ${CMAKE_CURRENT_BINARY_DIR}
 )
-target_link_libraries(openscad_cpp_parser PUBLIC nlohmann_json::nlohmann_json)
+# CMAKE_DL_LIBS is -ldl for api.cpp's dladdr() -- empty on macOS and
+# Windows, where it lives in libSystem/kernel32. A local macOS build
+# therefore links fine and manylinux (glibc < 2.34, dl still a separate
+# library) does not: caught only by a wheel build.
+target_link_libraries(openscad_cpp_parser PUBLIC nlohmann_json::nlohmann_json ${CMAKE_DL_LIBS})
+# SHGetFolderPathW, for the real My Documents rather than an assumed
+# %USERPROFILE%\Documents -- see api.cpp userLibraryDir().
+if(WIN32)
+  target_link_libraries(openscad_cpp_parser PUBLIC shell32)
+endif()
 target_compile_options(openscad_cpp_parser PRIVATE
   $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall;-Wextra>
 )

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/external/openscad_cpp_parser/src/api.cpp

@@ -7,6 +7,17 @@
 
 #include <cstdlib>
 #include <filesystem>
+#if defined(_WIN32)
+// NOMINMAX or windows.h's max()/min() macros eat std::max below -- MSVC
+// caught it as "illegal token on right side of '::'", which names neither
+// the macro nor the header.
+#define NOMINMAX
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <shlobj.h>
+#else
+#include <dlfcn.h>
+#endif
 #include <fstream>
 #include <set>
 #include <system_error>
@@ -133,6 +144,22 @@ std::vector<std::unique_ptr<ASTNode>> getASTFromString(const std::string& code,
 
 namespace {
 
+// A "not found" that says where we actually looked. The old message named
+// only the includer, so "searched relative to X" read as "only X was
+// searched" -- which is how #503 came to be filed against a search that
+// does cover the libraries folder.
+std::string notFound(const char* noun, const std::string& filename, const std::string& currentFile) {
+    std::string msg = std::string(noun) + " '" + filename + "' not found. Searched:";
+    for (const auto& d : librarySearchDirs(currentFile)) {
+        msg += "\n  " + d;
+    }
+    return msg;
+}
+
+} // namespace
+
+namespace {
+
 std::string readFile(const std::string& path) {
     std::ifstream in(path, std::ios::binary);
     if (!in) {
@@ -163,8 +190,7 @@ std::vector<std::unique_ptr<ASTNode>> resolveIncludes(std::vector<std::unique_pt
             const std::string& filename = inc.filepath->val;
             auto libFile = findLibraryFile(currentFile, filename);
             if (!libFile) {
-                throw std::runtime_error("Included file '" + filename + "' not found. Searched relative to: " +
-                                          (currentFile.empty() ? "current directory" : currentFile));
+                throw std::runtime_error(notFound("Included file", filename, currentFile));
             }
             std::string absLib = fs::absolute(*libFile).string();
             if (visited.count(absLib) != 0) {
@@ -185,40 +211,98 @@ std::vector<std::unique_ptr<ASTNode>> resolveIncludes(std::vector<std::unique_pt
 
 } // namespace
 
-std::optional<std::string> findLibraryFile(const std::string& currFile, const std::string& libFile) {
-    std::vector<fs::path> dirs;
-    if (!currFile.empty()) {
-        dirs.push_back(fs::absolute(currFile).parent_path());
-    }
+namespace {
 
-    char pathsep = ':';
-    std::string dfltPath;
-    const char* home = std::getenv("HOME");
+// The user's own libraries folder -- OpenSCAD's
+// PlatformUtils::userLibraryPath(), and the one an installer or a git clone
+// of BOSL2 lands in.
+std::string userLibraryDir() {
 #if defined(_WIN32)
-    pathsep = ';';
+    // ASK Windows where My Documents is rather than assuming
+    // %USERPROFILE%\Documents. OneDrive's Known Folder Move -- on by default
+    // on a new machine -- relocates it to %USERPROFILE%\OneDrive\Documents,
+    // and a library OpenSCAD itself installed then sat somewhere we never
+    // looked (BelfrySCAD #503). Same call and same flag OpenSCAD makes
+    // (PlatformUtils-win.cc getFolderPath).
+    wchar_t buf[MAX_PATH] = {0};
+    if (SHGetFolderPathW(nullptr, CSIDL_PERSONAL, nullptr, SHGFP_TYPE_CURRENT, buf) == S_OK) {
+        return (fs::path(buf) / "OpenSCAD" / "libraries").string();
+    }
     const char* userProfile = std::getenv("USERPROFILE");
-    if (userProfile) {
-        dfltPath = std::string(userProfile) + "\\Documents\\OpenSCAD\\libraries";
+    return userProfile ? (fs::path(userProfile) / "Documents" / "OpenSCAD" / "libraries").string()
+                       : std::string();
+#else
+    const char* home = std::getenv("HOME");
+    if (!home) {
+        return {};
     }
-#elif defined(__APPLE__)
-    if (home) {
-        dfltPath = std::string(home) + "/Documents/OpenSCAD/libraries";
+#if defined(__APPLE__)
+    return (fs::path(home) / "Documents" / "OpenSCAD" / "libraries").string();
+#else
+    return (fs::path(home) / ".local" / "share" / "OpenSCAD" / "libraries").string();
+#endif
+#endif
+}
+
+// Libraries shipped alongside this build -- OpenSCAD's
+// PlatformUtils::resourcePath("libraries"). "Alongside" means beside the
+// binary this code was linked into: the CLI executable, or the Python
+// extension inside its installed package.
+// ponytail: one candidate directory, no ../share/openscad/libraries walk --
+// add the walk if a packaging layout ever puts the libraries somewhere
+// other than next to the binary.
+std::string bundledLibraryDir() {
+    fs::path self;
+#if defined(_WIN32)
+    HMODULE mod = nullptr;
+    if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
+                               | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+                           reinterpret_cast<LPCWSTR>(&userLibraryDir), &mod)) {
+        wchar_t buf[MAX_PATH] = {0};
+        if (GetModuleFileNameW(mod, buf, MAX_PATH)) {
+            self = buf;
+        }
     }
 #else
-    if (home) {
-        dfltPath = std::string(home) + "/.local/share/OpenSCAD/libraries";
+    Dl_info info;
+    if (dladdr(reinterpret_cast<void*>(&userLibraryDir), &info) && info.dli_fname) {
+        self = info.dli_fname;
     }
 #endif
+    if (self.empty()) {
+        return {};
+    }
+    std::error_code ec;
+    return (fs::absolute(self, ec).parent_path() / "libraries").string();
+}
+
+} // namespace
 
+std::vector<std::string> librarySearchDirs(const std::string& currFile) {
+    std::vector<std::string> dirs;
+    if (!currFile.empty()) {
+        dirs.push_back(fs::absolute(currFile).parent_path().string());
+    }
+
+#if defined(_WIN32)
+    const char pathsep = ';';
+#else
+    const char pathsep = ':';
+#endif
+
+    // OPENSCADPATH comes FIRST and adds to the built-in paths rather than
+    // replacing them -- exactly what OpenSCAD's parser_init() does. It used
+    // to replace them, so setting the variable for one library hid every
+    // other, including a BOSL2 sitting in the default folder (#503).
     const char* envPath = std::getenv("OPENSCADPATH");
-    std::string env = envPath ? std::string(envPath) : dfltPath;
-    if (!env.empty()) {
+    if (envPath) {
+        std::string env(envPath);
         size_t start = 0;
         while (start <= env.size()) {
             size_t pos = env.find(pathsep, start);
             std::string part = (pos == std::string::npos) ? env.substr(start) : env.substr(start, pos - start);
             if (!part.empty()) {
-                dirs.emplace_back(part);
+                dirs.push_back(part);
             }
             if (pos == std::string::npos) {
                 break;
@@ -227,8 +311,17 @@ std::optional<std::string> findLibraryFile(const std::string& currFile, const st
         }
     }
 
-    for (const auto& d : dirs) {
-        fs::path candidate = d / libFile;
+    for (const std::string& d : {userLibraryDir(), bundledLibraryDir()}) {
+        if (!d.empty()) {
+            dirs.push_back(d);
+        }
+    }
+    return dirs;
+}
+
+std::optional<std::string> findLibraryFile(const std::string& currFile, const std::string& libFile) {
+    for (const auto& d : librarySearchDirs(currFile)) {
+        fs::path candidate = fs::path(d) / libFile;
         std::error_code ec;
         if (fs::is_regular_file(candidate, ec)) {
             return candidate.string();
@@ -255,9 +348,7 @@ LibraryFileResult getASTFromLibraryFile(const std::string& currFile, const std::
                                          bool processIncludes) {
     auto found = findLibraryFile(currFile, libFile);
     if (!found) {
-        throw std::runtime_error("Library file '" + libFile +
-                                  "' not found in search paths. Searched in: current file directory, OPENSCADPATH, and "
-                                  "platform default paths.");
+        throw std::runtime_error(notFound("Library file", libFile, currFile));
     }
     auto ast = getASTFromFile(*found, includeComments, processIncludes);
     return LibraryFileResult{std::move(ast), *found};
@@ -346,8 +437,7 @@ void collectProgram(const FileAst& nodes, const std::string& currentFile, bool i
             const std::string& filename = inc.filepath->val;
             auto libFile = findLibraryFile(currentFile, filename);
             if (!libFile) {
-                throw std::runtime_error("Included file '" + filename + "' not found. Searched relative to: " +
-                                          (currentFile.empty() ? "current directory" : currentFile));
+                throw std::runtime_error(notFound("Included file", filename, currentFile));
             }
             std::string absLib = fs::absolute(*libFile).string();
             if (!visited.insert(absLib).second) continue;

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/external/openscad_cpp_parser/tests/test_comments_and_files.cpp

@@ -2,6 +2,8 @@
 
 #include <gtest/gtest.h>
 
+#include <algorithm>
+#include <cstdlib>
 #include <filesystem>
 #include <fstream>
 #include <random>
@@ -138,3 +140,87 @@ TEST(FileApi, FindLibraryFileReturnsNulloptWhenMissing) {
     auto found = findLibraryFile("", "definitely_missing_file_xyz.scad");
     EXPECT_FALSE(found.has_value());
 }
+
+namespace {
+
+// RAII OPENSCADPATH, so one test's setting cannot leak into the next.
+class ScopedOpenscadPath {
+public:
+    explicit ScopedOpenscadPath(const std::string& value) {
+        const char* prev = std::getenv("OPENSCADPATH");
+        had_ = prev != nullptr;
+        if (had_) prev_ = prev;
+        set(value.c_str());
+    }
+    ~ScopedOpenscadPath() {
+        if (had_) {
+            set(prev_.c_str());
+        } else {
+#if defined(_WIN32)
+            _putenv_s("OPENSCADPATH", "");
+#else
+            unsetenv("OPENSCADPATH");
+#endif
+        }
+    }
+private:
+    static void set(const char* v) {
+#if defined(_WIN32)
+        _putenv_s("OPENSCADPATH", v);
+#else
+        setenv("OPENSCADPATH", v, 1);
+#endif
+    }
+    bool had_ = false;
+    std::string prev_;
+};
+
+} // namespace
+
+TEST(FileApi, OpenscadPathAddsToTheBuiltInDirsRatherThanReplacingThem) {
+    // BelfrySCAD #503: `env = envPath ? envPath : dfltPath` meant setting
+    // OPENSCADPATH for one library hid every library in the default folder.
+    std::vector<std::string> without = librarySearchDirs("");
+    TempDir dir;
+    ScopedOpenscadPath scoped(dir.path().string());
+    std::vector<std::string> with = librarySearchDirs("");
+
+    EXPECT_EQ(with.size(), without.size() + 1);
+    EXPECT_EQ(with.front(), dir.path().string());  // and it is searched FIRST
+    for (const auto& d : without) {
+        EXPECT_NE(std::find(with.begin(), with.end(), d), with.end()) << d;
+    }
+}
+
+TEST(FileApi, FindLibraryFileSearchesOpenscadPath) {
+    TempDir libs;
+    fs::create_directories(libs.path() / "MYLIB");
+    fs::path libFile = libs.path() / "MYLIB" / "std.scad";
+    writeFile(libFile, "x = 1;\n");
+
+    TempDir docs;
+    fs::path mainFile = docs.path() / "main.scad";
+    writeFile(mainFile, "x = 1;\n");
+
+    ScopedOpenscadPath scoped(libs.path().string());
+    auto found = findLibraryFile(mainFile.string(), "MYLIB/std.scad");
+    ASSERT_TRUE(found.has_value());
+    EXPECT_EQ(fs::path(*found), libFile);
+}
+
+TEST(FileApi, MissingIncludeErrorNamesEveryDirectorySearched) {
+    TempDir dir;
+    fs::path mainFile = dir.path() / "main.scad";
+    writeFile(mainFile, "include <NOPE/std.scad>\n");
+
+    try {
+        getASTFromFile(mainFile.string());
+        FAIL() << "expected a missing-include error";
+    } catch (const std::runtime_error& e) {
+        std::string msg = e.what();
+        EXPECT_NE(msg.find("NOPE/std.scad"), std::string::npos) << msg;
+        for (const auto& d : librarySearchDirs(mainFile.string())) {
+            EXPECT_NE(msg.find(d), std::string::npos) << msg;
+        }
+    }
+}

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -398,6 +398,14 @@ public:
     // than anything reentrancy-aware, since generateTreeImpl recurses
     // depth-first on one thread.
     const oscad::Position* generateWarnEntry = nullptr;
+    // Non-null while generateTreeImpl() is generating a subtree whose result
+    // it intends to cache: warn() appends each formatted line here as well as
+    // emitting it, so the entry can replay them on a later hit. Saved and
+    // restored around each node rather than left set, and the inner vector is
+    // merged into the outer one on the way out, so a parent's entry carries
+    // everything its whole subtree said -- which is what a parent-level hit
+    // has to reproduce, since it skips all of it. See ManifoldCache.
+    std::vector<std::string>* warnCapture = nullptr;
     // The same republish for CSGNode::callChain, read by tagGenerated to
     // fill idToCallChain.
     uint32_t generateCallChain = kNoCallChain;
@@ -530,6 +538,10 @@ public:
     // Public: builtins/import.cpp's not-manifold warning is emitted from a
     // free function, same reasoning as tagGenerated()/builtinChildren().
     void warn(const std::string& message, const oscad::Position* position);
+    // Hands one already-formatted warning line to echoFn_, recording it in
+    // warnCapture first when one is active. Every warning path goes through
+    // here, including a ManifoldCache hit replaying a cached line.
+    void emitWarning(const std::string& formatted);
 
     // Applies OpenSCAD's mixed-2D/3D rules to a node's children just
     // before its GenerateFn runs -- see csg_generate.cpp.

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/include/openscad_cpp_evaluator/manifold_cache.hpp

@@ -3,6 +3,7 @@
 #include "openscad_cpp_evaluator/csg_node.hpp"
 
 #include <mutex>
+#include <vector>
 #include <optional>
 #include <string>
 #include <unordered_map>
@@ -22,15 +23,28 @@ namespace oscadeval {
 // threading.Lock -- a host may run renders/evaluates on a background
 // thread while another operation reads/clears the same cache). Mirrors
 // the reference's ManifoldCache class.
+// What one cache entry holds. The warnings matter as much as the bodies:
+// a hit skips the whole subtree's GenerateFn, and every generate-time
+// diagnostic is raised *inside* one of those (polyhedron's "mesh is not
+// closed", import()'s failures, the dimension rules). Cached without them,
+// a second render of unchanged source silently dropped every warning the
+// first one raised, so a real defect looked intermittent and the author
+// went hunting for a phantom. A cache has to be transparent; that includes
+// what it says, not only what it draws. See BelfrySCAD issue #521.
+struct CachedSubtree {
+    std::vector<ColoredBody> bodies;
+    std::vector<std::string> warnings;  // already formatted, replayed verbatim
+};
+
 class ManifoldCache {
 public:
-    std::optional<std::vector<ColoredBody>> get(const std::string& key) const;
-    void put(std::string key, std::vector<ColoredBody> bodies);
+    std::optional<CachedSubtree> get(const std::string& key) const;
+    void put(std::string key, std::vector<ColoredBody> bodies, std::vector<std::string> warnings);
     void clear();
 
 private:
     mutable std::mutex mutex_;
-    std::unordered_map<std::string, std::vector<ColoredBody>> entries_;
+    std::unordered_map<std::string, CachedSubtree> entries_;
 };
 
 // Structural content-hash key for `node`, used by generateTree()'s

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/src/CMakeLists.txt

@@ -69,3 +69,37 @@ target_link_libraries(openscad_cpp_evaluator PRIVATE linenoise freetype harfbuzz
 target_compile_options(openscad_cpp_evaluator PRIVATE
   $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall;-Wextra>
 )
+
+# -Wall -Wextra above is about OUR code, but two TUs pull a vendored header
+# in wholesale and inherit its warnings: 27 from Boost.Polygon's voronoi
+# headers and 9 from stb_image_write's implementation, against 5 that were
+# real. Silenced per source file, per warning.
+#
+# Deliberately NOT -isystem, which looks like the tidier fix and is a trap:
+# clang searches -isystem AFTER /usr/local/include, so a Homebrew Boost
+# 1.90 silently won over the pinned 1.86 (measured, not assumed). Keeping
+# -I keeps the fetched copy winning.
+include(CheckCXXCompilerFlag)
+foreach(_w deprecated-enum-float-conversion missing-field-initializers deprecated-declarations)
+  check_cxx_compiler_flag("-Wno-${_w}" OSCAD_HAS_WNO_${_w})
+endforeach()
+
+if(OSCAD_HAS_WNO_deprecated-enum-float-conversion)
+  # <boost/polygon/voronoi.hpp> does floating-point arithmetic on an
+  # unnamed enum, deprecated in C++20.
+  set_source_files_properties(builtins/roof.cpp PROPERTIES
+    COMPILE_OPTIONS "-Wno-deprecated-enum-float-conversion")
+endif()
+
+# zip_stored.cpp defines STB_IMAGE_WRITE_IMPLEMENTATION, so stb's C compiles
+# as ours: `= { 0 }` partial initializers, and one sprintf().
+set(_stb_quiet "")
+if(OSCAD_HAS_WNO_missing-field-initializers)
+  list(APPEND _stb_quiet "-Wno-missing-field-initializers")
+endif()
+if(OSCAD_HAS_WNO_deprecated-declarations)
+  list(APPEND _stb_quiet "-Wno-deprecated-declarations")
+endif()
+if(_stb_quiet)
+  set_source_files_properties(zip_stored.cpp PROPERTIES COMPILE_OPTIONS "${_stb_quiet}")
+endif()

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/src/builtins/function_builtins.cpp

@@ -837,38 +837,6 @@ Value builtinFontmetrics(Evaluator& ev, const CallArgs& args) {
     });
 }
 
-// Take only scalar numbers, mapped to how many leading positional
-// arguments must each actually BE a number. Anything else there (undef, a
-// string, a list, a bool, an object) is a type error yielding undef, and
-// so is supplying fewer arguments than the arity -- matching the
-// reference, which rejects the call outright rather than coercing.
-//
-// This has to be checked up front rather than left to each case below:
-// toDoubleLenient() silently turns undef/string/list into 0.0, which
-// would make `cos(misspelled_var)` quietly 1 instead of undef, and a
-// typo'd variable then produces plausible-looking geometry instead of an
-// obvious failure. Arity is deliberately a floor, not an exact match --
-// the reference also rejects EXTRA arguments, but tightening that too
-// risks breaking working library code for no correctness gain here.
-const std::unordered_map<std::string, size_t>& scalarNumericArity() {
-    static const std::unordered_map<std::string, size_t> arity = {
-        {"abs", 1}, {"sign", 1}, {"ceil", 1}, {"floor", 1}, {"round", 1}, {"sqrt", 1},
-        {"ln", 1}, {"log", 1}, {"exp", 1}, {"sin", 1}, {"cos", 1}, {"tan", 1},
-        {"asin", 1}, {"acos", 1}, {"atan", 1}, {"atan2", 2}, {"pow", 2}, {"rands", 3},
-    };
-    return arity;
-}
-
-// Numeric functions that legitimately take a LIST argument, so the
-// all-arguments-must-be-numbers rule above can't apply -- each validates
-// its own operands, and only needs the bool case caught here (Value's
-// bool and double are distinct alternatives, but the reference rejects
-// `max(true, 1)` as a type error rather than treating true as 1).
-const std::unordered_set<std::string>& numericOnlyNames() {
-    static const std::unordered_set<std::string> names = {"max", "min", "norm", "cross"};
-    return names;
-}
-
 } // namespace
 
 bool isBuiltinFunctionName(const std::string& name) {

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/src/builtins/primitives_3d.cpp

@@ -11,7 +11,10 @@
 #include <cstdint>
 #include <map>
 #include <numbers>
+#include <optional>
 #include <set>
+#include <string>
+#include <utility>
 
 namespace oscadeval {
 
@@ -42,8 +45,18 @@ bool isDrawableFailure(const manifold::Manifold& body, const M& mesh) {
                         [](float v) { return std::isfinite(v); });
 }
 
+struct BoundaryEdges {
+    size_t count = 0;
+    // Vertex indices of one representative open edge, or nullopt when the
+    // mesh is closed. A count alone is enough on a hand-written face list,
+    // where you can just read it; it is useless on generated geometry --
+    // 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;
+};
+
 template <typename M>
-size_t countBoundaryEdges(const M& mesh) {
+BoundaryEdges findBoundaryEdges(const M& mesh) {
     std::map<std::pair<uint32_t, uint32_t>, int> uses;
     for (size_t i = 0; i + 2 < mesh.triVerts.size(); i += 3) {
         const uint32_t v[3] = {static_cast<uint32_t>(mesh.triVerts[i]),
@@ -54,11 +67,34 @@ size_t countBoundaryEdges(const M& mesh) {
             ++uses[{std::min(a, b), std::max(a, b)}];
         }
     }
-    size_t open = 0;
+    BoundaryEdges out;
+    // std::map iterates in vertex-index order, which is arbitrary from the
+    // author's point of view but DETERMINISTIC: the same mesh names the same
+    // edge on every run. That matters more than which edge gets picked --
+    // an identifier that moves between renders is worse than no identifier.
+    // 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) ++open;
+        if (count % 2 == 0) continue;
+        ++out.count;
+        if (!out.first) out.first = edge;
     }
-    return open;
+    return out;
+}
+
+// "[1, 2.5, 0] - [1, 3, 0]" for one edge, using the same number formatting
+// echo() uses, so a coordinate can be pasted straight back into a script.
+template <typename M>
+std::string describeEdge(const M& mesh, std::pair<uint32_t, uint32_t> edge) {
+    const size_t stride = mesh.numProp > 0 ? static_cast<size_t>(mesh.numProp) : 3;
+    auto point = [&](uint32_t v) {
+        const size_t base = static_cast<size_t>(v) * stride;
+        if (base + 2 >= mesh.vertProperties.size()) return std::string("?");
+        return "[" + formatNumber(static_cast<double>(mesh.vertProperties[base])) + ", " +
+               formatNumber(static_cast<double>(mesh.vertProperties[base + 1])) + ", " +
+               formatNumber(static_cast<double>(mesh.vertProperties[base + 2])) + "]";
+    };
+    return point(edge.first) + " - " + point(edge.second);
 }
 } // namespace
 
@@ -810,8 +846,15 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
         // self-intersections builds perfectly well, and only an OPEN one
         // reaches this branch. The count points straight at the problem.
         if (!ev.insideHull) {
-            ev.warn("polyhedron: mesh is not closed -- " + std::to_string(countBoundaryEdges(mesh)) +
-                        " boundary edge(s); drawing it as a surface. hull() can still "
+            const BoundaryEdges open = findBoundaryEdges(mesh);
+            // 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 +
+                        "; drawing it as a surface. hull() can still "
                         "use its points, but it cannot take part in union/difference/intersection",
                     &node.position());
         }

{openscad_cpp_evaluator-1.22.0 → openscad_cpp_evaluator-1.24.0}/src/builtins/topology.cpp

@@ -621,18 +621,6 @@ double bandDistance(double v, double lo, double hi, bool invert) {
     return invert ? -d : d;
 }
 
-std::optional<std::array<double, 3>> readVec3(const Value& v) {
-    const ListPtr* l = std::get_if<ListPtr>(&v);
-    if (!l || !*l || (*l)->items.size() != 3) return std::nullopt;
-    std::array<double, 3> out{};
-    for (size_t i = 0; i < 3; ++i) {
-        const double* d = std::get_if<double>(&(*l)->items[i]);
-        if (!d || !std::isfinite(*d)) return std::nullopt;
-        out[i] = *d;
-    }
-    return out;
-}
-
 } // namespace
 
 // -- 2D: marching squares --------------------------------------------------