openscad-cpp-evaluator 1.34.0__tar.gz → 1.36.0__tar.gz

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/.github/workflows/ci.yml

@@ -50,8 +50,21 @@ jobs:
       # Linux/macOS use (CMAKE_BUILD_TYPE already picked the config), but
       # required on Windows's default multi-config Visual Studio
       # generator, which ignores CMAKE_BUILD_TYPE entirely.
+      # A bounded job count on the Unix runners. A bare `-j` becomes `make -j`,
+      # which starts EVERY compile at once; on macos-latest (3 vCPU, 7 GB) a
+      # pile of template-heavy translation units that size ran the build at
+      # 852-2000 s against Linux's ~300 s. Windows keeps the bare -j: MSBuild
+      # reads it as "use the cores", which is already bounded.
       - name: Build
-        run: cmake --build build --config Release -j
+        shell: bash
+        run: |
+          case "$RUNNER_OS" in
+            macOS) JOBS=$(sysctl -n hw.ncpu) ;;
+            Linux) JOBS=$(nproc) ;;
+            *)     JOBS= ;;
+          esac
+          echo "building with -j ${JOBS:-<unbounded: MSBuild>}"
+          cmake --build build --config Release -j $JOBS
 
       # Bytecode VM on (the default as of the Phase 5 rollout decision --
       # see evaluator.hpp's own bytecodeVmEnabled() comment) and off

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/.github/workflows/wheels.yml

@@ -38,8 +38,16 @@ jobs:
             name: macos-arm64
           - runner: macos-15-intel
             name: macos-x86_64
+          # Two Windows jobs, one per architecture, both on the x86_64 runner
+          # (ARM64 is cross-compiled; see CIBW_ARCHS_WINDOWS). As one job they
+          # built one after the other -- 7 min each, 14.5 min for the job,
+          # the slowest in the release -- when neither needs the other.
           - runner: windows-latest
             name: windows-x86_64
+            archs: AMD64
+          - runner: windows-latest
+            name: windows-arm64
+            archs: ARM64
     runs-on: ${{ matrix.runner }}
     steps:
       - uses: actions/checkout@v7
@@ -65,7 +73,7 @@ jobs:
           # ARM64 build at all, so building on an ARM runner would have to
           # emulate it. cibuildwheel skips CIBW_TEST_COMMAND for the
           # cross-compiled wheel, since an x86_64 host cannot run it.
-          CIBW_ARCHS_WINDOWS: "AMD64 ARM64"
+          CIBW_ARCHS_WINDOWS: ${{ matrix.archs }}
           # delvewheel vendors the MSVC runtime into the wheel, but on an
           # x86_64 host it can only find the x86_64 copy -- repairing the
           # cross-built ARM64 wheel died with "Unable to find library:

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/CLAUDE.md

@@ -9,7 +9,14 @@ OpenSCAD AST and produces Manifold CSG geometry. This port builds on two depende
 
 - `openscad_cpp_parser` (git submodule, `external/openscad_cpp_parser`) for lexing/parsing/AST/scope
 - Manifold (https://github.com/elalish/manifold) v3.5.2, pulled in via CMake `FetchContent` (pinned
-  tag, not vendored) — wired in as of Phase 2
+  tag, not vendored) — wired in as of Phase 2. **Patched at fetch time** by
+  `cmake/patch_manifold.cmake`: it deletes the `combined.RemoveDegenerates()` call in
+  `CsgLeafNode::Compose`, which on some inputs leaves the face data inconsistent so the sort after
+  it reads past an array (heap-buffer-overflow under ASan, reached by
+  `MinkowskiDifference.ShrinksANonConvexBodyOnEverySide`). Bisected with a Manifold-only repro to
+  upstream #1789 (969b1417), which fixes it by deleting the same call; unreleased as of 3.5.4.
+  The script fails the configure if the source around the call has changed, so **drop the patch
+  when bumping past #1789** rather than letting it rot
 - Boost.Polygon (`boostorg/polygon` + `boostorg/config`, fetched individually — not the full Boost
   superproject) for `roof()`'s Voronoi-diagram construction — wired in as of Phase 6, see below
 - `nothings/stb` (`stb_image.h`; header-only, no build step) for `surface()`'s PNG loader — wired

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/CMakeLists.txt

@@ -79,6 +79,15 @@ if(MSVC)
   # unconditionally (a POSIX extension our code already relies on), so no
   # equivalent is needed there.
   add_compile_definitions(_USE_MATH_DEFINES)
+  # /MP: compile a target's source files in parallel. MSBuild's own /m (what
+  # `cmake --build -j` passes) runs PROJECTS in parallel but each project's
+  # files one at a time, and nearly everything here is one big library, so a
+  # Windows build was close to serial (CI's Build step ~665 s against Linux's
+  # ~250). Visual Studio generators only: under Ninja every compiler call is
+  # already one file, and Ninja does the parallelism itself.
+  if(CMAKE_GENERATOR MATCHES "Visual Studio")
+    add_compile_options(/MP)
+  endif()
 endif()
 
 # The nanobind Python extension (bindings/) links the static evaluator lib
@@ -128,6 +137,9 @@ FetchContent_Declare(
   GIT_REPOSITORY https://github.com/elalish/manifold.git
   GIT_TAG v3.5.2
   GIT_SHALLOW TRUE
+  # Backports the one line of upstream #1789 that fixes a heap overflow in
+  # CsgLeafNode::Compose -- see cmake/patch_manifold.cmake.
+  PATCH_COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/patch_manifold.cmake
 )
 FetchContent_MakeAvailable(manifold)
 

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/bindings/module.cpp

@@ -73,9 +73,10 @@ oscadeval::Value pyToValue(nb::handle v) {
     if (nb::isinstance<nb::int_>(v) || nb::isinstance<nb::float_>(v)) return oscadeval::Value{nb::cast<double>(v)};
     if (nb::isinstance<nb::str>(v)) return oscadeval::Value{nb::cast<std::string>(v)};
     if (nb::isinstance<nb::list>(v) || nb::isinstance<nb::tuple>(v)) {
-        oscadeval::ValueList vl;
-        for (nb::handle item : nb::borrow<nb::sequence>(v)) vl.items.push_back(pyToValue(item));
-        return oscadeval::Value{oscadeval::ListPtr(std::make_shared<const oscadeval::ValueList>(std::move(vl)))};
+        std::vector<oscadeval::Value> items;
+        for (nb::handle item : nb::borrow<nb::sequence>(v)) items.push_back(pyToValue(item));
+        return oscadeval::Value{oscadeval::ListPtr(
+            oscadeval::makeList(std::move(items)))};
     }
     return oscadeval::Value{}; // monostate = undef
 }

openscad_cpp_evaluator-1.36.0/cmake/patch_manifold.cmake

@@ -0,0 +1,31 @@
+# Patches the fetched Manifold v3.5.2 source; run as its FetchContent
+# PATCH_COMMAND, in the source directory.
+#
+# CsgLeafNode::Compose calls RemoveDegenerates() on the combined mesh and
+# then sorts it, and on some inputs the cleanup leaves the face data
+# inconsistent: SortGeometry -> GatherFaces then reads past the end of an
+# array (a heap-buffer-overflow under AddressSanitizer). Our
+# MinkowskiDifference.ShrinksANonConvexBodyOnEverySide test reaches it;
+# reproduced with Manifold alone, and bisected upstream to elalish/manifold
+# #1789 ("Improved decimation", 969b1417), which fixes it by deleting this
+# same call -- the only part of that commit the fix needs. Not in any
+# release yet; drop this patch when Manifold is bumped past it.
+#
+# Idempotent: a re-run on already-patched source changes nothing. Anything
+# else -- the call or its surroundings changed -- is an error, so a version
+# bump can never silently skip the patch.
+set(file src/csg_tree.cpp)
+file(READ ${file} src)
+set(call "  // required to remove parts that are smaller than the tolerance\n  combined.RemoveDegenerates();\n")
+string(FIND "${src}" "${call}" at)
+if(at EQUAL -1)
+  string(FIND "${src}" "combined.RemoveDegenerates();" any)
+  if(NOT any EQUAL -1)
+    message(FATAL_ERROR "patch_manifold.cmake: ${file} changed around RemoveDegenerates(); update the patch")
+  endif()
+  message(STATUS "patch_manifold.cmake: already applied")
+  return()
+endif()
+string(REPLACE "${call}" "" src "${src}")
+file(WRITE ${file} "${src}")
+message(STATUS "patch_manifold.cmake: removed RemoveDegenerates() from CsgLeafNode::Compose")

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -170,7 +170,7 @@ struct VmFrame {
     std::vector<Value> slots;
     std::vector<Value> stack;
     std::vector<bool> bound;
-    std::vector<std::vector<Value>> accumStack;
+    std::vector<ListBuilder> accumStack;
     std::vector<IterList> iterLists;
     // std::deque, NOT vector: Evaluator::enterUserCall stores
     // CallStackFrame::bodyCtx as a pointer to ctxChain.back() (see

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/include/openscad_cpp_evaluator/value.hpp

@@ -2,7 +2,10 @@
 
 #include "openscad_cpp_evaluator/osc_range.hpp"
 
+#include <atomic>
+#include <cstdint>
 #include <functional>
+#include <initializer_list>
 #include <memory>
 #include <optional>
 #include <string>
@@ -98,11 +101,93 @@ inline std::shared_ptr<TrailView<Value>> capturedLetTrail(const Closure& c) {
     return std::static_pointer_cast<TrailView<Value>>(c.capturedLet);
 }
 
-// Defined after Value so both can hold Value by value -- the standard
-// recursive-variant pattern (indirection through a forward-declared,
-// heap-allocated aggregate).
+// A list's elements: a read-only view of the first `size()` elements of a
+// buffer that other lists may share. Lists that are prefixes of one another
+// share one buffer, which is what makes repeated appending cheap: `acc`
+// and `concat(acc, [x])` are the same buffer, the second one element
+// longer (listAppend). Defined after Value so both can hold Value by value
+// -- the standard recursive-variant pattern.
+//
+// The buffer only ever grows within the capacity it was given, so element
+// addresses never move while any view of it is alive, and an element, once
+// written, is never changed. `used` is how far the longest view reaches;
+// only a list ending exactly there may extend it, claiming the new slots
+// with one compare-and-swap, so two lists sharing a prefix can never write
+// the same slot (the loser copies).
+struct ListBuffer {
+    std::vector<Value> v;      // never reallocated once a list views it
+    std::atomic<uint32_t> used{0};   // with fromAppend, packs into one word
+    // Set when this buffer came from appending: a list that was appended
+    // to once is likely to be again, so ITS copies grow geometrically,
+    // while a one-off concat's result is allocated at exactly its size.
+    bool fromAppend = false;
+};
+
+// A list's elements: the first `size()` of a buffer. A list made by
+// makeList keeps its buffer in its own allocation (keep_ empty); one made by
+// appending in place views the buffer of the list it extends, and keep_
+// holds that list's allocation alive. The element pointer is cached, so a
+// read is one hop, as with a plain vector. Neither copyable nor movable:
+// an own-buffer view must never outlive the allocation it sits in.
+class ListItems {
+public:
+    ListItems() = default;
+    ListItems(const ListItems&) = delete;
+    ListItems& operator=(const ListItems&) = delete;
+
+    size_t size() const { return n_; }
+    bool empty() const { return n_ == 0; }
+    const Value* data() const { return data_; }
+    const Value* begin() const { return data_; }
+    const Value* end() const { return data_ + n_; }
+    const Value& operator[](size_t i) const { return data_[i]; }
+    const Value& at(size_t i) const;
+    const Value& front() const { return data_[0]; }
+    const Value& back() const { return data_[n_ - 1]; }
+    // A copy as a plain vector, for the few callers that build on one.
+    // Explicit, so a copy is never made by accident binding a reference.
+    explicit operator std::vector<Value>() const { return std::vector<Value>(begin(), end()); }
+    std::vector<Value> toVector() const { return std::vector<Value>(begin(), end()); }
+
+private:
+    std::shared_ptr<const void> keep_;
+    ListBuffer* buf_ = nullptr;
+    const Value* data_ = nullptr;
+    size_t n_ = 0;
+    friend ListPtr makeList(std::vector<Value> items);
+    friend ListPtr listAppend(const ListPtr& base, std::vector<Value>&& extra);
+};
+
 struct ValueList {
-    std::vector<Value> items;
+    ListItems items;
+};
+
+// A new list holding `items` (adopted, not copied): one allocation for the
+// list and its buffer together, plus the elements' own -- as many as a list
+// that was a plain vector cost.
+ListPtr makeList(std::vector<Value> items);
+inline ListPtr makeList() { return makeList(std::vector<Value>{}); }
+
+
+// `base` followed by `extra`, sharing base's buffer whenever base is the
+// longest list using it and the buffer has room: amortized O(|extra|)
+// rather than O(|base| + |extra|), which is what turns the idiomatic
+// tail-recursive accumulator, f(i, concat(acc, [x])), from quadratic into
+// linear. Safe whatever else still holds `base`: base keeps seeing only
+// its own elements.
+ListPtr listAppend(const ListPtr& base, std::vector<Value>&& extra);
+
+// Builds a list literal or comprehension result from its contributions. When
+// the first contribution is `each <a list>`, the result starts AS that list
+// and everything after it is appended with listAppend -- so the other
+// accumulator idiom, f(i, [each acc, x]), extends acc in place just as
+// concat(acc, [x]) does, instead of copying it.
+struct ListBuilder {
+    ListPtr seed;              // the list an `each` started from, if any
+    std::vector<Value> rest;   // everything contributed after it
+    void push(Value v) { rest.push_back(std::move(v)); }
+    void appendEach(const Value& v);   // as appendEachInto
+    ListPtr finish();
 };
 
 // Insertion-ordered key/value pairs, not a map: object()'s iteration order

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/src/builtins/booleans.cpp

@@ -143,9 +143,9 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
 
     CSGParams params;
     params["op"] = Value{op};
-    params["group_sizes"] = Value{std::make_shared<const ValueList>(ValueList{std::move(groupSizes)})};
+    params["group_sizes"] = Value{makeList(std::move(groupSizes))};
     params["empty_is_a_group"] =
-        Value{std::make_shared<const ValueList>(ValueList{std::move(emptyIsAGroup)})};
+        Value{makeList(std::move(emptyIsAGroup))};
     return params;
 }
 
@@ -313,7 +313,7 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
     const std::string& op = std::get<std::string>(params.at("op"));
     const auto& groupSizes = std::get<ListPtr>(params.at("group_sizes"))->items;
     const auto emptyIsAGroupIt = params.find("empty_is_a_group");
-    const std::vector<Value>* emptyIsAGroup =
+    const ListItems* emptyIsAGroup =
         emptyIsAGroupIt == params.end()
             ? nullptr
             : &std::get<ListPtr>(emptyIsAGroupIt->second)->items;

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/src/builtins/call_args.cpp

@@ -93,10 +93,10 @@ Value callArgsToValue(const CallArgs& args) {
     std::vector<std::pair<std::string, Value>> namedVec(args.named.begin(), args.named.end());
 
     std::vector<Value> outer = {
-        Value{std::make_shared<const ValueList>(ValueList{std::move(posVec)})},
+        Value{makeList(std::move(posVec))},
         Value{std::make_shared<const ValueObject>(ValueObject{std::move(namedVec)})},
     };
-    return Value{std::make_shared<const ValueList>(ValueList{std::move(outer)})};
+    return Value{makeList(std::move(outer))};
 }
 
 const oscad::Expression* argExpr(const oscad::Argument& arg) {

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/src/builtins/control.cpp

@@ -141,7 +141,7 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
     recurse(0, ctx);
 
     CSGParams params;
-    params["group_sizes"] = Value{std::make_shared<const ValueList>(ValueList{std::move(groupSizes)})};
+    params["group_sizes"] = Value{makeList(std::move(groupSizes))};
     return params;
 }
 

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/src/builtins/dxf_dim.cpp

@@ -234,7 +234,7 @@ Value builtinDxfCross(Evaluator& ev, const CallArgs& args, const oscad::ASTNode&
             if (dem == 0.0) break;   // parallel: no cross, same as the reference
             const double ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / dem;
             std::vector<Value> xy{Value{x1 + ua * (x2 - x1)}, Value{y1 + ua * (y2 - y1)}};
-            return Value{std::make_shared<const ValueList>(ValueList{std::move(xy)})};
+            return Value{makeList(std::move(xy))};
         }
     }
     ev.warn("Can't find cross in '" + c.rawFile + "', layer '" + c.layer + "'!", &node.position());

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/src/builtins/function_builtins.cpp

@@ -48,7 +48,7 @@ std::optional<std::vector<double>> allNumericList(const Value& v) {
     return out;
 }
 
-Value listOf(std::vector<Value> items) { return Value{std::make_shared<const ValueList>(ValueList{std::move(items)})}; }
+Value listOf(std::vector<Value> items) { return Value{makeList(std::move(items))}; }
 Value numList(const std::vector<double>& xs) {
     std::vector<Value> items;
     items.reserve(xs.size());
@@ -616,11 +616,11 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
     const unsigned numReturns = static_cast<unsigned>(static_cast<long long>(nrRaw));
     const unsigned indexCol = static_cast<unsigned>(static_cast<long long>(icRaw));
 
-    static const std::vector<Value> kNoItems;
+    static const ListItems kNoItems;
     const ListPtr* tablePtr = std::get_if<ListPtr>(&tableArg);
-    const std::vector<Value>& table = (tablePtr && *tablePtr) ? (*tablePtr)->items : kNoItems;
+    const ListItems& table = (tablePtr && *tablePtr) ? (*tablePtr)->items : kNoItems;
 
-    const auto itemsOf = [](const Value& v) -> const std::vector<Value>& {
+    const auto itemsOf = [](const Value& v) -> const ListItems& {
         const ListPtr* l = std::get_if<ListPtr>(&v);
         return (l && *l) ? (*l)->items : kNoItems;
     };
@@ -629,7 +629,7 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
     // only when the entry really is a long enough vector.
     const auto hits = [&](const Value& needle, const Value& entry) {
         if (indexCol == 0 && oscEqual(needle, entry)) return true;
-        const std::vector<Value>& ev2 = itemsOf(entry);
+        const ListItems& ev2 = itemsOf(entry);
         return indexCol < ev2.size() && oscEqual(needle, ev2[indexCol]);
     };
     const auto num = [](size_t j) { return Value{static_cast<double>(j)}; };
@@ -682,7 +682,7 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
             unsigned matchCount = 0;
             std::vector<Value> resultvec;
             for (size_t j = 0; j < table.size(); ++j) {
-                const std::vector<Value>& entryVec = itemsOf(table[j]);
+                const ListItems& entryVec = itemsOf(table[j]);
                 if (entryVec.size() <= indexCol) {
                     ev.warn("Invalid entry in search vector at index " + std::to_string(j) +
                                 ", required number of values in the entry: " + std::to_string(indexCol + 1) +
@@ -1162,9 +1162,9 @@ bool checkMinMax(Evaluator& ev, const std::string& name, const CallArgs& args, c
         return false;
     }
     if (nPos == 1 && std::holds_alternative<ListPtr>(positionalAt(args, 0))) {
-        static const std::vector<Value> kEmptyItems;
+        static const ListItems kEmptyItems;
         const ListPtr& l = std::get<ListPtr>(positionalAt(args, 0));
-        const std::vector<Value>& items = l ? l->items : kEmptyItems;
+        const ListItems& items = l ? l->items : kEmptyItems;
         if (items.empty()) {
             warnArity(ev, name, "at least 1 vector element", 0, pos);
             return false;
@@ -1346,14 +1346,21 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
                                  toDoubleLenient(getArg(args, 2, "value_count", Value{})), getArg(args, 3, "seed", Value{}));
         }
         case BuiltinFnId::Concat: {
+            // Everything after the first argument, appended to the first
+            // when it is a list: listAppend extends its buffer in place when
+            // it can, so an accumulator loop is linear, not quadratic.
+            const size_t count = positionalCount(args);
+            const ListPtr* first = count ? std::get_if<ListPtr>(&positionalAt(args, 0)) : nullptr;
             std::vector<Value> out;
-            for (const Value& a : allPositional(args)) {
+            for (size_t i = (first && *first) ? 1 : 0; i < count; ++i) {
+                const Value& a = positionalAt(args, i);
                 if (const ListPtr* l = std::get_if<ListPtr>(&a); l && *l) {
                     out.insert(out.end(), (*l)->items.begin(), (*l)->items.end());
                 } else {
                     out.push_back(a);
                 }
             }
+            if (first && *first) return Value{listAppend(*first, std::move(out))};
             return listOf(std::move(out));
         }
         case BuiltinFnId::Len: {

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/src/builtins/import.cpp

@@ -66,7 +66,7 @@ Value jsonToValue(const nlohmann::ordered_json& j) {
         std::vector<Value> items;
         items.reserve(j.size());
         for (const auto& el : j) items.push_back(jsonToValue(el));
-        return Value{std::make_shared<const ValueList>(ValueList{std::move(items)})};
+        return Value{makeList(std::move(items))};
     }
     if (j.is_object()) {
         std::vector<std::pair<std::string, Value>> items;
@@ -102,20 +102,19 @@ Value meshToVnf(const LoadedMesh& mesh) {
             if (it == vertMap.end()) {
                 idx = static_cast<int>(vertsOut.size());
                 vertMap.emplace(v, idx);
-                vertsOut.push_back(Value{std::make_shared<const ValueList>(
-                    ValueList{{Value{v[0]}, Value{v[1]}, Value{v[2]}}})});
+                vertsOut.push_back(Value{makeList({Value{v[0]}, Value{v[1]}, Value{v[2]}})});
             } else {
                 idx = it->second;
             }
             face.push_back(Value{static_cast<double>(idx)});
         }
-        facesOut.push_back(Value{std::make_shared<const ValueList>(ValueList{std::move(face)})});
+        facesOut.push_back(Value{makeList(std::move(face))});
     }
     std::vector<Value> outer = {
-        Value{std::make_shared<const ValueList>(ValueList{std::move(vertsOut)})},
-        Value{std::make_shared<const ValueList>(ValueList{std::move(facesOut)})},
+        Value{makeList(std::move(vertsOut))},
+        Value{makeList(std::move(facesOut))},
     };
-    return Value{std::make_shared<const ValueList>(ValueList{std::move(outer)})};
+    return Value{makeList(std::move(outer))};
 }
 
 } // namespace
@@ -152,10 +151,10 @@ Value contoursToValue(const std::vector<Contour2d>& contours) {
     for (const auto& c : contours) {
         std::vector<Value> pts;
         pts.reserve(c.size());
-        for (const auto& p : c) pts.push_back(Value{std::make_shared<const ValueList>(ValueList{{Value{p[0]}, Value{p[1]}}})});
-        outer.push_back(Value{std::make_shared<const ValueList>(ValueList{std::move(pts)})});
+        for (const auto& p : c) pts.push_back(Value{makeList({Value{p[0]}, Value{p[1]}})});
+        outer.push_back(Value{makeList(std::move(pts))});
     }
-    return Value{std::make_shared<const ValueList>(ValueList{std::move(outer)})};
+    return Value{makeList(std::move(outer))};
 }
 
 std::vector<Contour2d> valueToContours(const Value& v) {
@@ -284,8 +283,8 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
         params["kind"] = Value{std::string("mesh")};
         params["repair"] = Value{repair};
         params["tolerance"] = toleranceArg;
-        params["verts"] = Value{std::make_shared<const ValueList>(ValueList{std::move(vertsFlat)})};
-        params["tris"] = Value{std::make_shared<const ValueList>(ValueList{std::move(trisFlat)})};
+        params["verts"] = Value{makeList(std::move(vertsFlat))};
+        params["tris"] = Value{makeList(std::move(trisFlat))};
         return params;
     }
     if (ext == ".json") {

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/src/builtins/primitives_2d.cpp

@@ -79,9 +79,9 @@ CSGParams resolve2d(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
         const double x = (pl && *pl && !(*pl)->items.empty()) ? toDoubleLenient((*pl)->items[0]) : 0.0;
         const double y = (pl && *pl && (*pl)->items.size() > 1) ? toDoubleLenient((*pl)->items[1]) : 0.0;
         std::vector<Value> xy = {Value{x}, Value{y}};
-        pts.push_back(Value{std::make_shared<const ValueList>(ValueList{std::move(xy)})});
+        pts.push_back(Value{makeList(std::move(xy))});
     }
-    params["pts"] = Value{std::make_shared<const ValueList>(ValueList{std::move(pts)})};
+    params["pts"] = Value{makeList(std::move(pts))};
 
     if (const ListPtr* pathsList = std::get_if<ListPtr>(&pathsArg); pathsList && *pathsList) {
         std::vector<Value> paths;
@@ -91,9 +91,9 @@ CSGParams resolve2d(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
             if (pathIdxList && *pathIdxList) {
                 for (const Value& idx : (*pathIdxList)->items) idxVals.push_back(Value{toDoubleLenient(idx)});
             }
-            paths.push_back(Value{std::make_shared<const ValueList>(ValueList{std::move(idxVals)})});
+            paths.push_back(Value{makeList(std::move(idxVals))});
         }
-        params["paths"] = Value{std::make_shared<const ValueList>(ValueList{std::move(paths)})};
+        params["paths"] = Value{makeList(std::move(paths))};
     } else {
         params["paths"] = Value{}; // undef == "no paths given" -- pts is one single contour
     }

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/src/builtins/primitives_3d.cpp

@@ -133,7 +133,7 @@ CSGParams resolveCube(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     } else if (l && *l && (*l)->items.size() == 3 &&
                std::all_of((*l)->items.begin(), (*l)->items.end(),
                            [](const Value& v) { return std::holds_alternative<double>(v); })) {
-        sizeVec = (*l)->items;
+        sizeVec = (*l)->items.toVector();
     } else if (!std::holds_alternative<std::monostate>(sizeArg)) {
         ev.warn("Unable to convert cube(size=" + fmtValue(sizeArg) +
                     ", ...) parameter to a number or a vec3 of numbers",
@@ -141,7 +141,7 @@ CSGParams resolveCube(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     }
 
     CSGParams params;
-    params["size"] = Value{std::make_shared<const ValueList>(ValueList{std::move(sizeVec)})};
+    params["size"] = Value{makeList(std::move(sizeVec))};
     params["center"] = Value{center};
     params["color"] = colorToValue(effCtx.color);
     return params;
@@ -402,8 +402,8 @@ CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalConte
         // Manifold::Sphere IS a subdivided octahedron (Shape::Octahedron,
         // then Subdivide), so this needs no mesh of our own -- generate
         // calls it directly.
-        params["verts"] = Value{std::make_shared<const ValueList>(ValueList{})};
-        params["tris"] = Value{std::make_shared<const ValueList>(ValueList{})};
+        params["verts"] = Value{makeList()};
+        params["tris"] = Value{makeList()};
         return params;
     }
 
@@ -418,8 +418,8 @@ CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalConte
     std::vector<Value> trisValues;
     trisValues.reserve(m.tris.size());
     for (int t : m.tris) trisValues.push_back(Value{static_cast<double>(t)});
-    params["verts"] = Value{std::make_shared<const ValueList>(ValueList{std::move(vertsValues)})};
-    params["tris"] = Value{std::make_shared<const ValueList>(ValueList{std::move(trisValues)})};
+    params["verts"] = Value{makeList(std::move(vertsValues))};
+    params["tris"] = Value{makeList(std::move(trisValues))};
     return params;
 }
 
@@ -832,8 +832,8 @@ CSGParams resolvePolyhedron(Evaluator& ev, const oscad::ModularCall& node, EvalC
     for (uint32_t t : tris) trisValues.push_back(Value{static_cast<double>(t)});
 
     CSGParams params;
-    params["verts"] = Value{std::make_shared<const ValueList>(ValueList{std::move(vertsValues)})};
-    params["tris"] = Value{std::make_shared<const ValueList>(ValueList{std::move(trisValues)})};
+    params["verts"] = Value{makeList(std::move(vertsValues))};
+    params["tris"] = Value{makeList(std::move(trisValues))};
     params["color"] = colorToValue(effCtx.color);
     return params;
 }

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/src/builtins/surface.cpp

@@ -44,9 +44,9 @@ CSGParams resolveSurface(Evaluator& ev, const oscad::ModularCall& node, EvalCont
         std::vector<Value> rowVals;
         rowVals.reserve(row.size());
         for (double v : row) rowVals.push_back(Value{v});
-        rows.push_back(Value{std::make_shared<const ValueList>(ValueList{std::move(rowVals)})});
+        rows.push_back(Value{makeList(std::move(rowVals))});
     }
-    params["heights"] = Value{std::make_shared<const ValueList>(ValueList{std::move(rows)})};
+    params["heights"] = Value{makeList(std::move(rows))};
     return params;
 }
 

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/src/builtins/text.cpp

@@ -69,8 +69,7 @@ CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     std::vector<Value> glyphs;
     glyphs.reserve(m.glyphs.size());
     for (const TextMeasurement::Placed& g : m.glyphs) {
-        glyphs.push_back(Value{std::make_shared<const ValueList>(
-            ValueList{{Value{static_cast<double>(g.glyph)}, Value{g.x}, Value{g.y}}})});
+        glyphs.push_back(Value{makeList({Value{static_cast<double>(g.glyph)}, Value{g.x}, Value{g.y}})});
     }
 
     CSGParams params;
@@ -89,7 +88,7 @@ CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     params["segs"] = Value{static_cast<double>(segs)};
     params["offset_x"] = Value{offsetX};
     params["offset_y"] = Value{offsetY};
-    params["glyphs"] = Value{std::make_shared<const ValueList>(ValueList{std::move(glyphs)})};
+    params["glyphs"] = Value{makeList(std::move(glyphs))};
     params["color"] = colorToValue(effCtx.color);
     return params;
 }

{openscad_cpp_evaluator-1.34.0 → openscad_cpp_evaluator-1.36.0}/src/bytecode_vm.cpp

@@ -792,7 +792,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                         items[count - 1 - i] = std::move(f.stack.back());
                         f.stack.pop_back();
                     }
-                    f.stack.push_back(Value{std::make_shared<const ValueList>(ValueList{std::move(items)})});
+                    f.stack.push_back(Value{makeList(std::move(items))});
                     ++f.pc;
                     break;
                 }
@@ -803,28 +803,28 @@ Value driveVm(Evaluator& ev, size_t floor) {
                 case Op::AccumAppendOne: {
                     Value v = std::move(f.stack.back());
                     f.stack.pop_back();
-                    f.accumStack.back().push_back(std::move(v));
+                    f.accumStack.back().push(std::move(v));
                     ++f.pc;
                     break;
                 }
                 case Op::AccumAppendEach: {
                     Value v = std::move(f.stack.back());
                     f.stack.pop_back();
-                    appendEachInto(f.accumStack.back(), v);
+                    f.accumStack.back().appendEach(v);
                     ++f.pc;
                     break;
                 }
                 case Op::AccumClose: {
-                    std::vector<Value> items = std::move(f.accumStack.back());
+                    ListPtr list = f.accumStack.back().finish();
                     f.accumStack.pop_back();
-                    f.stack.push_back(Value{std::make_shared<const ValueList>(ValueList{std::move(items)})});
+                    f.stack.push_back(Value{std::move(list)});
                     ++f.pc;
                     break;
                 }
                 case Op::AccumMergeEach: {
-                    std::vector<Value> inner = std::move(f.accumStack.back());
+                    const ListPtr inner = f.accumStack.back().finish();
                     f.accumStack.pop_back();
-                    for (const Value& item : inner) appendEachInto(f.accumStack.back(), item);
+                    for (const Value& item : inner->items) f.accumStack.back().appendEach(item);
                     ++f.pc;
                     break;
                 }
@@ -1492,9 +1492,8 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     CSGParams params;
                     if (site.includeOpParam) params["op"] = Value{pending.op};
                     params["group_sizes"] =
-                        Value{std::make_shared<const ValueList>(ValueList{std::move(pending.groupSizes)})};
-                    params["empty_is_a_group"] = Value{std::make_shared<const ValueList>(
-                        ValueList{std::move(pending.emptyIsAGroup)})};
+                        Value{makeList(std::move(pending.groupSizes))};
+                    params["empty_is_a_group"] = Value{makeList(std::move(pending.emptyIsAGroup))};
                     // Mirrors Evaluator::buildTreeNode's own post-
                     // resolveBody() half exactly (csg_resolve.cpp).
                     const bool uncacheable =