openscad-cpp-evaluator 1.35.0__tar.gz → 1.37.0__tar.gz

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.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
@@ -723,7 +730,14 @@ grep for `ponytail:`.
   parameter names live in `builtinParamNames` (`registry.cpp`): each list is the union of real
   OpenSCAD's own `Parameters::parse` declaration and any extra name this port reads via `getArg`,
   so the port never warns about an argument it goes on to honour — **add to it whenever a builtin
-  gains a parameter**, or that parameter starts warning. Builtin *functions* deliberately have no
+  gains a parameter**, or that parameter starts warning. **An argument given as `undef` is not given**: `getArg`
+  returns the default for it, as every upstream builtin does (`if (v.isDefined())`). Wrappers
+  forward their own optional parameters as undef -- BOSL2's `rotate_extrude` override passes
+  `angle=angle`, and reading that as 0 degrees flattened every plain `rotate_extrude()` (#680).
+  Checked argument by argument against OpenSCAD 2026.02 (47 cases, `tests/test_undef_args.cpp`).
+  Aliases (`linear_extrude`'s `h`, `rotate_extrude`'s `a`) go through `getArgOrAlias`, which
+  warns `Specified both "height" and "h"` as upstream and lets the primary name win.
+  `linear_extrude`'s default height is 100, upstream's (it was 1). Builtin *functions* deliberately have no
   entries beyond `textmetrics`/`fontmetrics`: upstream reads their arguments positionally without
   `Parameters::parse`, so `sin(bogus=30)` warns about nothing there (verified against 2022.08.22)
   and warning here would be a divergence. Not ported: the reference's `argument X supplied more

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.0}/CMakeLists.txt

@@ -137,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.35.0 → openscad_cpp_evaluator-1.37.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.0}/bindings/module.cpp

@@ -76,7 +76,7 @@ oscadeval::Value pyToValue(nb::handle v) {
         std::vector<oscadeval::Value> items;
         for (nb::handle item : nb::borrow<nb::sequence>(v)) items.push_back(pyToValue(item));
         return oscadeval::Value{oscadeval::ListPtr(
-            std::make_shared<const oscadeval::ValueList>(oscadeval::ValueList{std::move(items)}))};
+            oscadeval::makeList(std::move(items)))};
     }
     return oscadeval::Value{}; // monostate = undef
 }

openscad_cpp_evaluator-1.37.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.35.0 → openscad_cpp_evaluator-1.37.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.35.0 → openscad_cpp_evaluator-1.37.0}/include/openscad_cpp_evaluator/call_args.hpp

@@ -69,8 +69,20 @@ ResolvedCallArgs resolveCallArgs(Evaluator& ev, const std::vector<std::unique_pt
 // wins). `pos = std::nullopt` for an argument with no positional slot at
 // all (e.g. sphere's `d`, only ever named -- a later phase's need, plumbed
 // through now since the signature shape matters more than early callers).
+//
+// An argument given as undef counts as not given, as in every upstream
+// builtin (`if (v.isDefined()) ...`): rotate_extrude(angle=undef) is 360
+// degrees, not 0. It matters for wrappers that forward their own optional
+// parameters -- BOSL2's rotate_extrude override passes `angle=angle`, which
+// flattened every plain rotate_extrude() into its profile (#680).
 Value getArg(const CallArgs& args, std::optional<int> pos, const std::string& name, Value defaultValue = Value{});
 
+// getArg for a parameter with an alternative name (linear_extrude's
+// height/h, rotate_extrude's angle/a): `name` wins when both are given,
+// with upstream's warning.
+Value getArgOrAlias(Evaluator& ev, const oscad::Position* where, const CallArgs& args, std::optional<int> pos,
+                    const std::string& name, const std::string& alias, Value defaultValue);
+
 // Encodes a CallArgs as a single Value (positional -> a list indexed 0..N,
 // named -> an object) so a resolve function can carry a call's raw
 // arguments across into CSGParams (which only holds Value) for a generate

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.0}/include/openscad_cpp_evaluator/value.hpp

@@ -3,6 +3,7 @@
 #include "openscad_cpp_evaluator/osc_range.hpp"
 
 #include <atomic>
+#include <cstdint>
 #include <functional>
 #include <initializer_list>
 #include <memory>
@@ -114,41 +115,46 @@ inline std::shared_ptr<TrailView<Value>> capturedLetTrail(const Closure& c) {
 // 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;
-    std::atomic<size_t> used;
+    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;
-    explicit ListBuffer(std::vector<Value>&& items) : v(std::move(items)), used(v.size()) {}
 };
 
+// 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(std::vector<Value>&& items)                       // NOLINT: implicit, as the old vector was
-        : buf_(std::make_shared<ListBuffer>(std::move(items))), n_(buf_->v.size()) {}
-    ListItems(const std::vector<Value>& items) : ListItems(std::vector<Value>(items)) {}  // NOLINT
-    ListItems(std::initializer_list<Value> items) : ListItems(std::vector<Value>(items)) {}
+    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 buf_ ? buf_->v.data() : nullptr; }
-    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* 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]; }
+    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:
-    ListItems(std::shared_ptr<ListBuffer> buf, size_t n) : buf_(std::move(buf)), n_(n) {}
-    std::shared_ptr<ListBuffer> buf_;
+    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);
 };
 
@@ -156,6 +162,13 @@ struct ValueList {
     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
@@ -164,6 +177,19 @@ struct ValueList {
 // 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
 // and `==` are order-sensitive (doc: openscad_evaluator/docs/evaluator.md,
 // the object() entry).

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.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;
 }
 

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.0}/src/builtins/call_args.cpp

@@ -56,14 +56,31 @@ CallArgs resolveArgs(Evaluator& ev, const std::vector<std::unique_ptr<oscad::Arg
     return result;
 }
 
+namespace {
+bool isUndef(const Value& v) { return std::holds_alternative<std::monostate>(v); }
+} // namespace
+
 Value getArg(const CallArgs& args, std::optional<int> pos, const std::string& name, Value defaultValue) {
-    if (const Value* named = args.findNamed(name)) return *named;
+    if (const Value* named = args.findNamed(name); named && !isUndef(*named)) return *named;
     if (pos.has_value()) {
-        if (const Value* positional = args.findPositional(*pos)) return *positional;
+        if (const Value* positional = args.findPositional(*pos); positional && !isUndef(*positional))
+            return *positional;
     }
     return defaultValue;
 }
 
+Value getArgOrAlias(Evaluator& ev, const oscad::Position* where, const CallArgs& args, std::optional<int> pos,
+                    const std::string& name, const std::string& alias, Value defaultValue) {
+    const Value primary = getArg(args, pos, name, Value{});
+    const Value other = getArg(args, std::nullopt, alias, Value{});
+    if (!isUndef(primary)) {
+        if (!isUndef(other))
+            ev.warn("Specified both \"" + name + "\" and \"" + alias + "\"", where);
+        return primary;
+    }
+    return isUndef(other) ? defaultValue : other;
+}
+
 ResolvedCallArgs resolveCallArgs(Evaluator& ev, const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
                                   EvalContext& ctx) {
     CallArgs args = resolveArgs(ev, arguments, ctx);
@@ -93,10 +110,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.35.0 → openscad_cpp_evaluator-1.37.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.35.0 → openscad_cpp_evaluator-1.37.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.35.0 → openscad_cpp_evaluator-1.37.0}/src/builtins/extrude.cpp

@@ -118,7 +118,9 @@ manifold::Manifold extrudeTwisted(const manifold::Polygons& polys, double height
 BuiltinWrapParams computeLinearExtrudeParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
 
-    const double height = toDoubleLenient(getArg(args, 0, "height", Value{1.0}));
+    // 100 when not given, as upstream (the old 1 was a guess), and `h` as
+    // upstream's alias -- BOSL2's linear_extrude override forwards it.
+    const double height = toDoubleLenient(getArgOrAlias(ev, &node.position(), args, 0, "height", "h", Value{100.0}));
     const bool center = truthy(getArg(args, std::nullopt, "center", Value{false}));
     const double twist = toDoubleLenient(getArg(args, std::nullopt, "twist", Value{0.0}));
     // Upstream's validate_integral: any finite number counts as given, and is
@@ -239,7 +241,7 @@ std::vector<ColoredBody> generateLinearExtrude(Evaluator& ev, const CSGParams& p
 BuiltinWrapParams computeRotateExtrudeParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
 
-    const double angle = toDoubleLenient(getArg(args, 0, "angle", Value{360.0}));
+    const double angle = toDoubleLenient(getArgOrAlias(ev, &node.position(), args, 0, "angle", "a", Value{360.0}));
 
     CSGParams params;
     params["angle"] = Value{angle};

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.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());

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.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.35.0 → openscad_cpp_evaluator-1.37.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.35.0 → openscad_cpp_evaluator-1.37.0}/src/builtins/primitives_3d.cpp

@@ -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.35.0 → openscad_cpp_evaluator-1.37.0}/src/builtins/registry.cpp

@@ -125,8 +125,8 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         {"import",
           {"file", "layer", "convexity", "origin", "scale", "width", "height", "filename", "layername", "center", "dpi",
            "id", "class", "repair", "tolerance"}},
-        {"linear_extrude", {"height", "v", "scale", "center", "twist", "slices", "segments", "convexity"}},
-        {"rotate_extrude", {"angle", "start", "convexity"}},
+        {"linear_extrude", {"height", "h", "v", "scale", "center", "twist", "slices", "segments", "convexity"}},
+        {"rotate_extrude", {"angle", "a", "start", "convexity"}},
         {"projection", {"cut", "convexity"}},
         {"roof", {"method", "convexity"}},
         {"fill", {}},

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.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.35.0 → openscad_cpp_evaluator-1.37.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.35.0 → openscad_cpp_evaluator-1.37.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 =

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.0}/src/colored_body.cpp

@@ -5,7 +5,7 @@ namespace oscadeval {
 Value colorToValue(const std::optional<std::array<double, 4>>& color) {
     if (!color) return Value{};
     std::vector<Value> items = {Value{(*color)[0]}, Value{(*color)[1]}, Value{(*color)[2]}, Value{(*color)[3]}};
-    return Value{std::make_shared<const ValueList>(ValueList{std::move(items)})};
+    return Value{makeList(std::move(items))};
 }
 
 std::optional<std::array<float, 4>> valueToColor(const Value& v) {

{openscad_cpp_evaluator-1.35.0 → openscad_cpp_evaluator-1.37.0}/src/eval_context.cpp

@@ -63,9 +63,9 @@ EvalContext EvalContext::makeRoot(const oscad::Scope* rootScope, const oscad::Sc
     // same script starts working there with no edit.
     ctx.dyn->set("$_SUPPORTED_FEATURE", Value{true});
     ctx.dyn->set("$_BELFRYSCAD",
-                 Value{std::make_shared<const ValueList>(ValueList{{Value{double{OSCAD_EVAL_VERSION_MAJOR}},
+                 Value{makeList({Value{double{OSCAD_EVAL_VERSION_MAJOR}},
                                                                     Value{double{OSCAD_EVAL_VERSION_MINOR}},
-                                                                    Value{double{OSCAD_EVAL_VERSION_PATCH}}}})});
+                                                                    Value{double{OSCAD_EVAL_VERSION_PATCH}}})});
     ctx.let_ = TrailView<Value>::makeRoot();
     ctx.dynPositions = TrailView<const oscad::Position*>::makeRoot();
     ctx.childrenNodes = emptyChildrenNodes();