openscad-cpp-evaluator 0.13.0__tar.gz → 0.13.2__tar.gz

{openscad_cpp_evaluator-0.13.0 → openscad_cpp_evaluator-0.13.2}/PKG-INFO

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

{openscad_cpp_evaluator-0.13.0 → openscad_cpp_evaluator-0.13.2}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -260,26 +260,101 @@ enum class Op {
     // which splice is unconditional).
     CallModule,
 
-    // A single "native passthrough" statement -- a modifier wrapper,
-    // intersection_for, children(), a builtin module call, or a user-
-    // module call that didn't resolve at compile time (shadowed, forward-
-    // declared, or otherwise not statically known) -- 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 a
-    // throughput change, since none of these were ever the recursion-depth
-    // risk this compiler targets.)
+    // -- Builtin-wrap compilation (closes the "NativeStatement gap" for ----
+    // -- translate/rotate/scale/mirror/multmatrix/resize/color/#/%/!) ------
+    // A builtin-with-children statement that isn't a "call" the way
+    // Op::CallModule's target is (no callStack_/profiling participation,
+    // no named scope with upvalue semantics -- see CompiledChunk::
+    // BuiltinWrapSite's own doc comment for the full "why this doesn't
+    // need vmCallStack_/pushBracketedModuleFrame-style bracketing"
+    // reasoning) -- so unlike Op::CallModule, its children compile INLINE
+    // into the SAME instruction stream (via compileStatementList, exactly
+    // like Op::OpenLetScope's own body does for ModularLet) rather than
+    // becoming a separate chunk. Exists because falling through to
+    // Op::NativeStatement here was a REAL, proven Windows/MSVC crash risk
+    // for a recursive translate()/multmatrix()-wrapped module chain (see
+    // this project's own session notes: BOSL2's attachable() machinery
+    // needs native reentry depth ~55, past the empirically-proven-unsafe
+    // Windows ceiling for that reentry mechanism -- no depth-guard tuning
+    // could satisfy both "the real script works" and "Windows doesn't
+    // crash", only eliminating the native reentry itself could).
+    //
+    // a = index into CompiledChunk::builtinWrapSites. Runtime handler:
+    // captures ev.randsCallCount() BEFORE any argument resolution
+    // (mirrors Evaluator::buildTreeNode's own ordering exactly -- doing
+    // 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 (and, for Transform/
+    // Color kinds, a possibly-$-scoped child EvalContext, pushed onto
+    // f.ctxChain unconditionally -- Modifier kind needs neither params
+    // nor a ctx push), 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 plain Op::CheckDebugStatement immediately before
+    // this (see emitBuiltinWrap, bytecode_compiler.cpp), mirroring
+    // ModularEcho/ModularAssert's own pattern -- NOT skipped the way
+    // Op::CallModule's own call site skips one: this is a genuine
+    // statement doing real work here, unlike a module call (which
+    // transfers control to a declaration whose OWN body statements each
+    // get their own check instead).
+    PushBuiltinWrap,
+
+    // Closes the matching Op::PushBuiltinWrap bracket: pops
+    // 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), pops the ctx push Push made (Transform/
+    // Color kinds only), pops ev.treeStack_ to retrieve the children this
+    // bracket's own body produced, and builds the tagged CSGNode exactly
+    // like Evaluator::buildTreeNode's own post-resolveBody() half does
+    // (kind/node/isBuiltin=true/children/params/uncacheable/
+    // setTreeDepthOrThrow), pushing it onto the new top of treeStack_. a
+    // = index into CompiledChunk::builtinWrapSites (same site Push used).
+    //
+    // teardownVmCallStackDownTo's own exception path (bytecode_vm.cpp)
+    // pops frame->builtinWrapStack.size() additional treeStack_ entries
+    // per torn-down frame, on top of its existing ownsModuleSplice-gated
+    // pop -- required because an exception can leave N of these brackets
+    // open in one frame, unlike the "at most one Op::CallModule splice
+    // per frame" shape that gated pop was originally sized for. See
+    // releaseVmFrame's own doc comment (user_calls.cpp) for a real,
+    // previously-ASan-caught bug from exactly this class of mismatched-
+    // bookkeeping-vs-treeStack_-depth mistake (a 1-bit version of the
+    // same seam, now a counter).
+    PopBuiltinWrap,
+
+    // A single "native passthrough" statement -- intersection_for,
+    // children(), union/difference/intersection and every other builtin
+    // module call NOT covered by Op::PushBuiltinWrap (see that op's own
+    // doc comment for exactly which builtins ARE covered), the `*`
+    // modifier's own no-op case, or a user-module call that didn't
+    // resolve at compile time (shadowed, forward-declared, or otherwise
+    // not statically known) -- 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 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 here too, for the SAME
+    // throughput reasoning -- WRONG in that one specific case: a
+    // recursive module call wrapped in one of these is exactly the
+    // pattern that made this op's own native reentry a genuine Windows
+    // crash risk in practice, not just a missed optimization. See
+    // Op::PushBuiltinWrap's own doc comment for the real story and the
+    // fix.)
     // a = index into CompiledChunk::nativeStatements. Runtime just does
     // what Evaluator::evalChildren's own per-statement loop already does
     // for one node: derive childCtx via ctx.withScope(...), checkDebug,
-    // evalStatement. These are "leaf-shaped" in the sense the Stage 2 plan
-    // means it: whatever native recursion they make (a builtin's own
-    // resolve function walking ITS children, etc.) is bounded by ordinary
-    // script structure, not by how deep a recursive module chain goes --
-    // that risk is fully covered by CallModule/ForIterNext/the Jump-based
-    // if/for control flow instead, regardless of how many of THESE sit
-    // alongside them in the same body.
+    // evalStatement. These are still "leaf-shaped" for what's left here
+    // after Op::PushBuiltinWrap peeled off the proven-risky subset: real
+    // recursion safety for a recursive module chain is covered by
+    // CallModule/PushBuiltinWrap/ForIterNext/the Jump-based if/for control
+    // flow, not by how many of THESE sit alongside them in the same body
+    // -- true again now that the one construct that violated it
+    // (translate()-wrapped recursion) has its own real bytecode instead.
     NativeStatement,
 
     // If/if-else's own condition, evaluated NATIVELY (Evaluator::
@@ -583,6 +658,38 @@ struct CompiledChunk {
         std::string calleeName;
     };
 
+    // One Op::PushBuiltinWrap/PopBuiltinWrap site pair -- a builtin-with-
+    // children statement recognized at COMPILE time as one of the small,
+    // closed set this covers (see Op::PushBuiltinWrap's own doc comment
+    // for the full list and the Windows-crash rationale). Unlike
+    // ModuleCallSite, this is NOT "a call" -- see this struct's own `kind`
+    // discriminator and Evaluator::evalModularCall/buildTreeNode/
+    // evalModifier (csg_resolve.cpp): builtins never touch callStack_ or
+    // fire profileEnter/profileExit, native or compiled, so there's no
+    // enterUserCall-style bracketing to represent here, just enough to
+    // replay the native param-resolution step and rebuild the tagged
+    // CSGNode at Pop time.
+    //
+    // `node`'s concrete type depends on `kind`: Transform/Color sites are
+    // genuine `ModularCall`s (down-cast to read `.name`/`.arguments`/
+    // `.children`); Modifier sites are the wrapper node itself
+    // (`ModularModifierHighlight`/`Background`/`ShowOnly` -- `!`/`#`/`%`;
+    // `*`/Disable never reaches here, its child never evaluates at all,
+    // so it stays Op::NativeStatement's no-op-shaped native path), which
+    // does NOT derive from ModularCall (it derives from
+    // ModuleInstantiation directly and carries a single `child`) -- read
+    // via its own concrete type when kind == Modifier, never as a
+    // ModularCall. Stored as the generic `ASTNode*` here (not a tagged
+    // union of concrete pointers) because that's all Op::PopBuiltinWrap
+    // itself ever needs `node` for: the resulting CSGNode's own
+    // `node`/error-position field.
+    struct BuiltinWrapSite {
+        enum class Kind { Transform, Color, Modifier };
+        Kind kind;
+        std::string tagName; // "translate"/"rotate"/.../"color"/"highlight"/"background"/"show_only"
+        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
@@ -644,6 +751,7 @@ struct CompiledChunk {
     // NativeCondJumpIfFalse/NativeCheckDebugExprLevel/NativeIterMaterialize's
     // own doc comments, above) -- always empty for a function chunk.
     std::vector<ModuleCallSite> moduleCallSites;
+    std::vector<BuiltinWrapSite> builtinWrapSites;
     std::vector<AssertSite> assertSites;
     std::vector<const oscad::Expression*> nativeExprs;
     std::vector<const oscad::ASTNode*> nativeStatements;

{openscad_cpp_evaluator-0.13.0 → openscad_cpp_evaluator-0.13.2}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -2,6 +2,7 @@
 
 #include "openscad_cpp_evaluator/bound_args.hpp"
 #include "openscad_cpp_evaluator/bytecode.hpp"
+#include "openscad_cpp_evaluator/csg_node.hpp"
 #include "openscad_cpp_evaluator/eval_context.hpp"
 #include "openscad_cpp_evaluator/value.hpp"
 
@@ -16,6 +17,19 @@ namespace oscadeval {
 
 class Evaluator;
 
+// One still-open Op::PushBuiltinWrap bracket's own state, needed again by
+// its matching Op::PopBuiltinWrap -- see that op's own doc comment
+// (bytecode.hpp) for the full contract. Lives in the header for the same
+// reason IterList does, just above: it travels with a VmFrame (VmFrame::
+// builtinWrapStack, below), not a free-standing local, since Push/
+// PopBuiltinWrap pairs can nest or sequence within one frame's own
+// instruction stream.
+struct PendingBuiltinWrap {
+    CSGParams params;
+    std::uint64_t randsBefore = 0;
+    int siteIdx = -1;
+};
+
 // One ListCompFor/statement-for assignment's own materialized iteration
 // state -- see Op::IterMaterialize/IterReset/IterNext's own doc comments
 // (bytecode.hpp). Lives in the header (not bytecode_vm.cpp's own anonymous
@@ -102,6 +116,17 @@ struct VmFrame {
     std::vector<std::vector<Value>> accumStack;
     std::vector<IterList> iterLists;
     std::vector<EvalContext> ctxChain;
+    // Still-open Op::PushBuiltinWrap brackets, LIFO, scoped to THIS frame's
+    // own instruction stream -- mirrors accumStack/iterLists' own role for
+    // their respective bracket pairs. Normal execution always drains this
+    // back to empty (every Push has a compile-time-matched Pop); only the
+    // exception-teardown path (teardownVmCallStackDownTo, bytecode_vm.cpp)
+    // needs to know its size, to pop the matching number of extra
+    // treeStack_ entries for a frame torn down mid-bracket. Not explicitly
+    // cleared in releaseVmFrame, same as accumStack/ctxChain -- the
+    // existing invariant ("whoever pops this frame drains its own open
+    // brackets first") already covers it.
+    std::vector<PendingBuiltinWrap> builtinWrapStack;
     // The ORIGINAL callee name at push time, used by
     // Evaluator::exitUserCallSuccess's own returnHook call when this frame
     // carries a bracket -- deliberately NOT updated by a later tail hop

{openscad_cpp_evaluator-0.13.0 → openscad_cpp_evaluator-0.13.2}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -559,18 +559,25 @@ private:
     void buildTreeNode(const std::string& kind, const oscad::ASTNode& node,
                         const std::function<CSGParams()>& resolveBody);
 
+    // -- User function/module calls (Phase 4) --------------------------
+
+public:
     // Sets node.treeDepth from its own (already-finalized) `children`,
     // throwing (kMaxCsgTreeDepth's own doc comment, above, for why) if
     // it's now too deep. Called by every csg_resolve.cpp site that
     // finalizes a CSGNode's own `children` -- buildTreeNode,
     // evalModularCall's non-splice tail, spliceModuleChildren's
     // union-wrap branch -- right after assigning `children`, before the
-    // node is ever linked into anything a caller could see.
+    // node is ever linked into anything a caller could see. Public (not
+    // alongside buildTreeNode/evalModularCall, just above, which stay
+    // private member functions): Op::PopBuiltinWrap's own runtime handler
+    // (bytecode_vm.cpp, a free function, same "needs direct access, no
+    // friend declaration in play" reasoning as treeStack_/randsCallCount()
+    // above) calls this directly, replicating buildTreeNode's own
+    // post-resolveBody() half rather than going through it (the "body"
+    // there already ran as bytecode, not a callback buildTreeNode could
+    // invoke).
     void setTreeDepthOrThrow(CSGNode& node, const oscad::ASTNode& errNode);
-
-    // -- User function/module calls (Phase 4) --------------------------
-
-public:
     // Picks between an isolated call scope (callCtx()) and a closure-
     // capturing one (childCtx()) for entering `decl`'s body: walks the
     // live call stack, and if `decl`'s own declaration span is *strictly*
@@ -1351,18 +1358,44 @@ public:
     // doubled to 100 for headroom -- that immediately segfaulted on
     // Windows CI (ModuleBodyCompiles.
     // NativeReentrantRecursionHitsAControlledErrorInsteadOfCrashing, its
-    // own guard-safety regression test). Backed off to 50 -- STILL
-    // segfaulted there. Confirms this chain's real per-level native-frame
-    // cost is heavier than kMaxUserCallDepth's own (which needed the SAME
-    // kind of comedown, an initial 50 down to 30, for a shallower chain),
-    // and that Windows' real safe ceiling for THIS chain sits somewhere
-    // below 50, above the already-Windows-verified-safe 30 (confirmed
-    // safe by PR #60's own successful merge, before this value ever
-    // changed). Currently at 40 -- ALSO still functionally sufficient
-    // (all 3 real scripts still render locally at this value) -- bisecting
-    // downward toward Windows' actual ceiling via successive CI runs, one
-    // step at a time; if 40 itself is still unsafe there, keep coming
-    // down. Do not raise this value again based on local (macOS/Linux)
+    // own guard-safety regression test at the time -- since renamed/
+    // repurposed, see Op::PushBuiltinWrap below). Backed off to 50 --
+    // STILL segfaulted there. Confirms this chain's real per-level
+    // native-frame cost is heavier than kMaxUserCallDepth's own (which
+    // needed the SAME kind of comedown, an initial 50 down to 30, for a
+    // shallower chain), and that Windows' real safe ceiling for THIS
+    // chain sits somewhere below 50, above the already-Windows-verified-
+    // safe 30 (confirmed safe by PR #60's own successful merge, before
+    // this value ever changed). Landed at 40.
+    //
+    // A real stack-margin check (nativeStackMarginLow(), since removed --
+    // see git history for `native_stack.hpp`/`.cpp` if the exact mechanism
+    // is ever needed again) was tried as a REPLACEMENT for this fixed
+    // count, specifically because BOSL2's attachable() machinery
+    // (Anklet.scad) needed native reentry depth 55, past this ceiling --
+    // and confirmed working for that: Anklet.scad rendered successfully
+    // with an unmodified build. But the margin-based check was THEN
+    // confirmed, via two separate real Windows CI runs, to segfault for a
+    // DIFFERENT deep native-reentry chain (union()-wrapped recursion)
+    // regardless of total thread stack size (an 8 MiB Windows stack,
+    // matching macOS's own default byte-for-byte, still crashed at the
+    // same depth) -- i.e. this fixed count, not the margin check, is the
+    // mechanism actually proven safe on Windows for genuine deep native
+    // reentry; the margin check is not a safe general replacement for it.
+    //
+    // The REAL fix for Anklet.scad turned out to be architectural, not a
+    // better safety-check mechanism: Op::PushBuiltinWrap/PopBuiltinWrap
+    // (bytecode.hpp/bytecode_compiler.cpp/bytecode_vm.cpp) eliminates
+    // native reentry ENTIRELY for the specific pattern that needed depth
+    // 55 (translate/rotate/scale/mirror/multmatrix/resize/color/#/%/!-
+    // wrapped recursion) by compiling it to run on the heap-based
+    // vmCallStack_ instead of falling to Op::NativeStatement -- so this
+    // guard no longer needs to accommodate that case at all. What's left
+    // uncovered (union/difference/intersection-wrapped recursion, other
+    // builtins, fully interpreted-mode scripts) is genuinely "leaf-shaped"
+    // again in the sense Stage 2's original design assumed, comfortably
+    // within this fixed, Windows-proven-safe ceiling for any realistic
+    // script. Do not raise this value again based on local (macOS/Linux)
     // testing alone -- only a real Windows CI pass is evidence of safety
     // here. Deliberately its own named constant (not a reuse of
     // kMaxUserCallDepth) so the two can be recalibrated independently.

{openscad_cpp_evaluator-0.13.0 → openscad_cpp_evaluator-0.13.2}/pyproject.toml

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

{openscad_cpp_evaluator-0.13.0 → openscad_cpp_evaluator-0.13.2}/src/builtins/builtins.hpp

@@ -38,13 +38,29 @@ CSGParams resolve2d(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
 std::vector<ColoredBody> generate2d(Evaluator& ev, const CSGParams& params,
                                      const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);
 
+// Shared return shape for computeTransformParams/computeColorParams,
+// below -- the "resolve args, build params, compute a possibly-$-scoped
+// child ctx" half of resolveTransform/resolveColor, split out so
+// Op::PushBuiltinWrap's own runtime handler (bytecode_vm.cpp) can call it
+// directly instead of going through the full resolve function (whose
+// OTHER half, `ev.evalChildren(...)`, is exactly the native reentry this
+// split exists to avoid). `ctx` is the input ctx unchanged unless this
+// builtin's own resolution opened a new one (mirrors ResolvedCallArgs's
+// own `ctx` field, call_args.hpp).
+struct BuiltinWrapParams {
+    CSGParams params;
+    EvalContext ctx;
+};
+
 // translate/rotate/scale/mirror/multmatrix/resize share one resolve/
 // generate pair (2D/3D dispatch happens per-body at generate time).
+BuiltinWrapParams computeTransformParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 CSGParams resolveTransform(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateTransform(Evaluator& ev, const CSGParams& params,
                                             const std::vector<std::unique_ptr<CSGNode>>& children,
                                             const oscad::ASTNode& node);
 
+BuiltinWrapParams computeColorParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 CSGParams resolveColor(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateColor(Evaluator& ev, const CSGParams& params,
                                         const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);

{openscad_cpp_evaluator-0.13.0 → openscad_cpp_evaluator-0.13.2}/src/builtins/color.cpp

@@ -12,7 +12,7 @@ namespace oscadeval {
 // case). Sets the color on ctx for every descendant statement. Mirrors
 // _resolve_color/_generate_color.
 
-CSGParams resolveColor(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+BuiltinWrapParams computeColorParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     const Value defaultC =
         Value{std::make_shared<const ValueList>(ValueList{{Value{1.0}, Value{1.0}, Value{1.0}, Value{1.0}}})};
@@ -33,15 +33,19 @@ CSGParams resolveColor(Evaluator& ev, const oscad::ModularCall& node, EvalContex
     }
 
     EvalContext childCtx = effCtx.childCtx(nullptr, std::optional<std::array<double, 4>>(rgba));
+    CSGParams params;
+    params["rgba"] = colorToValue(rgba);
+    return BuiltinWrapParams{std::move(params), std::move(childCtx)};
+}
+
+CSGParams resolveColor(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    BuiltinWrapParams result = computeColorParams(ev, node, ctx);
     // Evaluated for the side effect of building the children's own CSGNodes
     // under the color-tagged context -- the returned bodies themselves are
     // unused here; generate reads them back via each child's own .bodies
     // and stamps `rgba` onto all of them. Mirrors _resolve_color.
-    ev.evalChildren(node.children, childCtx);
-
-    CSGParams params;
-    params["rgba"] = colorToValue(rgba);
-    return params;
+    ev.evalChildren(node.children, result.ctx);
+    return std::move(result.params);
 }
 
 std::vector<ColoredBody> generateColor(Evaluator&, const CSGParams& params,

{openscad_cpp_evaluator-0.13.0 → openscad_cpp_evaluator-0.13.2}/src/builtins/transforms.cpp

@@ -164,7 +164,7 @@ manifold::CrossSection applyTransform2d(const std::string& name, const CallArgs&
 
 } // namespace
 
-CSGParams resolveTransform(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+BuiltinWrapParams computeTransformParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     const std::string& name = node.name->name;
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
 
@@ -176,9 +176,13 @@ CSGParams resolveTransform(Evaluator& ev, const oscad::ModularCall& node, EvalCo
     // getArg() again in applyTransform2d/3d below, instead of resolving
     // e.g. "v"/"a" to a concrete vec3/vec2 here.
     params["args"] = callArgsToValue(args);
+    return BuiltinWrapParams{std::move(params), std::move(effCtx)};
+}
 
-    ev.evalChildren(node.children, effCtx);
-    return params;
+CSGParams resolveTransform(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    BuiltinWrapParams result = computeTransformParams(ev, node, ctx);
+    ev.evalChildren(node.children, result.ctx);
+    return std::move(result.params);
 }
 
 std::vector<ColoredBody> generateTransform(Evaluator&, const CSGParams& params,

{openscad_cpp_evaluator-0.13.0 → openscad_cpp_evaluator-0.13.2}/src/bytecode_compiler.cpp

@@ -1,8 +1,11 @@
 #include "openscad_cpp_evaluator/bytecode_compiler.hpp"
 
 #include "openscad_cpp_evaluator/call_args.hpp"
+#include "openscad_cpp_evaluator/dispatch.hpp"
 #include "openscad_cpp_evaluator/function_builtins.hpp"
 
+#include "builtins/builtins.hpp"
+
 #include "openscad_cpp_parser/ast/declarations.hpp"
 #include "openscad_cpp_parser/ast/expression.hpp"
 #include "openscad_cpp_parser/ast/module_instantiation.hpp"
@@ -1163,6 +1166,42 @@ public:
         out.push_back({Op::CloseExprScope, 0, 0, nullptr});
     }
 
+    // Shared by ModularCall's Transform/Color-kind branch and the 3 real
+    // modifier cases (ModularModifierHighlight/Background/ShowOnly),
+    // below -- emits one Op::PushBuiltinWrap/PopBuiltinWrap bracket around
+    // `children` compiled inline (exactly like ModularLet's own body
+    // does, via this same compileStatementList recursion). See
+    // Op::PushBuiltinWrap's own doc comment (bytecode.hpp) for the full
+    // design and why this specific set doesn't fall to Op::NativeStatement
+    // like other builtins-with-children still do.
+    //
+    // Op::CheckDebugStatement emitted first, mirroring ModularEcho/
+    // ModularAssert's own pattern (both above) -- NOT Op::CallModule's own
+    // lack of one: that omission is specific to a resolved USER MODULE
+    // call, whose own body statements each get their own check instead
+    // (mirrors evalUserModule's "no body-entry checkDebug of its own",
+    // evaluator.hpp). A builtin wrap statement isn't "control transferring
+    // to a declaration" the way a module call is -- it's a plain statement
+    // representing real work happening HERE, exactly like echo/assert/
+    // assignment, which is why those get their own checkpoint. Confirmed
+    // for real: DebugHooks.FastContinueNotHookSkippableStillFiresEvery-
+    // Checkpoint (a translate()-wrapped script) caught the miscount when
+    // this was first omitted by analogy to Op::CallModule.
+    void emitBuiltinWrap(CompiledChunk::BuiltinWrapSite::Kind kind, const std::string& tagName,
+                          const oscad::ASTNode& wrapperNode, const std::vector<const oscad::ASTNode*>& children,
+                          std::vector<Instruction>& out) {
+        out.push_back({Op::CheckDebugStatement, internNativeStatement(&wrapperNode), 0, nullptr});
+        CompiledChunk::BuiltinWrapSite site;
+        site.kind = kind;
+        site.tagName = tagName;
+        site.node = &wrapperNode;
+        chunk_.builtinWrapSites.push_back(std::move(site));
+        const int idx = static_cast<int>(chunk_.builtinWrapSites.size()) - 1;
+        out.push_back({Op::PushBuiltinWrap, idx, 0, &wrapperNode.position()});
+        compileStatementList(children, out);
+        out.push_back({Op::PopBuiltinWrap, idx, 0, &wrapperNode.position()});
+    }
+
     void compileOneStatement(const oscad::ASTNode& stmt, std::vector<Instruction>& out) {
         using oscad::NodeKind;
         trackSpan(stmt);
@@ -1350,14 +1389,61 @@ public:
                         {Op::CallModule, static_cast<int>(chunk_.moduleCallSites.size()) - 1, 0, &call.position()});
                     return;
                 }
-                // Builtin, children(), or a name that didn't resolve to a
-                // user module statically -- native passthrough, exactly
-                // like echo/assert/etc. below. Never the recursion-depth
-                // risk this compiler targets (see NativeStatement's own
-                // doc comment, bytecode.hpp).
+                // A user module never shadows a builtin transform/color
+                // name in a way that reaches here -- the `resolved` check
+                // above already ruled that out (isBuiltin per
+                // evalModularCall's own comment). So a name found in
+                // resolveDispatch() here is unambiguously the real C++
+                // builtin. Detected by FUNCTION-POINTER identity against
+                // &resolveTransform/&resolveColor, not a second,
+                // independently-maintained name list -- stays in sync
+                // with registry.cpp automatically if a 7th transform name
+                // is ever added there. See Op::PushBuiltinWrap's own doc
+                // comment (bytecode.hpp) for why this specific subset
+                // gets real bytecode instead of falling to
+                // Op::NativeStatement below like every other builtin
+                // still does.
+                const auto& dispatch = resolveDispatch();
+                auto dispatchIt = dispatch.find(call.name->name);
+                std::optional<CompiledChunk::BuiltinWrapSite::Kind> wrapKind;
+                if (dispatchIt != dispatch.end()) {
+                    if (dispatchIt->second == &resolveTransform) {
+                        wrapKind = CompiledChunk::BuiltinWrapSite::Kind::Transform;
+                    } else if (dispatchIt->second == &resolveColor) {
+                        wrapKind = CompiledChunk::BuiltinWrapSite::Kind::Color;
+                    }
+                }
+                if (wrapKind) {
+                    std::vector<const oscad::ASTNode*> children;
+                    children.reserve(call.children.size());
+                    for (const auto& c : call.children) children.push_back(c.get());
+                    emitBuiltinWrap(*wrapKind, call.name->name, call, children, out);
+                    return;
+                }
+                // Every other builtin, children(), or a name that didn't
+                // resolve to a user module statically -- native
+                // passthrough, exactly like echo/assert/etc. below. Never
+                // the recursion-depth risk this compiler targets for
+                // THESE (see NativeStatement's own doc comment,
+                // bytecode.hpp).
                 out.push_back({Op::NativeStatement, internNativeStatement(&stmt), 0, &stmt.position()});
                 return;
             }
+            case NodeKind::ModularModifierHighlight: {
+                auto& n = static_cast<const oscad::ModularModifierHighlight&>(stmt);
+                emitBuiltinWrap(CompiledChunk::BuiltinWrapSite::Kind::Modifier, "highlight", n, {n.child.get()}, out);
+                return;
+            }
+            case NodeKind::ModularModifierBackground: {
+                auto& n = static_cast<const oscad::ModularModifierBackground&>(stmt);
+                emitBuiltinWrap(CompiledChunk::BuiltinWrapSite::Kind::Modifier, "background", n, {n.child.get()}, out);
+                return;
+            }
+            case NodeKind::ModularModifierShowOnly: {
+                auto& n = static_cast<const oscad::ModularModifierShowOnly&>(stmt);
+                emitBuiltinWrap(CompiledChunk::BuiltinWrapSite::Kind::Modifier, "show_only", n, {n.child.get()}, out);
+                return;
+            }
             case NodeKind::ModularIf: {
                 auto& n = static_cast<const oscad::ModularIf&>(stmt);
                 const int jumpFalseIdx = static_cast<int>(out.size());
@@ -1389,10 +1475,17 @@ public:
                 return;
             }
             default:
-                // modifiers/intersection_for -- deliberately native (see
-                // this section's own header comment above); echo/assert/
-                // assignment/let-block now have their own real bytecode
-                // cases, above.
+                // ModularModifierDisable (`*`) -- deliberately native: its
+                // child never evaluates at all (see evalStatement's own
+                // ModularModifierDisable case, stmt_eval.cpp), so there's
+                // no recursion to eliminate here in the first place.
+                // intersection_for -- deliberately native (bespoke
+                // per-statement grouping, same reasoning as union/
+                // difference/intersection; not covered by
+                // Op::PushBuiltinWrap, see that op's own doc comment).
+                // `#`/`%`/`!` and translate/rotate/scale/mirror/multmatrix/
+                // resize/color have their own real bytecode cases now,
+                // above; echo/assert/assignment/let-block already did.
                 out.push_back({Op::NativeStatement, internNativeStatement(&stmt), 0, &stmt.position()});
                 return;
         }