openscad-cpp-evaluator 0.4.3__tar.gz → 0.4.5__tar.gz

{openscad_cpp_evaluator-0.4.3 → openscad_cpp_evaluator-0.4.5}/PKG-INFO

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

{openscad_cpp_evaluator-0.4.3 → openscad_cpp_evaluator-0.4.5}/include/openscad_cpp_evaluator/scope_trail.hpp

@@ -55,7 +55,25 @@ public:
     }
 
     void set(const std::string& name, T value, int level) {
-        stacks_[name].push_back(Entry{std::move(value), level});
+        std::vector<Entry>& vec = stacks_[name];
+        // A rebind of the SAME name at the level that's already current
+        // (a for-loop variable set every iteration without opening a new
+        // level each time, e.g. C-style for's init/incr -- see
+        // expr_eval.cpp's ListCompCFor case) overwrites the existing
+        // top-of-stack entry in place instead of pushing another one: a
+        // 999,999-iteration loop used to accumulate 999,999 Entry objects
+        // (and 999,999 duplicate name copies in dirty_[level]) that were
+        // never read again, all held until the level closed and popLevel()
+        // walked and popped every one of them in a single O(N) sweep.
+        // Nothing ever reads a stale same-level entry once a newer one at
+        // that same level exists (a level is one scope instantiation,
+        // never reopened), so this is a pure win, not just a memory
+        // optimization: it also collapses that O(N) unwind to O(1).
+        if (!vec.empty() && vec.back().level == level) {
+            vec.back().value = std::move(value);
+            return;
+        }
+        vec.push_back(Entry{std::move(value), level});
         dirty_[level].push_back(name);
     }
 
@@ -117,6 +135,17 @@ public:
 
     bool has(const std::string& name, int myLevel) const { return lookup(name, myLevel) != nullptr; }
 
+    // Test-only introspection: how many physical Entry objects exist for
+    // `name` (across every level, not just the current one) -- lets
+    // ScopeTrailStorageTest assert the same-level-overwrite optimization
+    // actually bounds growth (a for-loop variable set N times at one level
+    // should hold ~1 entry, not N), not just that lookup() still returns
+    // the right value either way.
+    size_t debugEntryCountForTesting(const std::string& name) const {
+        auto it = stacks_.find(name);
+        return it == stacks_.end() ? 0 : it->second.size();
+    }
+
     // Ancestry-filtered snapshot -- O(total distinct names ever bound so
     // far in the whole evaluation), not O(names visible now). Only used
     // by debug-REPL/children()-splice enumeration (never a hot path); see
@@ -258,7 +287,20 @@ public:
     void set(const std::string& name, T value, int level) {
         int id = intern_->idFor(name);
         ensureSize(id);
-        stacks_[static_cast<size_t>(id)].push_back(Entry{std::move(value), level});
+        std::vector<Entry>& vec = stacks_[static_cast<size_t>(id)];
+        // Same same-level-overwrite optimization as ScopeTrailStorage::set()
+        // -- see that one's doc comment for the full rationale. Applies
+        // here too: e.g. `$fn = 1; $fn = 2;` as sibling top-level
+        // statements share one level (evalChildren's per-statement
+        // EvalContext only swaps `scope`, aliasing the same trail/level --
+        // see EvalContext::withScope's own doc comment), so repeated
+        // same-block reassignment of a $-variable used to accumulate
+        // entries here exactly like a for-loop's plain variable did.
+        if (!vec.empty() && vec.back().level == level) {
+            vec.back().value = std::move(value);
+            return;
+        }
+        vec.push_back(Entry{std::move(value), level});
         dirty_[level].push_back(id);
     }
 
@@ -299,6 +341,12 @@ public:
 
     bool has(const std::string& name, int myLevel) const { return lookup(name, myLevel) != nullptr; }
 
+    // See ScopeTrailStorage::debugEntryCountForTesting's own doc comment.
+    size_t debugEntryCountForTesting(const std::string& name) const {
+        int id = intern_->idFor(name);
+        return id >= 0 && static_cast<size_t>(id) < stacks_.size() ? stacks_[static_cast<size_t>(id)].size() : 0;
+    }
+
     std::vector<std::pair<std::string, T>> items(int myLevel) const {
         std::vector<std::pair<std::string, T>> result;
         for (size_t id = 0; id < stacks_.size(); ++id) {

{openscad_cpp_evaluator-0.4.3 → openscad_cpp_evaluator-0.4.5}/include/openscad_cpp_evaluator/value.hpp

@@ -2,6 +2,7 @@
 
 #include "openscad_cpp_evaluator/osc_range.hpp"
 
+#include <functional>
 #include <memory>
 #include <optional>
 #include <string>
@@ -265,6 +266,13 @@ private:
     mutable std::optional<Cursor> cursor_;
 };
 
+// Called (count = the range's own requested element count) when a range
+// would be rejected for having too many elements -- see expandIterable's
+// own doc comment. The caller's own warn(message, position) already knows
+// how to format/emit a WARNING; this just hands back the number to put in
+// it, keeping expandIterable() itself free of any Evaluator/echo coupling.
+using RangeTooManyFn = std::function<void(size_t count)>;
+
 // Converts a for()/intersection_for() loop assignment's evaluated RHS into
 // the sequence of values to iterate: undef -> empty, range -> a LAZY
 // sequence (matching OscRange's own start/step/end iteration, half-open
@@ -275,7 +283,22 @@ private:
 // IterableValues), anything else (a bare scalar) -> a single-element
 // list. Mirrors the shared expansion logic duplicated across the
 // reference's _eval_for/_resolve_intersection_for.
-IterableValues expandIterable(const Value& v);
+//
+// A range whose own element count would be >= 1,000,000 is rejected
+// entirely (onTooMany called, empty result returned) rather than iterated
+// -- verified empirically against real OpenSCAD.app: a range producing
+// exactly 999,999 elements iterates fine; exactly 1,000,000 emits
+// "WARNING: Bad range parameter in for statement: too many elements (N)"
+// and contributes zero iterations (not a truncation to 999,999, not an
+// error like the C-style for's own _MAX_CFOR_ITERATIONS limit -- a
+// different mechanism entirely, checked per-range, not against a
+// cartesian-product total across a multi-variable for()). The Python
+// reference (openscad_evaluator) has no equivalent check at all -- this
+// was a real gap in both ports, closed here first since this port is the
+// one with a live consumer (BelfrySCAD) that surfaced it. The count is
+// computed in closed form (not IterableValues::size()'s O(n) walk) so a
+// legitimate huge-but-under-the-limit range never pays an eager pass.
+IterableValues expandIterable(const Value& v, const RangeTooManyFn& onTooMany = nullptr);
 
 // `each <body>`'s own flatten-one-level rule, shared by the AST interpreter
 // (evalListLiteral/evalListElement's ListCompEach handling, expr_eval.cpp)

{openscad_cpp_evaluator-0.4.3 → openscad_cpp_evaluator-0.4.5}/pyproject.toml

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

{openscad_cpp_evaluator-0.4.3 → openscad_cpp_evaluator-0.4.5}/src/builtins/control.cpp

@@ -101,7 +101,10 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
     varSeqs.reserve(node.assignments.size());
     for (const auto& assign : node.assignments) {
         Value values = ev.evalExpr(*assign->expr, ctx);
-        varSeqs.emplace_back(assign->name->name, expandIterable(values));
+        const oscad::Position* pos = &assign->position();
+        varSeqs.emplace_back(assign->name->name, expandIterable(values, [&](size_t count) {
+            ev.warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")", pos);
+        }));
     }
 
     std::vector<const oscad::ASTNode*> bodyNodes;

{openscad_cpp_evaluator-0.4.3 → openscad_cpp_evaluator-0.4.5}/src/bytecode_vm.cpp

@@ -240,7 +240,9 @@ Value runChunk(Evaluator& ev, const CompiledChunk& chunk, const std::vector<Inst
                 Value v = std::move(stack.back());
                 stack.pop_back();
                 IterList& il = iterLists[static_cast<size_t>(ins.a)];
-                il.values = expandIterable(v);
+                il.values = expandIterable(v, [&](size_t count) {
+                    ev.warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")", ins.pos);
+                });
                 il.index = 0;
                 ++pc;
                 break;

{openscad_cpp_evaluator-0.4.3 → openscad_cpp_evaluator-0.4.5}/src/expr_eval.cpp

@@ -136,7 +136,10 @@ void Evaluator::evalListElement(const oscad::ASTNode& elem, EvalContext& ctx, st
             pairs.reserve(n.assignments.size());
             for (const auto& assign : n.assignments) {
                 Value values = evalExpr(*assign->expr, ctx);
-                pairs.push_back(Pair{assign->name->name, expandIterable(values)});
+                const oscad::Position* pos = &assign->position();
+                pairs.push_back(Pair{assign->name->name, expandIterable(values, [&](size_t count) {
+                    warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")", pos);
+                })});
             }
             const bool isNestedLc = (n.body->kind() == oscad::NodeKind::ListComprehension);
 

{openscad_cpp_evaluator-0.4.3 → openscad_cpp_evaluator-0.4.5}/src/stmt_eval.cpp

@@ -79,7 +79,10 @@ void Evaluator::evalFor(const oscad::ModularFor& node, EvalContext& ctx) {
     pairs.reserve(node.assignments.size());
     for (const auto& assign : node.assignments) {
         Value values = evalExpr(*assign->expr, ctx);
-        pairs.push_back(AssignPair{assign->name->name, expandIterable(values)});
+        const oscad::Position* pos = &assign->position();
+        pairs.push_back(AssignPair{assign->name->name, expandIterable(values, [&](size_t count) {
+            warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")", pos);
+        })});
     }
 
     std::vector<const oscad::ASTNode*> bodyNodes;

{openscad_cpp_evaluator-0.4.3 → openscad_cpp_evaluator-0.4.5}/src/value.cpp

@@ -328,9 +328,25 @@ std::string fmtValue(const Value& v) {
     return "<function-literal>"; // const FunctionLiteral* -- no meaningful textual form in the reference either
 }
 
-IterableValues expandIterable(const Value& v) {
+// (Range::numValues()'s own count, closed-form) -- 1 + floor((end-start)/step),
+// the same epsilon IterableValues::inRange uses so this agrees exactly with
+// how many elements a lazy walk of the same range would actually produce.
+// nullopt for a step of 0 or a direction that disagrees with start/end (a
+// naturally-empty range -- 0 elements, never "too many").
+std::optional<size_t> rangeElementCount(const OscRange& r) {
+    if (r.step == 0.0) return std::nullopt;
+    const double n = (r.end - r.start) / r.step;
+    if (n < -1e-10) return std::nullopt; // wrong direction -- naturally empty
+    return static_cast<size_t>(std::floor(n + 1e-10)) + 1;
+}
+
+IterableValues expandIterable(const Value& v, const RangeTooManyFn& onTooMany) {
     if (std::holds_alternative<std::monostate>(v)) return IterableValues{};
     if (const OscRange* r = std::get_if<OscRange>(&v)) {
+        if (const std::optional<size_t> count = rangeElementCount(*r); count && *count >= 1'000'000) {
+            if (onTooMany) onTooMany(*count);
+            return IterableValues{};
+        }
         // Lazy -- IterableValues itself reproduces this exact
         // termination condition (a zero step is naturally empty: neither
         // `x <= end` nor `x >= end` branch ever fires for it) without

{openscad_cpp_evaluator-0.4.3 → openscad_cpp_evaluator-0.4.5}/tests/CMakeLists.txt

@@ -10,6 +10,7 @@ FetchContent_MakeAvailable(googletest)
 add_executable(oscad_eval_tests
   test_value.cpp
   test_eval_context.cpp
+  test_scope_trail.cpp
   test_scoping.cpp
   test_bytecode_compiler.cpp
   test_expr_eval.cpp

openscad_cpp_evaluator-0.4.5/tests/test_scope_trail.cpp

@@ -0,0 +1,79 @@
+#include "openscad_cpp_evaluator/scope_trail.hpp"
+
+#include <gtest/gtest.h>
+
+namespace oscadeval {
+namespace {
+
+TEST(ScopeTrailStorage, SetAtSameLevelOverwritesLatestValue) {
+    ScopeTrailStorage<int> storage;
+    const int level = storage.openLevel(0);
+    storage.set("i", 1, level);
+    storage.set("i", 2, level);
+    storage.set("i", 3, level);
+    ASSERT_NE(storage.lookup("i", level), nullptr);
+    EXPECT_EQ(*storage.lookup("i", level), 3);
+}
+
+TEST(ScopeTrailStorage, SetAtSameLevelDoesNotAccumulateEntries) {
+    // The actual optimization this session added: repeated set() calls at
+    // the SAME level (a for-loop variable rebound every iteration without
+    // opening a new level, or sibling same-block statements reassigning
+    // the same name) must overwrite in place, not grow the underlying
+    // stack -- verified via the test-only accessor, since correctness
+    // alone (SetAtSameLevelOverwritesLatestValue above) can't distinguish
+    // "overwrote in place" from "pushed and lookup() happens to find the
+    // newest one anyway."
+    ScopeTrailStorage<int> storage;
+    const int level = storage.openLevel(0);
+    for (int i = 0; i < 1000; ++i) storage.set("i", i, level);
+    EXPECT_EQ(storage.debugEntryCountForTesting("i"), 1u);
+}
+
+TEST(ScopeTrailStorage, SetAtANewLevelStillPushes) {
+    // The optimization must not collapse GENUINE nested bindings -- a
+    // child level's own set() for the same name is a real new binding
+    // (must be poppable back to the parent's value), not a same-level
+    // rebind.
+    ScopeTrailStorage<int> storage;
+    const int parentLevel = storage.openLevel(0);
+    storage.set("x", 1, parentLevel);
+    const int childLevel = storage.openLevel(parentLevel);
+    storage.set("x", 2, childLevel);
+    EXPECT_EQ(storage.debugEntryCountForTesting("x"), 2u);
+    ASSERT_NE(storage.lookup("x", childLevel), nullptr);
+    EXPECT_EQ(*storage.lookup("x", childLevel), 2);
+    storage.popLevel(childLevel);
+    ASSERT_NE(storage.lookup("x", parentLevel), nullptr);
+    EXPECT_EQ(*storage.lookup("x", parentLevel), 1);
+}
+
+TEST(ScopeTrailStorage, PopLevelAfterManySameLevelSetsRestoresParentValue) {
+    // The end-to-end correctness case a for-loop actually exercises: many
+    // same-level rebinds of the loop variable, then the level closes
+    // (loop exits) -- the parent's own binding for that name (if any) must
+    // resurface untouched, and the now-closed level's value must not leak.
+    ScopeTrailStorage<int> storage;
+    const int parentLevel = storage.openLevel(0);
+    storage.set("i", -1, parentLevel);
+    const int loopLevel = storage.openLevel(parentLevel);
+    for (int i = 0; i < 999; ++i) storage.set("i", i, loopLevel);
+    ASSERT_NE(storage.lookup("i", loopLevel), nullptr);
+    EXPECT_EQ(*storage.lookup("i", loopLevel), 998);
+    storage.popLevel(loopLevel);
+    ASSERT_NE(storage.lookup("i", parentLevel), nullptr);
+    EXPECT_EQ(*storage.lookup("i", parentLevel), -1);
+}
+
+TEST(IndexedScopeTrailStorage, SetAtSameLevelDoesNotAccumulateEntries) {
+    auto intern = std::make_shared<DynNameIntern>();
+    IndexedScopeTrailStorage<int> storage(intern);
+    const int level = storage.openLevel(0);
+    for (int i = 0; i < 1000; ++i) storage.set("$fn", i, level);
+    EXPECT_EQ(storage.debugEntryCountForTesting("$fn"), 1u);
+    ASSERT_NE(storage.lookup("$fn", level), nullptr);
+    EXPECT_EQ(*storage.lookup("$fn", level), 999);
+}
+
+} // namespace
+} // namespace oscadeval

{openscad_cpp_evaluator-0.4.3 → openscad_cpp_evaluator-0.4.5}/tests/test_value.cpp

@@ -364,12 +364,14 @@ TEST(ExpandIterable, OutOfOrderIndexAccessStillReturnsCorrectValue) {
 }
 
 TEST(ExpandIterable, LargeRangePartialIterationStaysLazy) {
-    // A huge range must not eagerly materialize a vector: constructing
-    // expandIterable() and reading only the first few elements has to
-    // stay instant regardless of the range's nominal size (a billion
-    // elements here). If this regresses to eager expansion, this test
-    // times out/OOMs instead of merely failing an assertion.
-    auto items = expandIterable(Value{OscRange{0, 1, 1'000'000'000.0}});
+    // A huge (but under the 1,000,000-element "too many" limit -- see the
+    // TooManyElements tests below) range must not eagerly materialize a
+    // vector: constructing expandIterable() and reading only the first few
+    // elements has to stay instant regardless of the range's nominal size
+    // (999,999 elements here, the largest value that doesn't trigger
+    // rejection). If this regresses to eager expansion, this test times
+    // out/OOMs instead of merely failing an assertion.
+    auto items = expandIterable(Value{OscRange{0, 1, 999'998.0}});
     auto it = items.begin();
     EXPECT_DOUBLE_EQ(asNum(*it), 0.0);
     ++it;
@@ -377,3 +379,58 @@ TEST(ExpandIterable, LargeRangePartialIterationStaysLazy) {
     ++it;
     EXPECT_DOUBLE_EQ(asNum(*it), 2.0);
 }
+
+TEST(ExpandIterable, RangeUnderOneMillionElementsIteratesNormally) {
+    // 999,999 elements (indices 0..999998) -- the largest range that must
+    // NOT be rejected. Verified against real OpenSCAD.app: this exact size
+    // iterates fine, one more element does not (see the next two tests).
+    bool warned = false;
+    auto items = expandIterable(Value{OscRange{0, 1, 999'998.0}}, [&](size_t) { warned = true; });
+    EXPECT_FALSE(warned);
+    EXPECT_EQ(items.size(), 999'999u);
+}
+
+TEST(ExpandIterable, RangeOfExactlyOneMillionElementsIsRejected) {
+    // 1,000,000 elements (indices 0..999999) -- real OpenSCAD.app rejects
+    // the whole range at exactly this size (WARNING + zero iterations, not
+    // a truncation to 999,999) -- a different mechanism from the C-style
+    // for loop's own _MAX_CFOR_ITERATIONS, which instead ALLOWS exactly
+    // 1,000,000 iterations and only errors past it. Verified empirically:
+    // these are genuinely different thresholds in real OpenSCAD, not a
+    // copy-paste of the same constant.
+    size_t warnedCount = 0;
+    auto items = expandIterable(Value{OscRange{0, 1, 999'999.0}}, [&](size_t count) { warnedCount = count; });
+    EXPECT_EQ(warnedCount, 1'000'000u);
+    EXPECT_EQ(items.size(), 0u);
+}
+
+TEST(ExpandIterable, HugeRangeIsRejectedInConstantTime) {
+    // The rejection check itself must be O(1) (closed-form), not a lazy
+    // walk to find out the count -- a billion-element range must reject
+    // instantly, not time out. This is exactly the case
+    // LargeRangePartialIterationStaysLazy used to (wrongly) exercise as
+    // "still iterable"; real OpenSCAD.app rejects it outright.
+    size_t warnedCount = 0;
+    auto items = expandIterable(Value{OscRange{0, 1, 1'000'000'000.0}}, [&](size_t count) { warnedCount = count; });
+    EXPECT_EQ(warnedCount, 1'000'000'001u);
+    EXPECT_EQ(items.size(), 0u);
+}
+
+TEST(ExpandIterable, NegativeStepRangeTooManyElementsIsRejectedToo) {
+    // Verified against real OpenSCAD.app: the too-many-elements check
+    // applies symmetrically to a descending range, with the correct count.
+    size_t warnedCount = 0;
+    auto items = expandIterable(Value{OscRange{1'099'999.0, -1, 0}}, [&](size_t count) { warnedCount = count; });
+    EXPECT_EQ(warnedCount, 1'100'000u);
+    EXPECT_EQ(items.size(), 0u);
+}
+
+TEST(ExpandIterable, ZeroStepRangeIsNaturallyEmptyNotTooMany) {
+    // A zero step never terminates by walking, but must not be
+    // misclassified as "too many" either -- it's naturally empty (0
+    // elements), no warning.
+    bool warned = false;
+    auto items = expandIterable(Value{OscRange{0, 0, 10}}, [&](size_t) { warned = true; });
+    EXPECT_FALSE(warned);
+    EXPECT_EQ(items.size(), 0u);
+}