openscad-cpp-evaluator 1.49.1__tar.gz → 1.49.3__tar.gz

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.49.1
+Version: 1.49.3
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT AND OFL-1.1

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "openscad_cpp_evaluator/function_builtins.hpp"
+#include "openscad_cpp_evaluator/reassign.hpp"
 #include "openscad_cpp_evaluator/value.hpp"
 
 #include "openscad_cpp_parser/ast/ast_node.hpp"
@@ -756,6 +757,9 @@ struct CompiledChunk {
     // with how many: the Evaluator warns for them once, when the chunk is
     // compiled (it has the warning channel; the compiler does not).
     std::vector<std::pair<const oscad::StringLiteral*, int>> undefinedEscapeLiterals;
+    // Reassignments merged in the statement lists compiled into this chunk
+    // (see mergeReassignments), warned about the same way.
+    std::vector<Reassignment> reassignments;
     struct Param {
         std::string name;
         int slot = 0; // unused when isDyn is true -- $-params are never slot-addressed

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -592,8 +592,11 @@ public:
         return false;
     }
     std::unordered_set<const oscad::StringLiteral*> undefinedEscapesWarned_;
+    // Warnings a chunk's compile found, given once it is built: undefined
+    // string escapes, and reassignments its statement lists merged.
     void warnUndefinedEscapes(const CompiledChunk& chunk) {
         for (const auto& [lit, n] : chunk.undefinedEscapeLiterals) warnUndefinedEscapes(*lit, n);
+        for (const Reassignment& r : chunk.reassignments) warnReassignment(r);
     }
     // Hands one already-formatted warning line to echoFn_, recording it in
     // warnCapture first when one is active. Every warning path goes through
@@ -1393,6 +1396,19 @@ private:
     };
     std::unordered_map<std::pair<const oscad::ASTNode*, size_t>, std::optional<CompiledChunk>, ChildrenListKeyHash>
         childrenListChunkCache_;
+    // A statement list with its reassignments merged (see
+    // mergedStatementList), or nullopt when it has none -- the common
+    // case, which then costs one lookup. Same key, same clearing, same
+    // dangling-pointer reasoning as childrenListChunkCache_ above.
+    std::unordered_map<std::pair<const oscad::ASTNode*, size_t>, std::optional<std::vector<const oscad::ASTNode*>>,
+                       ChildrenListKeyHash>
+        mergedListCache_;
+    // "origin:line:name" of each reassignment already warned about, so a
+    // cleared mergedListCache_ never warns twice. Strings, not node
+    // pointers: these outlive the ASTs the cache is cleared for.
+    std::unordered_set<std::string> warnedReassignments_;
+    const std::vector<const oscad::ASTNode*>& mergedStatementList(const std::vector<const oscad::ASTNode*>& children);
+    void warnReassignment(const Reassignment& r);
 
     // See stmtExprChunkCache_'s own doc comment, immediately above, for why
     // this exists. Not a reentrancy guard (resolveTreeImpl is never called

openscad_cpp_evaluator-1.49.3/include/openscad_cpp_evaluator/reassign.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "openscad_cpp_parser/ast/expression.hpp"
+#include "openscad_cpp_parser/position.hpp"
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace oscadeval {
+
+// One name assigned again in the same statement list.
+struct Reassignment {
+    std::string name;
+    const oscad::Position* first;   // where the variable is evaluated
+    const oscad::Position* here;    // the assignment whose value it takes
+};
+
+// OpenSCAD's handle_assignment (parser.y): a name assigned twice in one
+// statement list is ONE assignment, made where it was FIRST assigned but
+// with the LAST expression. `x = 1; y = x * 10; x = 2;` gives y = 20.
+// Running them in order gave 10 -- and with include<> spliced into the top
+// level, that broke the usual way of configuring a library (include it,
+// then override its defaults) for every value the library derives from one
+// (BelfrySCAD #809).
+//
+// Returns the merged list -- the last assignment's node in the first one's
+// place, later slots dropped -- or nullopt when nothing repeats. ASTs are
+// shared and never modified; only this list of pointers changes. Each merge
+// is appended to `found` for the caller to warn about.
+inline std::optional<std::vector<const oscad::ASTNode*>> mergeReassignments(
+    const std::vector<const oscad::ASTNode*>& stmts, std::vector<Reassignment>* found = nullptr) {
+    if (stmts.size() < 2) return std::nullopt;
+    std::vector<const oscad::ASTNode*> out;
+    out.reserve(stmts.size());
+    std::unordered_map<std::string, std::pair<size_t, const oscad::Position*>> seen;
+    bool merged = false;
+    for (const oscad::ASTNode* node : stmts) {
+        if (node->kind() != oscad::NodeKind::Assignment) {
+            out.push_back(node);
+            continue;
+        }
+        const auto& a = static_cast<const oscad::Assignment&>(*node);
+        const std::string& name = a.name->name;
+        auto it = seen.find(name);
+        if (it == seen.end()) {
+            seen.emplace(name, std::make_pair(out.size(), &a.position()));
+            out.push_back(node);
+            continue;
+        }
+        if (found) found->push_back({name, it->second.second, &a.position()});
+        out[it->second.first] = node;
+        merged = true;
+    }
+    if (!merged) return std::nullopt;
+    return out;
+}
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/pyproject.toml

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

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/src/bytecode_compiler.cpp

@@ -1283,7 +1283,11 @@ public:
     // necessarily one this Compiler's own declaration owns) -- see
     // tryCompileChildrenList's own doc comment, below, for the entry point
     // that needs this shape directly.
-    void compileStatementList(const std::vector<const oscad::ASTNode*>& children, std::vector<Instruction>& out) {
+    void compileStatementList(const std::vector<const oscad::ASTNode*>& childrenIn, std::vector<Instruction>& out) {
+        // Reassignments merged first, as Evaluator::evalChildren does for the
+        // interpreted path: a list compiled inline here never reaches it.
+        const auto merged = mergeReassignments(childrenIn, &chunk_.reassignments);
+        const std::vector<const oscad::ASTNode*>& children = merged ? *merged : childrenIn;
         std::vector<const oscad::ASTNode*> assignments;
         std::vector<const oscad::ASTNode*> others;
         for (const oscad::ASTNode* c : children) {

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/src/csg_resolve.cpp

@@ -247,6 +247,7 @@ std::vector<std::unique_ptr<CSGNode>> Evaluator::resolveTreeImpl(const NodeList&
     stmtExprChunkCache_.clear();
     assignBlockChunkCache_.clear();
     childrenListChunkCache_.clear();
+    mergedListCache_.clear();
     ResolvePassGuard resolvePassGuard(inResolvePass_);
     evalChildren(nodes, ctx);
     std::vector<std::unique_ptr<CSGNode>> tree = std::move(treeStack_.back());

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/src/eval_use.cpp

@@ -1,7 +1,12 @@
 #include "openscad_cpp_evaluator/eval_use.hpp"
 
+#include "openscad_cpp_evaluator/eval_error.hpp"
+#include "openscad_cpp_evaluator/reassign.hpp"
 #include "openscad_cpp_parser/ast/declarations.hpp"
+#include "openscad_cpp_parser/ast/expression.hpp"
 
+#include <filesystem>
+#include <unordered_map>
 #include <utility>
 
 namespace oscadeval {
@@ -19,6 +24,55 @@ ResolvedUseScopes resolveUseScopes(const std::vector<std::unique_ptr<oscad::ASTN
 
 namespace {
 
+namespace fs = std::filesystem;
+
+std::string normalPath(const std::string& p) {
+    std::error_code ec;
+    fs::path abs = fs::absolute(fs::path(p), ec);
+    return (ec ? fs::path(p) : abs).lexically_normal().generic_string();
+}
+
+// Each file's top-level list, merged before any scope is built (see
+// mergeReassignments, reassign.hpp), so the interpreter, the compiled VM
+// and the scope tables all see one assignment per name. This is where an
+// include<>'d library's defaults meet the main file's overrides.
+//
+// Warnings follow parser.y's rules exactly. The deliberate silence is the
+// main file overriding an included file's variable: that is configuration,
+// not a mistake. Two different included files overriding each other are
+// silent too.
+std::vector<const oscad::ASTNode*> mergeTopLevel(const std::vector<const oscad::ASTNode*>& nodes,
+                                                 const std::string& mainFile,
+                                                 const std::function<void(const std::string&)>& logFn) {
+    std::vector<Reassignment> found;
+    auto merged = mergeReassignments(nodes, &found);
+    if (!merged) return nodes;
+    const std::string main = normalPath(mainFile);
+    for (const Reassignment& r : found) {
+        const std::string prevFile = normalPath(r.first->origin);
+        const std::string currFile = normalPath(r.here->origin);
+        std::string where;   // the file named in the message, if not the main one
+        bool warnIt = false;
+        if (prevFile == main && currFile == main) {
+            warnIt = true;
+        } else if (prevFile == currFile) {
+            warnIt = r.first->line != r.here->line;   // equal: one file included twice
+            where = prevFile;
+        } else if (prevFile == main) {
+            warnIt = true;   // the main file's value overwritten by an include
+            where = prevFile;
+        }
+        if (!warnIt || !logFn) continue;
+        std::string msg = r.name + " was assigned on line " + std::to_string(r.first->line);
+        if (!where.empty()) {
+            const fs::path rel = fs::path(where).lexically_relative(fs::path(main).parent_path());
+            msg += " of " + (rel.empty() ? where : rel.generic_string());
+        }
+        logFn(formatWarning(msg + " but was overwritten", r.here, {}));
+    }
+    return *merged;
+}
+
 // The recursion. `table` is threaded through every level rather than each
 // level building its own: `use <file>` gives each used file its own root
 // Scope, but one evaluation reads all of them back, so every node's scope
@@ -26,11 +80,13 @@ namespace {
 // could not see anything a nested resolution recorded -- every node of a
 // used file read back as having no scope, and `use` silently resolved to
 // undef. BelfrySCAD's own suite caught that; this repo's did not.
-ResolvedUseScopes resolveUseScopesInto(const std::vector<const oscad::ASTNode*>& ownNodes,
+ResolvedUseScopes resolveUseScopesInto(const std::vector<const oscad::ASTNode*>& ownNodesIn,
                                         const std::string& currentFile,
+                                        const std::string& mainFile,
                                         const std::function<void(const std::string&)>& logFn,
                                         oscad::ScopeTable& table) {
     ResolvedUseScopes result;
+    const std::vector<const oscad::ASTNode*> ownNodes = mergeTopLevel(ownNodesIn, mainFile, logFn);
 
     std::vector<const oscad::ASTNode*> injected;
     // Declarations pulled in from one used file, paired with that file's
@@ -70,7 +126,7 @@ ResolvedUseScopes resolveUseScopesInto(const std::vector<const oscad::ASTNode*>&
         std::vector<const oscad::ASTNode*> libBorrowed;
         libBorrowed.reserve(libAst.size());
         for (const auto& n : libAst) libBorrowed.push_back(n.get());
-        ResolvedUseScopes nested = resolveUseScopesInto(libBorrowed, lib.resolvedPath, logFn, table);
+        ResolvedUseScopes nested = resolveUseScopesInto(libBorrowed, lib.resolvedPath, mainFile, logFn, table);
 
         std::vector<const oscad::ASTNode*> libInjected;
         for (const oscad::ASTNode* n : nested.ownNodesFiltered) {
@@ -137,7 +193,7 @@ ResolvedUseScopes resolveUseScopes(const std::vector<const oscad::ASTNode*>& own
     // One table for the whole resolution, handed to the root scope at the
     // end so it lives exactly as long as the scopes it points into.
     auto table = std::make_unique<oscad::ScopeTable>();
-    ResolvedUseScopes result = resolveUseScopesInto(ownNodes, currentFile, logFn, *table);
+    ResolvedUseScopes result = resolveUseScopesInto(ownNodes, currentFile, currentFile, logFn, *table);
     if (result.rootScope) result.rootScope->adoptTable(std::move(table));
     return result;
 }

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/src/stmt_eval.cpp

@@ -1,5 +1,6 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
 #include "openscad_cpp_evaluator/format_closure.hpp"
+#include "openscad_cpp_evaluator/reassign.hpp"
 
 #include "openscad_cpp_evaluator/call_args.hpp"
 
@@ -325,7 +326,37 @@ void Evaluator::evalStatement(const oscad::ASTNode& node, EvalContext& ctx) {
     }
 }
 
-void Evaluator::evalChildren(const std::vector<const oscad::ASTNode*>& children, EvalContext& ctx) {
+// A statement list inside a module body or a block, with its reassignments
+// merged (mergeReassignments, reassign.hpp). The top level of each file is
+// merged once before scopes are built (eval_use.cpp); these lists live in
+// shared, immutable ASTs, so they are merged here, as they are run, and
+// cached. The compiler merges the lists it compiles inline itself
+// (compileStatementList), so both paths agree.
+const std::vector<const oscad::ASTNode*>& Evaluator::mergedStatementList(
+    const std::vector<const oscad::ASTNode*>& children) {
+    if (children.size() < 2) return children;
+    const auto key = std::make_pair(children.front(), children.size());
+    auto it = mergedListCache_.find(key);
+    if (it == mergedListCache_.end()) {
+        std::vector<Reassignment> found;
+        it = mergedListCache_.emplace(key, mergeReassignments(children, &found)).first;
+        for (const Reassignment& r : found) warnReassignment(r);
+    }
+    return it->second ? *it->second : children;
+}
+
+void Evaluator::warnReassignment(const Reassignment& r) {
+    // A body is one file, so parser.y's rule reduces to: always warn (its
+    // same-line exemption is for one file included twice, which only the
+    // top level can see). Once per assignment however often its list is
+    // run or recompiled.
+    const std::string tag = r.here->origin + ":" + std::to_string(r.here->start_offset) + ":" + r.name;
+    if (!warnedReassignments_.insert(tag).second) return;
+    warn(r.name + " was assigned on line " + std::to_string(r.first->line) + " but was overwritten", r.here);
+}
+
+void Evaluator::evalChildren(const std::vector<const oscad::ASTNode*>& childrenIn, EvalContext& ctx) {
+    const std::vector<const oscad::ASTNode*>& children = mergedStatementList(childrenIn);
     // Whole-LIST compile first (see tryRunCompiledChildren's own doc
     // comment, evaluator.hpp) -- tries the FULL `children` as one chunk
     // before falling back to assignments-then-others below. This is what

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/src/zip_stored.cpp

@@ -52,6 +52,7 @@ uint16_t readU16(const uint8_t* p) { return static_cast<uint16_t>(p[0] | (p[1] <
 uint32_t readU32(const uint8_t* p) {
     return static_cast<uint32_t>(p[0] | (p[1] << 8) | (p[2] << 16) | (static_cast<uint32_t>(p[3]) << 24));
 }
+uint64_t readU64(const uint8_t* p) { return readU32(p) | (static_cast<uint64_t>(readU32(p + 4)) << 32); }
 
 // A fixed, valid DOS date/time (2020-01-01 00:00:00) -- the exact instant
 // doesn't matter for a generated 3MF, just that it's a well-formed DOS
@@ -156,9 +157,9 @@ void writeZipEntries(const std::string& path, const std::vector<PlacedEntry>& en
 struct CentralDirEntry {
     std::string name;
     uint16_t method;
-    uint32_t compressedSize;
-    uint32_t uncompressedSize;
-    uint32_t localHeaderOffset;
+    uint64_t compressedSize;
+    uint64_t uncompressedSize;
+    uint64_t localHeaderOffset;
 };
 
 std::vector<uint8_t> readWholeFile(const std::string& path) {
@@ -189,25 +190,57 @@ std::vector<CentralDirEntry> parseCentralDirectory(const std::vector<uint8_t>& f
     }
     if (eocd == std::string::npos) throw std::runtime_error("'" + path + "' is not a valid ZIP archive (no EOCD)");
 
-    const uint16_t entryCount = readU16(&file[eocd + 10]);
-    const uint32_t cdOffset = readU32(&file[eocd + 16]);
+    uint64_t entryCount = readU16(&file[eocd + 10]);
+    uint64_t cdOffset = readU32(&file[eocd + 16]);
+    // ZIP64: a field too big for the classic record is all ones, and the
+    // real value is in the ZIP64 end record the locator just before it
+    // points to. lib3mf -- behind OpenSCAD's and most slicers' 3MF export --
+    // writes one even for a tiny file, so without this nearly every 3MF
+    // read as "corrupt central directory offset" (BelfrySCAD #800).
+    if ((entryCount == 0xFFFFu || cdOffset == 0xFFFFFFFFu) && eocd >= 20 &&
+        readU32(&file[eocd - 20]) == 0x07064b50u) {
+        const uint64_t z64 = readU64(&file[eocd - 20 + 8]);
+        if (z64 + 56 > file.size() || readU32(&file[z64]) != 0x06064b50u) {
+            throw std::runtime_error("'" + path + "': corrupt ZIP64 end of central directory");
+        }
+        entryCount = readU64(&file[z64 + 32]);
+        cdOffset = readU64(&file[z64 + 48]);
+    }
     if (cdOffset >= file.size()) throw std::runtime_error("'" + path + "': corrupt central directory offset");
 
     std::vector<CentralDirEntry> entries;
     size_t p = cdOffset;
-    for (uint16_t i = 0; i < entryCount; ++i) {
+    for (uint64_t i = 0; i < entryCount; ++i) {
         if (p + 46 > file.size() || readU32(&file[p]) != 0x02014b50u) {
             throw std::runtime_error("'" + path + "': corrupt central directory entry");
         }
         const uint16_t method = readU16(&file[p + 10]);
-        const uint32_t compressedSize = readU32(&file[p + 20]);
-        const uint32_t uncompressedSize = readU32(&file[p + 24]);
+        uint64_t compressedSize = readU32(&file[p + 20]);
+        uint64_t uncompressedSize = readU32(&file[p + 24]);
         const uint16_t nameLen = readU16(&file[p + 28]);
         const uint16_t extraLen = readU16(&file[p + 30]);
         const uint16_t commentLen = readU16(&file[p + 32]);
-        const uint32_t localHeaderOffset = readU32(&file[p + 42]);
-        if (p + 46 + nameLen > file.size()) throw std::runtime_error("'" + path + "': corrupt central directory entry name");
+        uint64_t localHeaderOffset = readU32(&file[p + 42]);
+        if (p + 46 + nameLen + extraLen > file.size()) throw std::runtime_error("'" + path + "': corrupt central directory entry name");
         std::string name(reinterpret_cast<const char*>(&file[p + 46]), nameLen);
+        // A ZIP64 extra field (id 1) holds, in this order, only the values
+        // whose 32-bit field above is all ones.
+        for (size_t x = p + 46 + nameLen, xEnd = x + extraLen; x + 4 <= xEnd;) {
+            const uint16_t id = readU16(&file[x]);
+            const uint16_t len = readU16(&file[x + 2]);
+            size_t q = x + 4;
+            const size_t qEnd = std::min<size_t>(q + len, xEnd);
+            if (id == 0x0001u) {
+                for (uint64_t* v : {&uncompressedSize, &compressedSize, &localHeaderOffset}) {
+                    if (*v != 0xFFFFFFFFu) continue;
+                    if (q + 8 > qEnd) throw std::runtime_error("'" + path + "': corrupt ZIP64 extra field");
+                    *v = readU64(&file[q]);
+                    q += 8;
+                }
+                break;
+            }
+            x = q + len;
+        }
         entries.push_back(CentralDirEntry{std::move(name), method, compressedSize, uncompressedSize, localHeaderOffset});
         p += 46 + nameLen + extraLen + commentLen;
     }

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/tests/test_scoping.cpp

@@ -195,3 +195,20 @@ TEST(SpecialVariables, PreviewIsAlwaysFalse) {
     ASSERT_EQ(msgs.size(), 1u) << (msgs.empty() ? "" : msgs[0]);
     EXPECT_EQ(msgs[0], "ECHO: false, true, \"r\"");
 }
+
+// OpenSCAD evaluates a reassigned variable once, at its FIRST assignment,
+// with its LAST value (parser.y's handle_assignment) -- in a module body or
+// a block as at the top level. Checked against OpenSCAD 2026.02.01.
+TEST(Scoping, ReassignedVariableTakesItsLastValueAtItsFirstPosition) {
+    std::vector<std::string> out;
+    evaluateSrc("x = 1;\ny = x * 10;\nx = 2;\necho(y = y);\n"
+                "module m() {\n  u = 1;\n  v = u * 10;\n  u = 2;\n  echo(v = v);\n}\nm();\n"
+                "if (true) { a = 1; b = a + 1; a = 5; echo(b = b); }\n",
+                [&](const std::string& m) { out.push_back(m); });
+    EXPECT_TRUE(anyContains(out, "ECHO: y = 20"));
+    EXPECT_TRUE(anyContains(out, "ECHO: v = 20"));
+    EXPECT_TRUE(anyContains(out, "ECHO: b = 6"));
+    size_t warnings = 0;
+    for (const auto& m : out) warnings += m.find("but was overwritten") != std::string::npos;
+    EXPECT_EQ(warnings, 3u) << "one per reassignment, even though m() could run again";
+}

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/tests/test_use.cpp

@@ -173,3 +173,34 @@ TEST(UseStatement, MainFileGlobalReadFromFunctionIsStable) {
     EXPECT_EQ(echoed[2], "ECHO: undef");
     std::filesystem::remove(main);
 }
+
+// BelfrySCAD #809: OpenSCAD evaluates a reassigned variable at its FIRST
+// assignment with its LAST value, so a main file overriding an included
+// library's default changes everything the library derives from it -- the
+// standard way to configure a library. And it says nothing: overriding an
+// included file's variable is configuration, not a mistake. Expected values
+// and warnings checked against OpenSCAD 2026.02.01.
+TEST(IncludeReassignment, MainFileOverrideReachesValuesTheLibraryDerives) {
+    auto lib = writeFile("reassign_lib.scad", "x = 1;\ny = x * 10;\no = object(k = 5);\np = o.k;\n");
+    auto main = writeFile("reassign_main.scad", "include <" + lib.string() + ">\n"
+                                                 "x = 2;\no = object(k = 7);\necho(y = y, p = p);\n");
+    std::vector<std::string> out;
+    evalFile(main, [&](const std::string& m) { out.push_back(m); });
+    ASSERT_EQ(out.size(), 1u) << "no warnings: overriding an include is configuration";
+    EXPECT_EQ(out[0], "ECHO: y = 20, p = 7");
+    std::filesystem::remove(lib);
+    std::filesystem::remove(main);
+}
+
+TEST(IncludeReassignment, IncludeOverwritingTheMainFileWarnsNamingIt) {
+    auto lib = writeFile("reassign_lib2.scad", "a = 1;\n");
+    auto main = writeFile("reassign_main2.scad", "a = 2;\ninclude <" + lib.string() + ">\necho(a = a);\n");
+    std::vector<std::string> out;
+    evalFile(main, [&](const std::string& m) { out.push_back(m); });
+    ASSERT_EQ(out.size(), 2u);
+    EXPECT_EQ(out[0], "WARNING: a was assigned on line 1 of " + main.filename().string() +
+                          " but was overwritten in file " + lib.string() + ", line 1");
+    EXPECT_EQ(out[1], "ECHO: a = 1");
+    std::filesystem::remove(lib);
+    std::filesystem::remove(main);
+}

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/tests/test_zip_stored.cpp

@@ -253,3 +253,90 @@ TEST(ZipStored, StoredZipWritesMethod0) {
     EXPECT_EQ(centralDirMethodBySuffix(path.string(), "3dmodel.model"), 0);
     std::filesystem::remove(path);
 }
+
+TEST(ZipStored, ReadsZip64Archive) {
+    // The shape lib3mf writes (BelfrySCAD #800): every size and offset in the
+    // central directory and classic end record all ones, the real values in a
+    // ZIP64 extra field and a ZIP64 end record found through its locator.
+    const std::string name = "3D/3dmodel.model";
+    const std::string content = "zip64 payload";
+    std::vector<uint8_t> out;
+
+    putLE<uint32_t>(out, 0x04034b50u);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, static_cast<uint32_t>(content.size()));
+    putLE<uint32_t>(out, static_cast<uint32_t>(content.size()));
+    putLE<uint16_t>(out, static_cast<uint16_t>(name.size()));
+    putLE<uint16_t>(out, 0);
+    out.insert(out.end(), name.begin(), name.end());
+    out.insert(out.end(), content.begin(), content.end());
+
+    const uint64_t cdStart = out.size();
+    putLE<uint32_t>(out, 0x02014b50u);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint16_t>(out, static_cast<uint16_t>(name.size()));
+    putLE<uint16_t>(out, 4 + 24 + 4 + 4); // an unrelated field first, then ZIP64
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    out.insert(out.end(), name.begin(), name.end());
+    putLE<uint16_t>(out, 0x5455);
+    putLE<uint16_t>(out, 4);
+    putLE<uint32_t>(out, 0);
+    putLE<uint16_t>(out, 0x0001);
+    putLE<uint16_t>(out, 24);
+    putLE<uint64_t>(out, content.size());
+    putLE<uint64_t>(out, content.size());
+    putLE<uint64_t>(out, 0);
+    const uint64_t cdSize = out.size() - cdStart;
+
+    const uint64_t z64 = out.size();
+    putLE<uint32_t>(out, 0x06064b50u);
+    putLE<uint64_t>(out, 44);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 45);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint64_t>(out, 1);
+    putLE<uint64_t>(out, 1);
+    putLE<uint64_t>(out, cdSize);
+    putLE<uint64_t>(out, cdStart);
+
+    putLE<uint32_t>(out, 0x07064b50u);
+    putLE<uint32_t>(out, 0);
+    putLE<uint64_t>(out, z64);
+    putLE<uint32_t>(out, 1);
+
+    putLE<uint32_t>(out, 0x06054b50u);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0xFFFF);
+    putLE<uint16_t>(out, 0xFFFF);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint16_t>(out, 0);
+
+    const auto path = tempPath("zip64.zip");
+    {
+        std::ofstream f(path, std::ios::binary);
+        f.write(reinterpret_cast<const char*>(out.data()), static_cast<std::streamsize>(out.size()));
+    }
+    const std::vector<uint8_t> read = readStoredZipEntry(path.string(), name);
+    EXPECT_EQ(std::string(read.begin(), read.end()), content);
+    std::filesystem::remove(path);
+}

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.3}/uv.lock

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