openscad-cpp-evaluator 1.4.1__tar.gz → 1.6.0__tar.gz

{openscad_cpp_evaluator-1.4.1 → openscad_cpp_evaluator-1.6.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.4.1 → openscad_cpp_evaluator-1.6.0}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -152,7 +152,20 @@ struct IterList {
 // (pre-redesign) behavior exactly.
 struct VmFrame {
     const CompiledChunk* chunk = nullptr;
-    const std::vector<Instruction>* code = nullptr;
+    // This frame's instruction stream, pre-decomposed into data()/size().
+    // driveVm's dispatch loop reads both once per INSTRUCTION; when this was a
+    // `const std::vector<Instruction>*`, that cost a pointer chase plus an
+    // end-minus-begin divided by sizeof(Instruction) (a multiply by a magic
+    // constant) on every opcode. ~11% of a whole Anklet.scad render sat in that
+    // loop preamble. A compiled chunk's code vector is immutable for as long as
+    // any frame runs it, so caching these is free -- but they must only ever be
+    // set together, hence setCode() rather than two public fields to forget.
+    const Instruction* code = nullptr;
+    size_t codeSize = 0;
+    void setCode(const std::vector<Instruction>& c) {
+        code = c.data();
+        codeSize = c.size();
+    }
     size_t pc = 0;
     std::vector<Value> slots;
     std::vector<Value> stack;
@@ -189,6 +202,16 @@ struct VmFrame {
     // brackets first", normally via matched Push/Pop, or via
     // teardownVmCallStackDownTo on the exception path) already covers it.
     std::vector<PendingCsgWrap> csgWrapStack;
+    // Scratch CallArgs for this frame's builtin/import call sites, reused
+    // across calls so its two vectors keep their capacity: building a fresh
+    // one per call was 1.99M of one Anklet.scad render's 10M allocations,
+    // second only to the argument vector this frame's operand stack now
+    // stands in for. One per FRAME rather than one per Evaluator because a
+    // builtin can re-enter the VM -- but only by pushing a new frame, which
+    // brings its own scratch, and a frame never has two call opcodes in
+    // flight at once. Frames themselves are pooled (acquireVmFrame), so the
+    // capacity survives the call that grew it.
+    CallArgs argScratch;
     // 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-1.4.1 → openscad_cpp_evaluator-1.6.0}/include/openscad_cpp_evaluator/call_args.hpp

@@ -97,4 +97,14 @@ const oscad::Expression* argExpr(const oscad::Argument& arg);
 // positional argument, not a fixed named slot.
 std::vector<Value> allPositional(const CallArgs& args);
 
+// allPositional()'s size and element access, without building the vector.
+// The argument CHECKERS (function_builtins.cpp) only ever ask how many
+// positional slots there are and look at a couple of them, so they used to
+// pay a heap allocation plus a Value copy per slot on every builtin call
+// that has a check entry -- 1.97M of the 16.6M allocations in one
+// Anklet.scad render. positionalAt() answers undef for a gap, exactly as
+// allPositional() pads one.
+size_t positionalCount(const CallArgs& args);
+const Value& positionalAt(const CallArgs& args, size_t pos);
+
 } // namespace oscadeval

{openscad_cpp_evaluator-1.4.1 → openscad_cpp_evaluator-1.6.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -1812,7 +1812,26 @@ private:
     // its (possibly many) active occurrences is checked, checking each
     // DISTINCT X once is exactly equivalent to checking every occurrence
     // -- not an approximation.
-    std::unordered_map<const oscad::ASTNode*, int> activeDeclRefcount_;
+    // A flat vector, not a map, for the reason the paragraph above already
+    // establishes: the number of DISTINCT active declarations stays small and
+    // roughly constant, so a linear scan beats hashing -- and an
+    // unordered_map cost one node allocation per user call (595K in one
+    // Anklet.scad render) where this costs none after warmup, while the
+    // every-call containment scan above walks contiguous memory instead of a
+    // hash table's buckets. Same flat-vector-over-small-map trade CallArgs and
+    // BoundArgs already make. Entry order is not meaningful (the scan visits
+    // all of them), so removal swaps with the back.
+    std::vector<std::pair<const oscad::ASTNode*, int>> activeDeclRefcount_;
+    // ++count for `decl`, appending an entry if it has none yet.
+    void noteActiveDeclEnter(const oscad::ASTNode* declNode) {
+        for (auto& entry : activeDeclRefcount_) {
+            if (entry.first == declNode) {
+                ++entry.second;
+                return;
+            }
+        }
+        activeDeclRefcount_.emplace_back(declNode, 1);
+    }
 
     // Shared cap on callStack_'s own size, checked by both
     // evalUserFunctionCore (below) and evalUserModule (user_calls.cpp) --

{openscad_cpp_evaluator-1.4.1 → openscad_cpp_evaluator-1.6.0}/include/openscad_cpp_evaluator/scope_trail.hpp

@@ -50,7 +50,7 @@ public:
     // ancestry chain here (an isolating derivation -- see openChild).
     int openLevel(int parentLevel) {
         int level = ++nextLevel_;
-        parent_[level] = parentLevel;
+        parent_.push_back(parentLevel); // index == level; see parent_'s own comment
         return level;
     }
 
@@ -122,7 +122,7 @@ public:
             }
             dirty_.erase(it);
         }
-        parent_.erase(level);
+        parent_[static_cast<size_t>(level)] = 0; // dead: an ancestry walk stops here
     }
 
     // nullptr if `name` has no binding on `myLevel`'s own ancestry chain.
@@ -154,8 +154,7 @@ public:
             } else if (entryLevel == ancestor) {
                 return &vec[static_cast<size_t>(idx)].value;
             } else {
-                auto pit = parent_.find(ancestor);
-                ancestor = pit != parent_.end() ? pit->second : 0;
+                ancestor = parent_[static_cast<size_t>(ancestor)];
             }
         }
         return nullptr;
@@ -194,7 +193,19 @@ private:
     };
     std::unordered_map<std::string, std::vector<Entry>> stacks_;
     std::unordered_map<int, std::vector<std::string>> dirty_;
-    std::unordered_map<int, int> parent_; // level -> parent level (0 = chain terminates here)
+    // level -> parent level (0 = chain terminates here, which is also what a
+    // popped level reads back as). Levels come from `++nextLevel_`, so they are
+    // dense and monotonic and this is a plain vector indexed BY level, with
+    // element 0 the unused stand-in for "no parent" -- push_back in openLevel()
+    // keeps index == level. It used to be an unordered_map<int,int>, which cost
+    // one hash-node allocation per scope derivation (3 of the 10 allocations a
+    // user function call makes, ~2M of them in one Anklet.scad render) and made
+    // lookup()'s ancestry walk -- run on every variable read -- a hash probe per
+    // hop instead of an array index. It never shrinks: 4 bytes per level ever
+    // opened (~2.6MB for Anklet.scad), traded knowingly for the allocation.
+    // Levels are NEVER renumbered or reused -- lookup()'s sorted-merge walk
+    // depends on level numbers being globally monotonic.
+    std::vector<int> parent_{0};
     int nextLevel_ = 0;
 };
 
@@ -249,7 +260,7 @@ public:
     // call returns; ~TrailView() pops ITS bindings from ScopeTrailStorage
     // (erasing the very data the still-alive child's ancestry walk needs)
     // even though the walk can still numerically reach that ancestor level
-    // via ScopeTrailStorage::parent_ (that map entry is untouched -- only
+    // via ScopeTrailStorage::parent_ (that entry is untouched -- only
     // the DATA is gone). Caught by a closure created inside a let()
     // nested one level inside its own enclosing call reading undef for a
     // variable bound at the call's own (now-popped) level, not the let()'s
@@ -344,7 +355,7 @@ public:
 
     int openLevel(int parentLevel) {
         int level = ++nextLevel_;
-        parent_[level] = parentLevel;
+        parent_.push_back(parentLevel); // index == level; see parent_'s own comment
         return level;
     }
 
@@ -395,7 +406,7 @@ public:
             }
             dirty_.erase(it);
         }
-        parent_.erase(level);
+        parent_[static_cast<size_t>(level)] = 0; // dead: an ancestry walk stops here
     }
 
     // Same sorted-merge ancestry walk as ScopeTrailStorage::lookup -- see
@@ -414,8 +425,7 @@ public:
             } else if (entryLevel == ancestor) {
                 return &vec[static_cast<size_t>(idx)].value;
             } else {
-                auto pit = parent_.find(ancestor);
-                ancestor = pit != parent_.end() ? pit->second : 0;
+                ancestor = parent_[static_cast<size_t>(ancestor)];
             }
         }
         return nullptr;
@@ -450,7 +460,7 @@ private:
     std::shared_ptr<DynNameIntern> intern_;
     std::vector<std::vector<Entry>> stacks_;
     std::unordered_map<int, std::vector<int>> dirty_;
-    std::unordered_map<int, int> parent_;
+    std::vector<int> parent_{0}; // see ScopeTrailStorage::parent_
     int nextLevel_ = 0;
 };
 

{openscad_cpp_evaluator-1.4.1 → openscad_cpp_evaluator-1.6.0}/include/openscad_cpp_evaluator/utf8.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <string>
 #include <vector>
 
@@ -17,6 +18,11 @@ namespace oscadeval {
 // string that actually holds non-ASCII pays, and those are short in
 // practice.
 
+// One code point as UTF-8. The caller decides which code points are
+// legal -- chr() drops an invalid one, a \uXXXX escape substitutes a space
+// -- so this encodes whatever it is given.
+std::string utf8Encode(uint32_t cp);
+
 // True when every byte is < 0x80, so byte offsets and character offsets are
 // the same thing.
 bool utf8IsAscii(const std::string& s);

{openscad_cpp_evaluator-1.4.1 → openscad_cpp_evaluator-1.6.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.4.1 → openscad_cpp_evaluator-1.6.0}/src/builtins/call_args.cpp

@@ -106,6 +106,18 @@ const oscad::Expression* argExpr(const oscad::Argument& arg) {
     return static_cast<const oscad::PositionalArgument&>(arg).expr.get();
 }
 
+size_t positionalCount(const CallArgs& args) {
+    int maxPos = -1;
+    for (const auto& [idx, v] : args.positional) maxPos = std::max(maxPos, idx);
+    return static_cast<size_t>(maxPos + 1);
+}
+
+const Value& positionalAt(const CallArgs& args, size_t pos) {
+    static const Value kUndef;
+    const Value* v = args.findPositional(static_cast<int>(pos));
+    return v ? *v : kUndef;
+}
+
 std::vector<Value> allPositional(const CallArgs& args) {
     int maxPos = -1;
     for (const auto& [idx, v] : args.positional) maxPos = std::max(maxPos, idx);

{openscad_cpp_evaluator-1.4.1 → openscad_cpp_evaluator-1.6.0}/src/builtins/function_builtins.cpp

@@ -193,29 +193,8 @@ double atan2Degrees(double y, double x) {
     return std::fabs(degs - whole) < 3.0E-14 ? whole : degs;
 }
 
-// UTF-8 encode/decode for chr()/ord() -- OpenSCAD strings are unicode text,
-// not byte arrays, so a codepoint above U+007F needs real multi-byte
-// handling, not a raw byte cast.
-std::string utf8Encode(uint32_t cp) {
-    std::string out;
-    if (cp <= 0x7F) {
-        out.push_back(static_cast<char>(cp));
-    } else if (cp <= 0x7FF) {
-        out.push_back(static_cast<char>(0xC0 | (cp >> 6)));
-        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
-    } else if (cp <= 0xFFFF) {
-        out.push_back(static_cast<char>(0xE0 | (cp >> 12)));
-        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
-        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
-    } else {
-        out.push_back(static_cast<char>(0xF0 | (cp >> 18)));
-        out.push_back(static_cast<char>(0x80 | ((cp >> 12) & 0x3F)));
-        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
-        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
-    }
-    return out;
-}
-
+// utf8Encode lives in utf8.cpp -- the string-literal escape decoder
+// (\uXXXX) needs it too.
 uint32_t utf8DecodeFirst(const std::string& s) {
     if (s.empty()) return 0;
     const auto b = [&](size_t i) { return static_cast<unsigned char>(s[i]); };
@@ -1200,15 +1179,15 @@ void warnConversion(Evaluator& ev, const std::string& name, const std::string& w
 // numbers, with a distinct "at least 1 vector element" arity text for the
 // empty-vector case.
 bool checkMinMax(Evaluator& ev, const std::string& name, const CallArgs& args, const oscad::Position* pos) {
-    const std::vector<Value> positional = allPositional(args);
-    const size_t count = positional.size() + args.named.size();
+    const size_t nPos = positionalCount(args);
+    const size_t count = nPos + args.named.size();
     if (count < 1) {
         warnArity(ev, name, "at least 1", count, pos);
         return false;
     }
-    if (positional.size() == 1 && std::holds_alternative<ListPtr>(positional[0])) {
+    if (nPos == 1 && std::holds_alternative<ListPtr>(positionalAt(args, 0))) {
         static const std::vector<Value> kEmptyItems;
-        const ListPtr& l = std::get<ListPtr>(positional[0]);
+        const ListPtr& l = std::get<ListPtr>(positionalAt(args, 0));
         const std::vector<Value>& items = l ? l->items : kEmptyItems;
         if (items.empty()) {
             warnArity(ev, name, "at least 1 vector element", 0, pos);
@@ -1222,9 +1201,9 @@ bool checkMinMax(Evaluator& ev, const std::string& name, const CallArgs& args, c
         }
         return true;
     }
-    for (size_t i = 0; i < positional.size(); ++i) {
-        if (!std::holds_alternative<double>(positional[i])) {
-            warnConversion(ev, name, "argument " + std::to_string(i), "number", positional[i], pos);
+    for (size_t i = 0; i < nPos; ++i) {
+        if (!std::holds_alternative<double>(positionalAt(args, i))) {
+            warnConversion(ev, name, "argument " + std::to_string(i), "number", positionalAt(args, i), pos);
             return false;
         }
     }
@@ -1240,8 +1219,8 @@ bool checkBuiltinArgs(Evaluator& ev, const std::string& name, BuiltinFnId id, co
     if (it == checks.end()) return true;
     const BuiltinCheck& c = it->second;
 
-    const std::vector<Value> positional = allPositional(args);
-    const size_t count = positional.size() + args.named.size();
+    const size_t nPos = positionalCount(args);
+    const size_t count = nPos + args.named.size();
     if (c.arityText && (static_cast<int>(count) < c.minArgs || (c.maxArgs >= 0 && static_cast<int>(count) > c.maxArgs))) {
         warnArity(ev, name, c.arityText, count, pos);
         return false;
@@ -1250,9 +1229,10 @@ bool checkBuiltinArgs(Evaluator& ev, const std::string& name, BuiltinFnId id, co
     // flat argument list can't be reconstructed from our split
     // positional/named form, and warning on the wrong index would be worse
     // than staying quiet on a spelling nobody uses for these builtins.
-    for (size_t i = 0; i < c.types.size() && i < positional.size(); ++i) {
-        if (!(typeBit(positional[i]) & c.types[i].allowed)) {
-            warnConversion(ev, name, "argument " + std::to_string(i), c.types[i].expected, positional[i], pos);
+    for (size_t i = 0; i < c.types.size() && i < nPos; ++i) {
+        const Value& v = positionalAt(args, i);
+        if (!(typeBit(v) & c.types[i].allowed)) {
+            warnConversion(ev, name, "argument " + std::to_string(i), c.types[i].expected, v, pos);
             return false;
         }
     }

{openscad_cpp_evaluator-1.4.1 → openscad_cpp_evaluator-1.6.0}/src/bytecode_vm.cpp

@@ -20,10 +20,18 @@ namespace {
 
 // Shared by Op::CallFn's isBuiltin (evalBuiltinFunction) and isImport
 // (importAsValue) branches -- both take the same pre-resolved CallArgs
-// shape resolveArgs would build for the interpreter path. `args` is
-// consumed (each element moved out).
-CallArgs buildCallArgs(const CompiledChunk::CallSite& site, std::vector<Value>& args, size_t argCount) {
-    CallArgs callArgs;
+// shape resolveArgs would build for the interpreter path. `args` points
+// AT THE CALLER FRAME'S OPERAND STACK, not at a copy: the arguments are
+// already sitting there contiguously and in order, so every Op::Call*
+// hands over `f.stack.data() + argBase` and truncates the stack once the
+// arguments have been moved out. Building a `std::vector<Value>` for them
+// instead was the single largest allocation site in the whole evaluator --
+// 2.57M of one Anklet.scad render's 12.7M allocations, one per function
+// call, builtins included. `args` is consumed (each element moved out), and
+// nothing may push to that stack until it has been.
+CallArgs& buildCallArgs(const CompiledChunk::CallSite& site, Value* args, size_t argCount, CallArgs& callArgs) {
+    callArgs.positional.clear();
+    callArgs.named.clear();
     int positionalIdx = 0;
     for (size_t i = 0; i < argCount; ++i) {
         if (site.argNames[i]) {
@@ -41,7 +49,7 @@ CallArgs buildCallArgs(const CompiledChunk::CallSite& site, std::vector<Value>&
 // LIST is `paramNames` (in declared order -- a FunctionDeclaration's
 // parameters or a FunctionLiteral's). Shared by CallFn/CallFnTail (a
 // site.decl callee) and CallDynamic/CallDynamicTail (a closure callee).
-BoundArgs buildBoundArgs(Evaluator& ev, const CompiledChunk::CallSite& site, std::vector<Value>& args, size_t argCount,
+BoundArgs buildBoundArgs(Evaluator& ev, const CompiledChunk::CallSite& site, Value* args, size_t argCount,
                           const std::vector<std::unique_ptr<oscad::ParameterDeclaration>>& paramNames) {
     BoundArgs bound;
     bound.reserve(argCount);
@@ -176,7 +184,7 @@ void applyCompiledDefaultsToFrame(Evaluator& ev, const CompiledChunk& chunk, VmF
         if (!chunk.defaultCode[i].empty()) {
             auto defaultFrame = ev.acquireVmFrame();
             defaultFrame->chunk = &chunk;
-            defaultFrame->code = &chunk.defaultCode[i];
+            defaultFrame->setCode(chunk.defaultCode[i]);
             defaultFrame->pc = 0;
             defaultFrame->slots = frame.slots; // defaults may read earlier SIBLING slots? no -- compiled with an
                                                  // isolated (zero-frame) scope, see bytecode_compiler.cpp's
@@ -213,7 +221,7 @@ void pushBareFrame(Evaluator& ev, const CompiledChunk& chunk, const std::vector<
                     EvalContext ctx) {
     auto frame = ev.acquireVmFrame();
     frame->chunk = &chunk;
-    frame->code = &code;
+    frame->setCode(code);
     frame->pc = 0;
     frame->slots.assign(static_cast<size_t>(chunk.numSlots), Value{});
     frame->stack.clear();
@@ -254,7 +262,7 @@ void pushBracketedCallFrame(Evaluator& ev, const CompiledChunk& chunk, const osc
 
     auto frame = ev.acquireVmFrame();
     frame->chunk = &chunk;
-    frame->code = &chunk.bodyCode;
+    frame->setCode(chunk.bodyCode);
     frame->pc = 0;
     frame->slots.assign(static_cast<size_t>(chunk.numSlots), Value{});
     frame->stack.clear();
@@ -314,7 +322,7 @@ void pushBracketedModuleFrame(Evaluator& ev, const CompiledChunk& chunk, const o
     }
     auto frame = ev.acquireVmFrame();
     frame->chunk = &chunk;
-    frame->code = &chunk.bodyCode;
+    frame->setCode(chunk.bodyCode);
     frame->pc = 0;
     // See runCompiledModuleBody's own doc comment (below) for why this is
     // .assign(numSlots) now, not .clear() -- a nested let-expression
@@ -369,7 +377,7 @@ void pushChildrenForwardFrame(Evaluator& ev, const CompiledChunk& chunk, EvalCon
     }
     auto frame = ev.acquireVmFrame();
     frame->chunk = &chunk;
-    frame->code = &chunk.bodyCode;
+    frame->setCode(chunk.bodyCode);
     frame->pc = 0;
     frame->slots.assign(static_cast<size_t>(chunk.numSlots), Value{});
     frame->stack.clear();
@@ -491,7 +499,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
         }
         while (ev.vmCallStack_.size() > floor) {
             VmFrame& f = *ev.vmCallStack_.back();
-            if (f.pc >= f.code->size()) {
+            if (f.pc >= f.codeSize) {
                 // A module chunk produces nothing on the stack at all --
                 // its whole effect already landed in treeStack_ as a side
                 // effect of running its own body (Op::CallModule/
@@ -528,7 +536,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                 continue;
             }
 
-            const Instruction& ins = (*f.code)[f.pc];
+            const Instruction& ins = f.code[f.pc];
             EvalContext& ctx = f.ctxChain.back();
             switch (ins.op) {
                 case Op::PushConst:
@@ -787,27 +795,28 @@ Value driveVm(Evaluator& ev, size_t floor) {
                 case Op::CallFn: {
                     const CompiledChunk::CallSite& site = f.chunk->callSites[static_cast<size_t>(ins.a)];
                     const size_t argCount = static_cast<size_t>(ins.b);
-                    std::vector<Value> args(argCount);
-                    for (size_t i = 0; i < argCount; ++i) {
-                        args[argCount - 1 - i] = std::move(f.stack.back());
-                        f.stack.pop_back();
-                    }
+                    const size_t argBase = f.stack.size() - argCount;
+                    Value* args = f.stack.data() + argBase; // into f.stack; truncated below once consumed
                     if (site.isImport) {
-                        CallArgs callArgs = buildCallArgs(site, args, argCount);
+                        CallArgs& callArgs = buildCallArgs(site, args, argCount, f.argScratch);
+                        f.stack.resize(argBase);
                         f.stack.push_back(importAsValue(ev, callArgs, *site.callNode));
                         ++f.pc;
                     } else if (site.isBuiltin && site.calleeName == "object") {
                         std::vector<std::pair<std::optional<std::string>, Value>> pairs;
                         pairs.reserve(argCount);
                         for (size_t i = 0; i < argCount; ++i) pairs.emplace_back(site.argNames[i], std::move(args[i]));
+                        f.stack.resize(argBase);
                         f.stack.push_back(mergeObjectArgs(ev, pairs, &site.callNode->position()));
                         ++f.pc;
                     } else if (site.isBuiltin) {
-                        CallArgs callArgs = buildCallArgs(site, args, argCount);
+                        CallArgs& callArgs = buildCallArgs(site, args, argCount, f.argScratch);
+                        f.stack.resize(argBase);
                         f.stack.push_back(evalBuiltinFunction(ev, site.calleeName, callArgs, *site.callNode));
                         ++f.pc;
                     } else {
                         BoundArgs bound = buildBoundArgs(ev, site, args, argCount, site.decl->parameters);
+                        f.stack.resize(argBase);
                         const CompiledChunk* calleeChunk = ev.useBytecodeVm() ? ev.lookupOrCompileChunk(*site.decl) : nullptr;
                         if (calleeChunk) {
                             const oscad::Scope* fnScope = ctx.scopeOf(*site.decl) ? ctx.scopeOf(*site.decl) : ctx.scope;
@@ -828,17 +837,14 @@ Value driveVm(Evaluator& ev, size_t floor) {
                 case Op::CallDynamic: {
                     const CompiledChunk::CallSite& site = f.chunk->callSites[static_cast<size_t>(ins.a)];
                     const size_t argCount = static_cast<size_t>(ins.b);
-                    std::vector<Value> args(argCount);
-                    for (size_t i = 0; i < argCount; ++i) {
-                        args[argCount - 1 - i] = std::move(f.stack.back());
-                        f.stack.pop_back();
-                    }
-                    Value callee = std::move(f.stack.back());
-                    f.stack.pop_back();
+                    const size_t argBase = f.stack.size() - argCount;
+                    Value* args = f.stack.data() + argBase; // into f.stack; truncated below once consumed
+                    Value callee = std::move(f.stack[argBase - 1]);
                     if (const auto* closurePtr = std::get_if<ClosurePtr>(&callee); closurePtr && *closurePtr) {
                         const Closure& closure = **closurePtr;
                         const oscad::FunctionLiteral& funcNode = *closure.node;
                         BoundArgs bound = buildBoundArgs(ev, site, args, argCount, funcNode.parameters);
+                        f.stack.resize(argBase - 1); // also drops the callee
                         const CompiledChunk* calleeChunk = ev.useBytecodeVm() ? ev.lookupCompiledLiteralChunk(funcNode) : nullptr;
                         if (calleeChunk) {
                             const oscad::Scope* fnScope = ctx.scopeOf(funcNode) ? ctx.scopeOf(funcNode) : ctx.scope;
@@ -851,6 +857,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                         }
                     } else {
                         if (!site.calleeName.empty()) ev.warn("Ignoring unknown function '" + site.calleeName + "'", ins.pos);
+                        f.stack.resize(argBase - 1); // arguments and callee both go
                         f.stack.push_back(Value{});
                         ++f.pc;
                     }
@@ -859,12 +866,10 @@ Value driveVm(Evaluator& ev, size_t floor) {
                 case Op::CallFnTail: {
                     const CompiledChunk::CallSite& site = f.chunk->callSites[static_cast<size_t>(ins.a)];
                     const size_t argCount = static_cast<size_t>(ins.b);
-                    std::vector<Value> args(argCount);
-                    for (size_t i = 0; i < argCount; ++i) {
-                        args[argCount - 1 - i] = std::move(f.stack.back());
-                        f.stack.pop_back();
-                    }
+                    const size_t argBase = f.stack.size() - argCount;
+                    Value* args = f.stack.data() + argBase; // into f.stack; truncated below once consumed
                     BoundArgs bound = buildBoundArgs(ev, site, args, argCount, site.decl->parameters);
+                    f.stack.resize(argBase);
                     // Tail-hop-in-place requires f.hopEligible -- a frame
                     // that's call-boundary-free (statement expression,
                     // assignment block, parameter default) has no
@@ -890,7 +895,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     if (calleeChunk) {
                         ev.recordTailCallHop(site.calleeName, *site.decl, &site.callNode->position(), f.tailHopGuard);
                         f.chunk = calleeChunk;
-                        f.code = &calleeChunk->bodyCode;
+                        f.setCode(calleeChunk->bodyCode);
                         f.pc = 0;
                         f.slots.assign(static_cast<size_t>(calleeChunk->numSlots), Value{});
                         f.stack.clear();
@@ -921,17 +926,14 @@ Value driveVm(Evaluator& ev, size_t floor) {
                 case Op::CallDynamicTail: {
                     const CompiledChunk::CallSite& site = f.chunk->callSites[static_cast<size_t>(ins.a)];
                     const size_t argCount = static_cast<size_t>(ins.b);
-                    std::vector<Value> args(argCount);
-                    for (size_t i = 0; i < argCount; ++i) {
-                        args[argCount - 1 - i] = std::move(f.stack.back());
-                        f.stack.pop_back();
-                    }
-                    Value callee = std::move(f.stack.back());
-                    f.stack.pop_back();
+                    const size_t argBase = f.stack.size() - argCount;
+                    Value* args = f.stack.data() + argBase; // into f.stack; truncated below once consumed
+                    Value callee = std::move(f.stack[argBase - 1]);
                     if (const auto* closurePtr = std::get_if<ClosurePtr>(&callee); closurePtr && *closurePtr) {
                         const Closure& closure = **closurePtr;
                         const oscad::FunctionLiteral& funcNode = *closure.node;
                         BoundArgs bound = buildBoundArgs(ev, site, args, argCount, funcNode.parameters);
+                        f.stack.resize(argBase - 1); // also drops the callee
                         const bool thisFrameBracketed = f.hopEligible;
                         std::optional<EvalContext> hopCtx = thisFrameBracketed
                                                                  ? ev.isolatedCallCtxFor(funcNode, ctx, capturedLetTrail(closure))
@@ -942,7 +944,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                         if (calleeChunk) {
                             ev.recordTailCallHop("<function literal>", funcNode, ins.pos, f.tailHopGuard);
                             f.chunk = calleeChunk;
-                            f.code = &calleeChunk->bodyCode;
+                            f.setCode(calleeChunk->bodyCode);
                             f.pc = 0;
                             f.slots.assign(static_cast<size_t>(calleeChunk->numSlots), Value{});
                             f.stack.clear();
@@ -967,6 +969,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                         }
                     } else {
                         if (!site.calleeName.empty()) ev.warn("Ignoring unknown function '" + site.calleeName + "'", ins.pos);
+                        f.stack.resize(argBase - 1); // arguments and callee both go
                         f.stack.push_back(Value{});
                         ++f.pc;
                     }
@@ -1559,7 +1562,7 @@ Value runCompiledFunction(Evaluator& ev, const CompiledChunk& chunk,
                           EvalContext& childCtx) {
     auto frame = ev.acquireVmFrame();
     frame->chunk = &chunk;
-    frame->code = &chunk.bodyCode;
+    frame->setCode(chunk.bodyCode);
     frame->pc = 0;
     frame->slots.assign(static_cast<size_t>(chunk.numSlots), Value{});
     frame->stack.clear();
@@ -1585,7 +1588,7 @@ Value runCompiledFunctionFromBound(Evaluator& ev, const CompiledChunk& chunk, co
                                     EvalContext& childCtx) {
     auto frame = ev.acquireVmFrame();
     frame->chunk = &chunk;
-    frame->code = &chunk.bodyCode;
+    frame->setCode(chunk.bodyCode);
     frame->pc = 0;
     frame->slots.assign(static_cast<size_t>(chunk.numSlots), Value{});
     frame->stack.clear();
@@ -1644,7 +1647,7 @@ void runCompiledModuleBody(Evaluator& ev, const CompiledChunk& chunk, EvalContex
     // exactly (VmFrame::ownsModuleSplice's own doc comment, bytecode_vm.hpp).
     auto frame = ev.acquireVmFrame();
     frame->chunk = &chunk;
-    frame->code = &chunk.bodyCode;
+    frame->setCode(chunk.bodyCode);
     frame->pc = 0;
     // .assign, not .clear() -- a module chunk's own bodyCode has no
     // PARAMETER slots (module params are always bound natively, see this

{openscad_cpp_evaluator-1.4.1 → openscad_cpp_evaluator-1.6.0}/src/user_calls.cpp

@@ -685,7 +685,7 @@ void Evaluator::recordTailCallHop(const std::string& calleeName, const oscad::AS
     // here too, or it would count the OLD declaration as active forever
     // and never see the NEW one at all.
     noteActiveDeclExit(frame.declNode);
-    ++activeDeclRefcount_[&calleeDecl];
+    noteActiveDeclEnter(&calleeDecl);
     frame.name = calleeName;
     frame.declNode = &calleeDecl;
     frame.declPosition = &calleeDecl.position();
@@ -736,16 +736,22 @@ Evaluator::UserCallHandle Evaluator::enterUserCall(const std::string& name, cons
     callStack_.push_back(CallStackFrame{kind, name, callPos, &declNode.position(), &declNode, nullptr, upvalueParent});
     callStack_.back().bodyCtx = &childCtx; // per-frame locals for the debugger
     if (isModule) ++moduleCallDepth_;
-    ++activeDeclRefcount_[&declNode];
+    noteActiveDeclEnter(&declNode);
     if (bodyExpr) checkDebug(*bodyExpr, childCtx);
     lastCtx_ = &childCtx;
     return h;
 }
 
 void Evaluator::noteActiveDeclExit(const oscad::ASTNode* declNode) {
-    auto it = activeDeclRefcount_.find(declNode);
-    if (it == activeDeclRefcount_.end()) return; // defensive; should always be found
-    if (--it->second <= 0) activeDeclRefcount_.erase(it);
+    for (auto it = activeDeclRefcount_.begin(); it != activeDeclRefcount_.end(); ++it) {
+        if (it->first != declNode) continue;
+        if (--it->second <= 0) {
+            *it = activeDeclRefcount_.back(); // order is not meaningful
+            activeDeclRefcount_.pop_back();
+        }
+        return;
+    }
+    // not found: defensive; should always be present
 }
 
 void Evaluator::exitUserCallSuccess(const std::string& name, const UserCallHandle& handle, const Value& result,

{openscad_cpp_evaluator-1.4.1 → openscad_cpp_evaluator-1.6.0}/src/utf8.cpp

@@ -17,6 +17,26 @@ size_t nextCharStart(const std::string& s, size_t i) {
 
 } // namespace
 
+std::string utf8Encode(uint32_t cp) {
+    std::string out;
+    if (cp <= 0x7F) {
+        out.push_back(static_cast<char>(cp));
+    } else if (cp <= 0x7FF) {
+        out.push_back(static_cast<char>(0xC0 | (cp >> 6)));
+        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
+    } else if (cp <= 0xFFFF) {
+        out.push_back(static_cast<char>(0xE0 | (cp >> 12)));
+        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
+        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
+    } else {
+        out.push_back(static_cast<char>(0xF0 | (cp >> 18)));
+        out.push_back(static_cast<char>(0x80 | ((cp >> 12) & 0x3F)));
+        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
+        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
+    }
+    return out;
+}
+
 bool utf8IsAscii(const std::string& s) {
     for (char c : s) {
         if (static_cast<unsigned char>(c) >= 0x80) return false;