openscad-cpp-evaluator 1.43.0__tar.gz → 1.45.0__tar.gz

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.45.0}/CLAUDE.md

@@ -211,8 +211,23 @@ Challenges and Experiences"), `roof.cpp` was rewritten from scratch as a close p
 `roof_vd.cc`'s `voronoi_diagram_roof`/`vd_inner_faces`/`discretize_arc` (CGAL/Eigen/Clipper2Lib
 swapped for `manifold::vec2` arithmetic and `manifold::Triangulate`), on top of Boost.Polygon's
 Voronoi builder (fetched as just `boostorg/polygon` + `boostorg/config`, confirmed to need nothing
-else from Boost). Both `method` values dispatch to this same construction (no CGAL-based `"straight"`
-path exists in this port). **Verified independently**, not just "it compiles": a brute-force
+else from Boost). **`method="straight"` is its own construction** (`StraightSkeletonRoof` in
+`roof.cpp`), a true straight-skeleton roof written from the literature (Aichholzer et al. 1995;
+Felkel & Obdržálek 1998's event-driven wavefront) and the reference binary's black-box output --
+no CGAL, and no OpenSCAD roof source read. It simulates the shrinking wavefront event by event
+(edge, split and vertex events; a vertex event reconnects every wavefront edge at the meeting point
+by angle), O(n^2 log n): 5000 vertices in ~0.5 s. Its input is welded first (`weldContours`: corners
+within 2^-19 of the extent snapped together or onto edges, then a Clipper2 union), because a 2D
+union often hands back pieces sharing an edge as separate outlines a hairline apart, and spikes
+are cut away (`dropSpikes`). It matches OpenSCAD 2026.02.01 (`--enable=roof`) in volume, height and
+vertex set on every shape compared that the reference does not crash on -- the reference segfaults
+on many unions of rectangles/triangles that touch along edges, so those were checked only for being
+valid 45-degree roofs (roof area = floor area x sqrt 2). Until this landed both methods built the
+Voronoi roof, wrong for any concave outline. **Warnings**: `$fs`/`$fa` clamping (via the shared
+`Discretizer::fromCtx`) and `Unknown roof method '...'` (a non-string shown as str() shows it) are
+printed BEFORE the children run, as the reference does -- `computeRoofParams` therefore runs at
+`Op::PushBuiltinWrap` time like every other wrap kind (it used to be deferred to Pop on the belief
+that the warning followed the children). **Verified independently**, not just "it compiles": a brute-force
 distance-transform grid search over a square-frame-with-a-hole test case found the same ridge height
 (≈1.756) this implementation produces — the Python reference's own SDF fallback gets this case
 measurably wrong (≈1.5, ~15% low) since it was never more than a documented approximation for
@@ -1115,9 +1130,10 @@ grep for `ponytail:`.
   `toCrossSection`; no children/generate-time-bounds dependency, so its resolve/generate split is
   the simple kind (segment count for `r=` IS resolvable early here, unlike `rotate_extrude`'s,
   since `offset`'s own radius argument is already known at resolve time).
-- `src/builtins/roof.cpp` — `roof()`, built on Boost.Polygon's segment Voronoi diagram (see the
-  `roof()` note above for the full story of why this replaced an earlier straight-skeleton
-  approximation mid-Phase-6). `voronoiRoof` scales the merged cross-section's polygons into signed
+- `src/builtins/roof.cpp` — `roof()`: the default `method="voronoi"` built on Boost.Polygon's
+  segment Voronoi diagram (see the `roof()` note above for the full story of why this replaced an
+  earlier straight-skeleton approximation mid-Phase-6), and `method="straight"`'s straight-skeleton
+  wavefront simulation (`StraightSkeletonRoof`, same note). `voronoiRoof` scales the merged cross-section's polygons into signed
   32-bit integer coordinates (`chooseScale`, headroom below 2^31 for Boost.Polygon's own internal
   robustness margin), constructs the Voronoi diagram over the resulting segments, walks it
   (`vdInnerFaces`, discretizing parabolic point-vs-segment bisector edges via `discretizeArc`) to get

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.45.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.45.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -287,14 +287,13 @@ enum class Op {
     // this AFTER would silently drop uncacheable/ManifoldCache taint
     // tracking for a rands() call embedded in the wrapper's own
     // arguments), computes this site's own params for every kind except
-    // Modifier (empty, no ctx push) and Roof (deferred to Pop -- see
-    // BuiltinWrapSite's own doc comment) via that kind's own native
+    // Modifier (empty, no ctx push) via that kind's own native
     // compute function (computeTransformParams/computeColorParams/etc.,
     // builtins.hpp) -- always a possibly-$-scoped child EvalContext,
     // pushed onto f.ctxChain unconditionally for every non-Modifier kind
-    // (Roof pushes it too, params or not) -- pushes a fresh ev.treeStack_
-    // frame, and stashes {params, randsBefore, siteIdx, (Roof only)
-    // deferredArgs} onto VmFrame::builtinWrapStack (a real per-frame LIFO
+    // -- pushes a fresh ev.treeStack_
+    // frame, and stashes {params, randsBefore, siteIdx} onto
+    // VmFrame::builtinWrapStack (a real per-frame LIFO
     // stack, not a single slot: Push/PopBuiltinWrap pairs can nest or
     // sequence within one frame's own instruction stream, e.g.
     // `translate(a) translate(b) recur();`). The compiler always emits a
@@ -311,12 +310,7 @@ enum class Op {
     // VmFrame::builtinWrapStack's own top entry FIRST (before anything
     // that can itself throw, e.g. Evaluator::setTreeDepthOrThrow below --
     // so the exception-teardown path's own pending count is already
-    // correct if THIS throws); for Roof only, computes `pending.params`
-    // HERE via computeRoofParams(ev, pending.deferredArgs, ctx) -- the one
-    // kind whose params computation has an observable side effect
-    // (ev.warn()) that must stay ordered AFTER children, unlike every
-    // other kind's params (computed at Push, before children, since
-    // nothing else in this group has an order-sensitive side effect); pops
+    // correct if THIS throws); pops
     // the ctx Push made (every kind except Modifier); pops ev.treeStack_
     // to retrieve the children this bracket's own body produced, and
     // builds the tagged CSGNode exactly like Evaluator::buildTreeNode's
@@ -511,7 +505,7 @@ enum class Op {
     // anything compileStatementList doesn't give its own real bytecode.
     // (Assignment/ModularEcho/ModularAssert/ModularLet used to fall here
     // too; they now have their own real bytecode -- Op::StoreModuleVar/
-    // Op::Echo/Op::AssertStatement/Op::OpenLetScope+StoreLetVar -- purely
+    // Op::Echo/Op::AssertPass+AssertFail/Op::OpenLetScope+StoreLetVar -- purely
     // a throughput change, since none of these were ever the recursion-
     // depth risk this compiler targets. `#`/`%`/`!` modifiers and
     // translate/rotate/scale/mirror/multmatrix/resize/color used to fall
@@ -640,14 +634,9 @@ enum class Op {
     // the position recorded into dynPositions).
     StoreModuleVar,
 
-    // ModularEcho/ModularAssert's own statement form share Op::Echo/a
-    // dedicated AssertStatement op (below) for the "pop N already-compiled
-    // argument values" mechanics -- see those ops' own doc comments
-    // (Op::Echo, above; Op::AssertStatement, below) for why the
-    // EXPRESSION-form opcodes are directly reusable (statement-shaped
-    // already: no value pushed, straight fall-through) while assert's
-    // needs its own op (named-argument support + eager-not-lazy message
-    // evaluation, both genuinely different from AssertOp's own contract).
+    // ModularEcho/ModularAssert's own statement form share Op::Echo and
+    // Op::AssertPass/AssertFail (below) with the expression forms: both are
+    // statement-shaped already (no value pushed, straight fall-through).
 
     // Isolates ONE inline-compiled sub-expression's own `$`-writes from the
     // rest of this chunk's shared, long-lived ctx -- pushes ctx.
@@ -703,12 +692,15 @@ enum class Op {
     // the handler itself, kept for consistency/future debugging only).
     StoreLetVar,
 
-    // a = index into CompiledChunk::assertSites. Pops site.argCount values
-    // (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,
+    // assert(): the condition is compiled first, then JumpIfFalse to the
+    // failure path; the passing path never evaluates any other argument
+    // (see Evaluator::evalAssert). a = index into CompiledChunk::assertSites.
+    // AssertPass prints the site's unexpected-argument warnings and runs a
+    // statement's chained children; it is emitted only when the site has
+    // either. AssertFail pops every non-condition argument (source order)
+    // and throws via Evaluator::failAssert.
+    AssertPass,
+    AssertFail,
     // a = nativeStatements index of the AST node whose arm this is. Emitted
     // only when the Evaluator was built with coverage on (compile-time
     // flag, and chunks are per-Evaluator): Evaluator::coverHit(node), nothing
@@ -717,6 +709,17 @@ enum class Op {
     Cover,
 };
 
+// Which of an assert() call's arguments are its condition and message, and
+// whether the call has any unexpected argument to warn about -- all fixed by
+// the call's shape, so worked out once per call site (assertLayout,
+// stmt_eval.cpp). -1 = not given.
+struct AssertLayout {
+    int cond = -1;
+    int msg = -1;
+    bool warns = false;
+};
+AssertLayout assertLayout(const std::vector<std::unique_ptr<oscad::Argument>>& arguments);
+
 struct Instruction {
     Op op;
     int a = 0;
@@ -956,10 +959,9 @@ struct CompiledChunk {
     // rotate_extrude()/projection()/offset()/roof()) share Transform/
     // Color's exact push-time-computed-params shape, just via a different
     // native compute function each (Op::PushBuiltinWrap's own runtime
-    // handler switches on `kind` to pick it) -- see that op's own doc
-    // comment for the one exception (Roof, whose params computation has
-    // to run at POP time instead, after children, to preserve an
-    // observable warn() ordering).
+    // handler switches on `kind` to pick it). Roof's warnings ($fs/$fa
+    // clamping, unknown method) therefore come before its children's
+    // output, as in OpenSCAD 2026.02.01.
     struct BuiltinWrapSite {
         enum class Kind {
             Transform,
@@ -977,7 +979,7 @@ struct CompiledChunk {
             RotateExtrude,
             Projection,
             Offset,
-            Roof,          // computed at POP time, not PUSH -- see this struct's own doc comment
+            Roof,
         };
         Kind kind;
         std::string tagName; // "translate"/"rotate"/.../"color"/"highlight"/"background"/"show_only"/"hull"/...
@@ -1021,10 +1023,10 @@ struct CompiledChunk {
         const oscad::ASTNode* node = nullptr;
     };
 
-    // One Op::AssertStatement site. `statement` is null for the expression
-    // form, which has no children.
+    // One Op::AssertPass/AssertFail site. `statement` is null for the
+    // expression form, which has no children.
     struct AssertSite {
-        int argCount = 0;
+        AssertLayout layout;
         const std::vector<std::unique_ptr<oscad::Argument>>* arguments = nullptr;
         const oscad::ASTNode* node = nullptr;
         const oscad::ModularAssert* statement = nullptr;

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.45.0}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -30,15 +30,6 @@ struct PendingBuiltinWrap {
     CSGParams params;
     std::uint64_t randsBefore = 0;
     int siteIdx = -1;
-    // Only populated for BuiltinWrapSite::Kind::Roof -- the already-
-    // resolved call arguments, retained across the whole bracket so
-    // Op::PopBuiltinWrap's handler can compute roof()'s own params AFTER
-    // children finish (computeRoofParams needs them; re-running
-    // resolveCallArgs at Pop time instead would re-evaluate every argument
-    // expression a second time -- double rands()/side effects). Every
-    // other kind computes its params at Push time and leaves this default-
-    // empty.
-    CallArgs deferredArgs;
 
     // ev.measuring_ as it stood immediately BEFORE this bracket opened.
     // Recorded for EVERY kind, not just Measure, so the exception teardown

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.45.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -565,13 +565,20 @@ public:
     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);
+    // assert(), interpreted: the condition first, and only on failure the
+    // message and any other argument -- see the definition (stmt_eval.cpp)
+    // for why this deliberately diverges from OpenSCAD. `maybeCompiled`
+    // picks evalExprMaybeCompiled (statement form) over evalExpr.
+    void evalAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const oscad::ASTNode& node,
+                    EvalContext& ctx, bool maybeCompiled);
+    // The unexpected-argument warnings, which a passing assert still prints.
+    void warnAssertArgs(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const AssertLayout& layout);
+    // A failed (or condition-less) assert, once every non-condition argument
+    // has been evaluated: warns about unexpected arguments, then throws via
+    // error(). `message` is null when none was given; it prints as echo()
+    // would print it.
+    [[noreturn]] void failAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
+                                 const AssertLayout& layout, const Value* message, 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) {

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.45.0}/include/openscad_cpp_evaluator/format_closure.hpp

@@ -3,6 +3,7 @@
 #include <string>
 
 namespace oscad {
+class ASTNode;
 class FunctionLiteral;
 }
 
@@ -16,5 +17,8 @@ namespace oscadeval {
 // precedence-minimal and which 94 places inside the parser depend on. See
 // format_closure.cpp for where each rule came from.
 std::string formatFunctionLiteral(const oscad::FunctionLiteral& fn);
+// Any expression, spelled the same way: what assert() quotes as its
+// condition ("Assertion '(a > 1)' failed").
+std::string formatExpression(const oscad::ASTNode& expr);
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.45.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.45.0}/src/builtins/builtins.hpp

@@ -246,17 +246,11 @@ CSGParams resolveOffset(Evaluator& ev, const oscad::ModularCall& node, EvalConte
 std::vector<ColoredBody> generateOffset(Evaluator& ev, const CSGParams& params,
                                          const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);
 
-// roof() -- roof.cpp. Tier 1 (exact straight skeleton, stable single-
-// contour polygons) + Tier 3 (SDF/level-set fallback) only, per the plan --
-// Tier 2 (general multi-contour/hole straight skeleton) is a named,
-// documented follow-up, not silently dropped (see CLAUDE.md).
-// computeRoofParams: UNLIKE computeLinearExtrudeParams and friends above,
-// this is the params-computation half taken from AFTER evalChildren (it
-// calls ev.warn(), an observable side effect that must stay ordered after
-// any child's own echo/warn output) -- takes already-resolved CallArgs,
-// not a raw node+ctx, since Op::PushBuiltinWrap's own runtime handler
-// calls this at POP time. See its own doc comment (roof.cpp).
-CSGParams computeRoofParams(Evaluator& ev, const CallArgs& args, EvalContext& effCtx);
+// roof() -- roof.cpp. method="voronoi" (the default) is the Voronoi-diagram
+// roof, method="straight" the straight-skeleton one.
+// computeRoofParams: the params half, from already-resolved arguments;
+// it warns ($fs/$fa clamping, unknown method), before the children run.
+CSGParams computeRoofParams(Evaluator& ev, const CallArgs& args, EvalContext& effCtx, const oscad::Position* where);
 CSGParams resolveRoof(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateRoof(Evaluator& ev, const CSGParams& params,
                                        const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.45.0}/src/builtins/extrude.cpp

@@ -27,9 +27,7 @@ namespace oscadeval {
 // side effect of its own (no warn()/echo()/rands() call), so moving it
 // before evalChildren (unlike this function's own former single-body
 // shape, which computed params AFTER children like every other builtin
-// still not covered by PushBuiltinWrap) is behaviorally unobservable --
-// see computeRoofParams's own doc comment (roof.cpp) for the one builtin
-// in this group where that ISN'T true and a different split was needed.
+// still not covered by PushBuiltinWrap) is behaviorally unobservable.
 namespace {
 
 // Picks the diagonal that splits one side quad: true for A0-B1, false for

{openscad_cpp_evaluator-1.43.0 → openscad_cpp_evaluator-1.45.0}/src/builtins/function_builtins.cpp

@@ -1242,9 +1242,12 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
     // was 0, concat(a=[1], b=[2]) was [], rands(seed_value=) went unseeded.
     // (textmetrics/fontmetrics -- with declaredParams -- and dxf_dim/
     // dxf_cross bind by name in OpenSCAD too.)
+    // The common all-positional call goes straight through, with no
+    // reordered copy built (or destroyed) on its way.
     const bool byName = declaredParams || id == BuiltinFnId::DxfDim || id == BuiltinFnId::DxfCross;
+    if (byName || args.named.empty()) return evalBuiltinFunctionInOrder(ev, id, name, args, node);
     CallArgs ordered;
-    if (!byName && node.kind() == oscad::NodeKind::PrimaryCall && !args.named.empty()) {
+    if (node.kind() == oscad::NodeKind::PrimaryCall) {
         int k = 0, out = 0;
         for (const auto& a : static_cast<const oscad::PrimaryCall&>(node).arguments) {
             const Value* v = nullptr;
@@ -1258,8 +1261,7 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
             ordered.setPositional(out++, v ? *v : Value{});
         }
     }
-    const CallArgs& argsInOrder = (!byName && !args.named.empty()) ? ordered : args;
-    return evalBuiltinFunctionInOrder(ev, id, name, argsInOrder, node);
+    return evalBuiltinFunctionInOrder(ev, id, name, ordered, node);
 }
 
 Value evalBuiltinFunctionInOrder(Evaluator& ev, BuiltinFnId id, const std::string& name, const CallArgs& args,