openscad-cpp-evaluator 1.40.0__tar.gz → 1.42.0__tar.gz

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/bindings/module.cpp

@@ -134,6 +134,7 @@ const char* roleToString(oscadeval::BodyRole role) {
         case oscadeval::BodyRole::Highlight:  return "highlight";
         case oscadeval::BodyRole::Background: return "background";
         case oscadeval::BodyRole::ShowOnly:   return "show_only";
+        case oscadeval::BodyRole::HighlightGhost: return "highlight_ghost";
         case oscadeval::BodyRole::Normal:
         default:                              return "normal";
     }

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -43,6 +43,7 @@ enum class Op {
     StoreLocal,     // a = slot index (pops)
     LoadDyn,        // a = name pool index ($-prefixed)
     StoreDyn,       // a = name pool index (pops; also marks dynExplicit)
+    WarnDuplicateLet, // a = name pool index (pops; warns, binds nothing -- see Evaluator::warnDuplicateLet)
     LoadFree,       // a = name pool index -- Evaluator::evalIdentifier fallback (warnIfUndef=true)
     // Same as LoadFree, but Evaluator::evalIdentifier's warnIfUndef=false --
     // only ever emitted for a PrimaryCall's own callee probe (bytecode_
@@ -240,20 +241,6 @@ enum class Op {
     // there's no branch to emit here).
     Echo,
 
-    // Only ever emitted for a non-empty-argument AssertOp (see
-    // bytecode_compiler.cpp's own AssertOp case -- a zero-argument
-    // assert() is unconditionally true and compiles straight through with
-    // no check at all). Reached only on the condition-false path (guarded
-    // by a JumpIfTrue the compiler emits around it, mirroring LogicalOrOp's
-    // own jump-then-patch shape) -- always throws via Evaluator::error(),
-    // i.e. [[noreturn]] at runtime. a = 1 if a message Value was compiled
-    // and pushed (pop it), else 0. b = constant-pool index of condText
-    // (the condition expression's own source text, interned ONCE at
-    // compile time via its toString() -- cheaper than the interpreter,
-    // which recomputes this on every failing call). pos/node: same
-    // Evaluator::error() TRACE-walk need CheckIterLimit already has.
-    AssertFail,
-
     // -- Module-body compilation (Stage 2) --------------------------------
     // A call to a user module resolved to a specific ModuleDeclaration AT
     // COMPILE TIME (see CompiledChunk::ModuleCallSite) -- the module-side
@@ -717,16 +704,10 @@ enum class Op {
     StoreLetVar,
 
     // a = index into CompiledChunk::assertSites. Pops site.argCount values
-    // (all of this statement's own arguments, already compiled+pushed in
-    // source order via compileExpr -- EVERY one, not just condition/
-    // message, mirrors evalAssertStatement's own eager resolveArgs() over
-    // AssertOp's lazy-message contract) and replicates
-    // Evaluator::evalAssertStatement exactly: named "condition"/"message"
-    // win over positional 0/1 (resolved at COMPILE time into
-    // AssertSite::conditionArgIndex/messageArgIndex -- the argument SHAPE
-    // is static, only values vary per call), throws via Evaluator::error()
-    // on failure, otherwise runs any chained node.children natively (rare;
-    // not worth its own compiled path -- see AssertSite's own doc comment).
+    // (every argument of an assert() statement or expression, pushed in
+    // source order) and hands them to Evaluator::checkAssert; a statement
+    // then runs any chained children natively (rare; not worth its own
+    // compiled path).
     AssertStatement,
     // a = nativeStatements index of the AST node whose arm this is. Emitted
     // only when the Evaluator was built with coverage on (compile-time
@@ -763,6 +744,10 @@ struct Instruction {
 // applyDefaults()'s existing sibling-isolated defaultCtx; empty if that
 // parameter has no default. `bodyCode` is the function's own expression body.
 struct CompiledChunk {
+    // String literals whose text holds an escape OpenSCAD calls undefined,
+    // 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;
     struct Param {
         std::string name;
         int slot = 0; // unused when isDyn is true -- $-params are never slot-addressed
@@ -1036,30 +1021,13 @@ struct CompiledChunk {
         const oscad::ASTNode* node = nullptr;
     };
 
-    // One Op::AssertStatement site -- see that op's own doc comment for
-    // the full contract. `conditionArgIndex`/`messageArgIndex` are indices
-    // into the site's own argCount-sized popped-argument array (source
-    // order), resolved at COMPILE time via the same "named wins over
-    // positional 0/1" priority Evaluator::getArg applies at runtime --
-    // nullopt means "no argument supplies this logical parameter" (mirrors
-    // getArg's own defaultValue fallback: absent condition reads as
-    // `Value{true}`, absent message means no ": ..." suffix).
-    // `condTextConstIdx`: constants[] index of the condition argument's own
-    // source text (or "false" when no condition argument exists, matching
-    // evalAssertStatement's `node.arguments.empty() ? "false" : ...`),
-    // interned once at compile time. `node`: for both Evaluator::error()'s
-    // TRACE walk and the (rare) chained-children fallback below.
-    //
-    // ponytail: a script with TWO named args of the SAME name (e.g.
-    // `assert(condition=true, condition=false)`) would resolve to the
-    // LAST one here, not getArg's own first-match; not worth the extra
-    // bookkeeping to fix for input that's already nonsensical.
+    // One Op::AssertStatement site. `statement` is null for the expression
+    // form, which has no children.
     struct AssertSite {
         int argCount = 0;
-        std::optional<int> conditionArgIndex;
-        std::optional<int> messageArgIndex;
-        int condTextConstIdx = -1;
-        const oscad::ModularAssert* node = nullptr;
+        const std::vector<std::unique_ptr<oscad::Argument>>* arguments = nullptr;
+        const oscad::ASTNode* node = nullptr;
+        const oscad::ModularAssert* statement = nullptr;
     };
 
     // Every distinct chunk this SPECIFIC CompiledChunk owns is either a

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -71,6 +71,9 @@ struct PendingCsgWrap {
     // Parallel to groupSizes: whether a group that came out EMPTY is still
     // an operand. See Op::CsgGroupEnd's `a`.
     std::vector<Value> emptyIsAGroup;
+    // Parallel too: whether the statement was a `%` one, which is never an
+    // operand. See Op::CsgGroupEnd's `a` (bit 2).
+    std::vector<Value> backgroundStmt;
     size_t groupStartSize = 0;
 };
 

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -12,7 +12,16 @@
 
 namespace oscadeval {
 
-enum class BodyRole { Normal, Highlight, Background, ShowOnly };
+// HighlightGhost is the see-through copy of a `#` operand that an operation
+// (difference, intersection, hull, ...) emits beside its result so the
+// viewport can still show the operand. The operand itself was merged into
+// the result; the ghost is drawing only. It is never an operand again and
+// never exported -- it used to be a plain Highlight body, so an outer
+// boolean used it twice and export wrote it as real geometry:
+// difference(){ cube(2); #translate([1,1,1]) cube(2); } exported volume 15
+// where OpenSCAD writes 7. A `#` with nothing merging it stays Highlight,
+// and exports like any other geometry, as it does upstream.
+enum class BodyRole { Normal, Highlight, Background, ShowOnly, HighlightGhost };
 
 // A single piece of evaluated geometry: exactly one of `body` (3D) or
 // `section` (2D) is set, never both -- mirrors the Python reference's
@@ -178,4 +187,26 @@ inline constexpr double kTopLevel2dHeight = 1.0;
 std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies,
                                             double flatHeight = kTopLevel2dHeight);
 
+// A 3D affine transform as it acts on the XY plane: rows x and y, columns
+// x, y and translation -- what OpenSCAD's GeometryEvaluator applies to 2D
+// geometry (z, and everything out of the plane, simply drops away).
+manifold::mat2x3 projectTo2d(const manifold::mat3x4& m);
+
+// Moves a section's carried transform (ColoredBody::sectionXform) into the
+// CrossSection itself, projected onto the plane, and resets it. Every 2D
+// operation does this to its children before it reads them: OpenSCAD's F6
+// has already projected each transform by then, and an operation that
+// ignored the carried one -- union, offset, hull, linear_extrude -- used the
+// shape as if the transform had never happened. False if the projection
+// was singular and the shape was removed (the caller warns).
+bool projectSectionXform(ColoredBody& b);
+
+// Applies `m`, projected onto the plane, to a CrossSection. A singular
+// projection -- scale([0,1]), a quarter turn about X -- empties it, as
+// upstream's Polygon2d::transform does, and returns false.
+bool transformSection(manifold::CrossSection& cs, const manifold::mat3x4& m);
+
+// Upstream's warning for that case, word for word.
+inline constexpr const char* kZeroScale2dWarning = "Scaling a 2D object with 0 - removing object";
+
 } // namespace oscadeval

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -2,6 +2,8 @@
 
 #include "openscad_cpp_evaluator/bound_args.hpp"
 #include "openscad_cpp_evaluator/bytecode.hpp"
+
+#include <unordered_set>
 #include "openscad_cpp_evaluator/bytecode_vm.hpp"
 #include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/csg_node.hpp"
@@ -557,6 +559,30 @@ public:
     // Public: builtins/import.cpp's not-manifold warning is emitted from a
     // free function, same reasoning as tagGenerated()/builtinChildren().
     void warn(const std::string& message, const oscad::Position* position);
+    // OpenSCAD's lexer warns "Undefined escape sequence" once per bad escape
+    // in the source. This warns for a literal the first time it is
+    // evaluated or compiled, and never again for that literal.
+    void warnUndefinedEscapes(const oscad::StringLiteral& lit, int count);
+    // let() keeps the FIRST binding of a repeated name: OpenSCAD evaluates
+    // the later right-hand side, warns with its value, and discards it.
+    // OpenSCAD's Assert::performAssert, given every argument's value in
+    // source order -- it evaluates them all, pass or fail, so a passing
+    // `assert(true, nosuch)` still warns. Warns about unexpected arguments;
+    // throws via error() when the condition is false or missing (`assert()`
+    // fails). The message prints as echo() would print it.
+    void checkAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const std::vector<Value>& values,
+                     const oscad::ASTNode& node);
+    void warnDuplicateLet(const std::string& name, const Value& v, const oscad::Position* position);
+    template <typename Assignments>
+    static bool repeatsEarlierLetName(const Assignments& assignments, size_t i) {
+        for (size_t j = 0; j < i; ++j)
+            if (assignments[j]->name->name == assignments[i]->name->name) return true;
+        return false;
+    }
+    std::unordered_set<const oscad::StringLiteral*> undefinedEscapesWarned_;
+    void warnUndefinedEscapes(const CompiledChunk& chunk) {
+        for (const auto& [lit, n] : chunk.undefinedEscapeLiterals) warnUndefinedEscapes(*lit, n);
+    }
     // Hands one already-formatted warning line to echoFn_, recording it in
     // warnCapture first when one is active. Every warning path goes through
     // here, including a ManifoldCache hit replaying a cached line.

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/include/openscad_cpp_evaluator/export.hpp

@@ -52,6 +52,14 @@ struct ExportObject {
 // A body Manifold rejected (an open shell is not a solid) can take part in
 // none of that: it keeps its own triangles and its own object, and its
 // 1-based index is appended to `openParts` for the caller to warn about.
+// The dimension OpenSCAD's render gives these top-level bodies: that of the
+// first one with geometry (2 or 3), or 0 for none.
+int topLevelDimension(const std::vector<ColoredBody>& bodies);
+
+// OpenSCAD's render warnings for a top level that mixes 2D and 3D; export
+// writes only the first object's dimension.
+std::vector<std::string> mixedDimensionWarnings(const std::vector<ColoredBody>& bodies);
+
 std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies,
                                                 std::vector<int>* openParts = nullptr,
                                                 bool splitComponents = false,

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/include/openscad_cpp_evaluator/segments.hpp

@@ -5,7 +5,9 @@
 
 #include <manifold/common.h>
 
+#include <functional>
 #include <optional>
+#include <string>
 
 namespace oscadeval {
 
@@ -27,7 +29,8 @@ struct Discretizer {
     double fa = 12.0;
     double fs = 2.0;
 
-    static Discretizer fromCtx(const EvalContext& ctx);
+    // `warn`, when given, receives upstream's clamping warnings.
+    static Discretizer fromCtx(const EvalContext& ctx, const std::function<void(const std::string&)>& warn = {});
     // Stored in, and read back from, a node's params -- they are part of its
     // cache key, and generate has only the params to go on.
     static Discretizer fromParams(const CSGParams& params);
@@ -53,6 +56,7 @@ struct Discretizer {
 
 // Full-circle segment count from ctx's $fn/$fe/$fa/$fs at radius r;
 // upstream's primitives fall back to 3.
-int fnSegmentsFromCtx(const EvalContext& ctx, double r = 0.0);
+int fnSegmentsFromCtx(const EvalContext& ctx, double r = 0.0,
+                      const std::function<void(const std::string&)>& warn = {});
 
 } // namespace oscadeval

openscad_cpp_evaluator-1.42.0/include/openscad_cpp_evaluator/surface_load.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace oscadeval {
+
+// Height data for surface(), read as upstream's SurfaceNode reads it: a
+// PNG (by its signature) as 16-bit luminance scaled to 0-100, negated by
+// `invert`, bottom image row at y = 0; anything else as a .dat grid, first
+// line at y = 0, short rows padded with 0. Never throws: a file that cannot
+// be read gives no heights and upstream's warning, and the script carries
+// on. `heights[row * cols + col]`; `minVal` is what the base sits 1 below.
+struct SurfaceData {
+    std::vector<double> heights;
+    int rows = 0;
+    int cols = 0;
+    double minVal = 0;
+    std::vector<std::string> warnings;
+};
+SurfaceData loadSurface(const std::string& path, bool invert);
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/include/openscad_cpp_evaluator/value.hpp

@@ -306,7 +306,9 @@ std::string formatNumber(double v);
 //
 // A trailing lone backslash is kept as itself. It can only occur in an
 // unterminated literal, which is a parse error long before this runs.
-std::string unescapeStringLiteral(const std::string& raw);
+// `undefinedEscapes`, when given, counts the escapes OpenSCAD's lexer calls
+// undefined (it warns once for each).
+std::string unescapeStringLiteral(const std::string& raw, int* undefinedEscapes = nullptr);
 
 // echo()/str()/assert-message display format: "undef" | "true"/"false" |
 // "[start : step : end]" (range) | formatNumber() (number) | "[e1, e2, ...]"

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/python/openscad_cpp_evaluator/__init__.py

@@ -249,7 +249,8 @@ def _summarize_param(value, max_items: int = 6, max_len: int = 40) -> str:
 # of kind -- pure internal bookkeeping or already represented structurally
 # elsewhere in the tree. Mirrors the reference's _DUMP_HIDDEN_PARAM_KEYS.
 _DUMP_HIDDEN_PARAM_KEYS = frozenset(
-    {"color", "op", "name", "group_sizes", "empty_is_a_group"})
+    {"color", "op", "name", "group_sizes", "empty_is_a_group", "background_stmt",
+     "m", "remove"})
 
 # Auto-generated tessellation data (not user-authored) for every kind except
 # polyhedron, where the equivalent data *is* the user's own points/faces.
@@ -520,7 +521,7 @@ class ColoredBody:
     section: object = None             # kept for API parity (always None here)
     flat_preview: bool = False
     tri_colors: Optional[object] = None  # (numTri, 4) float32 ndarray, real multi-color CSG merges only
-    role: str = "normal"               # "normal" | "highlight" | "background" | "show_only"
+    role: str = "normal"               # "normal" | "highlight" | "highlight_ghost" | "background" | "show_only"
 
 
 def bodies_from_dicts(body_dicts) -> list:

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/src/builtins/booleans.cpp

@@ -33,17 +33,28 @@ RoleSplit splitByRole(const std::vector<ColoredBody>& bodies) {
     // boolean would silently zero the whole operation (the same failure
     // mode invalid operands caused before they were filtered out).
     for (const ColoredBody& c : bodies) {
-        if (c.isDisplayOnly() && c.role != BodyRole::Background && c.role != BodyRole::ShowOnly) {
+        if (c.isDisplayOnly() && c.role != BodyRole::Background && c.role != BodyRole::ShowOnly &&
+            c.role != BodyRole::HighlightGhost) {
             r.displayOnly.push_back(c);
         }
     }
     for (const ColoredBody& c : bodies) {
-        if (c.role != BodyRole::Background && c.role != BodyRole::ShowOnly && !c.isDisplayOnly()) {
+        if (c.role != BodyRole::Background && c.role != BodyRole::ShowOnly && c.role != BodyRole::HighlightGhost &&
+            !c.isDisplayOnly()) {
             r.foreground.push_back(c);
         }
     }
+    // A `#` operand is merged like any other (it is in `foreground` above)
+    // AND drawn again as a ghost; a ghost from deeper down just rides along.
     for (const ColoredBody& c : r.foreground) {
-        if (c.role == BodyRole::Highlight) r.highlight.push_back(c);
+        if (c.role == BodyRole::Highlight) {
+            ColoredBody ghost = c;
+            ghost.role = BodyRole::HighlightGhost;
+            r.highlight.push_back(std::move(ghost));
+        }
+    }
+    for (const ColoredBody& c : bodies) {
+        if (c.role == BodyRole::HighlightGhost) r.highlight.push_back(c);
     }
     for (const ColoredBody& c : bodies) {
         if (c.role == BodyRole::ShowOnly) r.showOnly.push_back(c);
@@ -82,6 +93,13 @@ std::optional<manifold::CrossSection> toCrossSection(const std::vector<ColoredBo
 // alongside real ManifoldCache/provenance work if per-triangle color
 // through a merge is needed).
 
+bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt) {
+    const oscad::NodeKind k = stmt.kind();
+    return k == oscad::NodeKind::ModularCall || k == oscad::NodeKind::ModularFor ||
+           k == oscad::NodeKind::ModularIntersectionFor || k == oscad::NodeKind::ModularLet ||
+           k == oscad::NodeKind::ModularModifierShowOnly || k == oscad::NodeKind::ModularModifierHighlight;
+}
+
 CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     const std::string& op = node.name->name;
     // union/difference/intersection take no positional arguments in real
@@ -110,6 +128,7 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
 
     std::vector<Value> groupSizes;
     std::vector<Value> emptyIsAGroup;
+    std::vector<Value> backgroundStmt;
     groupSizes.reserve(geoNodes.size());
     emptyIsAGroup.reserve(geoNodes.size());
     for (const oscad::ASTNode* geoNode : geoNodes) {
@@ -130,15 +149,8 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
         // for `if(false) sphere(6)`, `{ }` and `*cube(1)`, and comes out
         // empty for `for(i=[1:0]) sphere(6)`, `union(){}`, `group(){}` and
         // a call to an empty user module.
-        const oscad::NodeKind k = geoNode->kind();
-        emptyIsAGroup.push_back(Value{
-                                       k == oscad::NodeKind::ModularCall ||
-                                       k == oscad::NodeKind::ModularFor ||
-                                       k == oscad::NodeKind::ModularIntersectionFor ||
-                                       k == oscad::NodeKind::ModularLet ||
-                                       k == oscad::NodeKind::ModularModifierShowOnly ||
-                                       k == oscad::NodeKind::ModularModifierHighlight ||
-                                       k == oscad::NodeKind::ModularModifierBackground});
+        emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*geoNode)});
+        backgroundStmt.push_back(Value{geoNode->kind() == oscad::NodeKind::ModularModifierBackground});
     }
 
     CSGParams params;
@@ -146,6 +158,7 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
     params["group_sizes"] = Value{makeList(std::move(groupSizes))};
     params["empty_is_a_group"] =
         Value{makeList(std::move(emptyIsAGroup))};
+    params["background_stmt"] = Value{makeList(std::move(backgroundStmt))};
     return params;
 }
 
@@ -314,6 +327,11 @@ 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 auto backgroundStmtIt = params.find("background_stmt");
+    const auto* backgroundStmt =
+        backgroundStmtIt != params.end() && std::holds_alternative<ListPtr>(backgroundStmtIt->second)
+            ? &std::get<ListPtr>(backgroundStmtIt->second)->items
+            : nullptr;
     const ListItems* emptyIsAGroup =
         emptyIsAGroupIt == params.end()
             ? nullptr
@@ -374,6 +392,20 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
         }
 
         RoleSplit split = splitByRole(stmtBodies);
+        // A `%` statement is scenery, not an operand: upstream leaves it out
+        // of the CSG entirely (collectChildren skips isBackground()), so the
+        // NEXT statement is the minuend of a difference(), and an
+        // intersection() is not cancelled by it. It was taken as an empty
+        // operand, which emptied both. Only the `%` statement itself: a
+        // module or union() holding nothing but `%` is still an (empty)
+        // operand there.
+        const bool isBackgroundStmt = backgroundStmt && thisStmt < backgroundStmt->size() &&
+                                      std::holds_alternative<bool>((*backgroundStmt)[thisStmt]) &&
+                                      std::get<bool>((*backgroundStmt)[thisStmt]);
+        if (isBackgroundStmt) {
+            allBg.insert(allBg.end(), split.background.begin(), split.background.end());
+            continue;
+        }
         allBg.insert(allBg.end(), split.background.begin(), split.background.end());
         allHi.insert(allHi.end(), split.highlight.begin(), split.highlight.end());
         allSo.insert(allSo.end(), split.showOnly.begin(), split.showOnly.end());

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/src/builtins/builtins.hpp

@@ -267,6 +267,19 @@ std::vector<ColoredBody> generateSurface(Evaluator& ev, const CSGParams& params,
                                           const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);
 
 // text() -- text.cpp.
+// Whether a statement that produced no geometry still counts as a boolean
+// operand (and so empties an intersection) -- see resolveCsg.
+bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt);
+
+// OpenSCAD's sin_degrees/cos_degrees: exact at multiples of 30 and 45 degrees.
+double sinDeg(double x);
+double cosDeg(double x);
+
+// OpenSCAD's lookup_radius() (primitives_2d.cpp): `d` beats `r`, numbers only.
+std::optional<double> lookupRadius(Evaluator& ev, const CallArgs& args, std::optional<int> rPos,
+                                   std::optional<int> dPos, const std::string& rName, const std::string& dName,
+                                   const oscad::Position* where);
+
 CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 
 // The font size text()/textmetrics()/fontmetrics() draw at: `size`

{openscad_cpp_evaluator-1.40.0 → openscad_cpp_evaluator-1.42.0}/src/builtins/control.cpp

@@ -106,6 +106,8 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
     const std::vector<const oscad::ASTNode*> bodyNodes = ev.expandChildStatements(node.body, ctx);
 
     std::vector<Value> groupSizes;
+    std::vector<Value> emptyIsAGroup;
+    std::vector<Value> backgroundStmt;
 
     // Each dimension's own RHS is evaluated against `parentCtx` (not
     // upfront against the original `ctx`), re-evaluated on every entry
@@ -116,14 +118,31 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
     // needs `i` visible in `j`'s own range expression).
     std::function<void(size_t, EvalContext&)> recurse = [&](size_t depth, EvalContext& parentCtx) {
         if (depth == node.assignments.size()) {
+            if (depth == 0) return; // for() with no loop variables iterates zero times in OpenSCAD, not once.
             // One body-entry marker per full cartesian-product iteration
             // and nothing per individual variable binding (unlike
             // evalFor) -- mirrors _resolve_intersection_for's single
             // `_check_debug(body_node[0], loop_ctx, expr_level=True)`.
             if (!bodyNodes.empty()) ev.checkDebug(*bodyNodes.front(), parentCtx, /*forced=*/false, /*exprLevel=*/true);
-            const size_t before = ev.currentTreeFrameSize();
-            ev.evalChildren(bodyNodes, parentCtx);
-            groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
+            // One operand per child STATEMENT of every iteration: upstream
+            // instantiates the children straight into the intersection
+            // node (control.cc), so they are intersected flat, not
+            // unioned per iteration first.
+            std::vector<const oscad::ASTNode*> assigns, stmts;
+            for (const oscad::ASTNode* stmt : bodyNodes) {
+                if (stmt->kind() == oscad::NodeKind::Assignment) assigns.push_back(stmt);
+                else if (stmt->kind() != oscad::NodeKind::ModuleDeclaration &&
+                         stmt->kind() != oscad::NodeKind::FunctionDeclaration)
+                    stmts.push_back(stmt);
+            }
+            if (!assigns.empty()) ev.evalChildren(assigns, parentCtx);
+            for (const oscad::ASTNode* stmt : stmts) {
+                const size_t before = ev.currentTreeFrameSize();
+                ev.evalChildren(std::vector<const oscad::ASTNode*>{stmt}, parentCtx);
+                groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
+                emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*stmt)});
+                backgroundStmt.push_back(Value{stmt->kind() == oscad::NodeKind::ModularModifierBackground});
+            }
             return;
         }
         const auto& assign = node.assignments[depth];
@@ -142,49 +161,19 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
 
     CSGParams params;
     params["group_sizes"] = Value{makeList(std::move(groupSizes))};
+    params["empty_is_a_group"] = Value{makeList(std::move(emptyIsAGroup))};
+    params["background_stmt"] = Value{makeList(std::move(backgroundStmt))};
     return params;
 }
 
-std::vector<ColoredBody> generateIntersectionFor(Evaluator&, const CSGParams& params,
+std::vector<ColoredBody> generateIntersectionFor(Evaluator& ev, const CSGParams& params,
                                                   const std::vector<std::unique_ptr<CSGNode>>& children,
-                                                  const oscad::ASTNode&) {
-    const auto& groupSizes = std::get<ListPtr>(params.at("group_sizes"))->items;
-    std::vector<ColoredBody> iterations;
-    size_t idx = 0;
-    for (const Value& sv : groupSizes) {
-        const size_t size = static_cast<size_t>(std::get<double>(sv));
-        std::vector<ColoredBody> stmtBodies = flattenCsgTree(children, idx, size);
-        idx += size;
-        if (!stmtBodies.empty()) iterations.push_back(combineBodies(stmtBodies));
-    }
-    if (iterations.empty()) return {};
-
-    std::vector<ColoredBody> bodies3d;
-    for (const ColoredBody& c : iterations) {
-        if (c.body) bodies3d.push_back(c);
-    }
-    if (!bodies3d.empty()) {
-        manifold::Manifold result = *bodies3d.front().body;
-        for (size_t i = 1; i < bodies3d.size(); ++i) result = result ^ *bodies3d[i].body;
-        ColoredBody cb;
-        cb.body = std::move(result);
-        cb.color = bodies3d.front().color;
-        return {cb};
-    }
-
-    std::vector<ColoredBody> sections;
-    for (const ColoredBody& c : iterations) {
-        if (c.section) sections.push_back(c);
-    }
-    if (!sections.empty()) {
-        manifold::CrossSection result = *sections.front().section;
-        for (size_t i = 1; i < sections.size(); ++i) result = result ^ *sections[i].section;
-        ColoredBody cb;
-        cb.section = std::move(result);
-        cb.color = iterations.front().color;
-        return {cb};
-    }
-    return {};
+                                                  const oscad::ASTNode& node) {
+    // The same operand rules as intersection() itself -- empty statements,
+    // `%` scenery, `#` ghosts, 2D vs 3D -- over the flat statement list.
+    CSGParams p = params;
+    p["op"] = Value{std::string("intersection")};
+    return generateCsg(ev, p, children, node);
 }
 
 } // namespace oscadeval