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

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

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

{openscad_cpp_evaluator-1.41.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.41.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.41.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.41.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.41.0"
+version = "1.42.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

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

@@ -118,6 +118,7 @@ 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

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.42.0}/src/builtins/function_builtins.cpp

@@ -246,23 +246,6 @@ Value builtinPow(double a, double b) {
 
 // -- cross/rands/search/lookup --------------------------------------------
 
-Value builtinCross(const Value& aArg, const Value& bArg) {
-    const auto a = allNumericList(aArg);
-    const auto b = allNumericList(bArg);
-    if (!a || !b) return Value{};
-    for (double x : *a) {
-        if (!std::isfinite(x)) return Value{};
-    }
-    for (double x : *b) {
-        if (!std::isfinite(x)) return Value{};
-    }
-    if (a->size() == 2 && b->size() == 2) return Value{(*a)[0] * (*b)[1] - (*a)[1] * (*b)[0]};
-    if (a->size() == 3 && b->size() == 3) {
-        return numList({(*a)[1] * (*b)[2] - (*a)[2] * (*b)[1], (*a)[2] * (*b)[0] - (*a)[0] * (*b)[2],
-                         (*a)[0] * (*b)[1] - (*a)[1] * (*b)[0]});
-    }
-    return Value{};
-}
 
 // -- linear_solve(A, b) --------------------------------------------------
 //
@@ -784,36 +767,49 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
     return Value{};
 }
 
-Value builtinLookup(const CallArgs& args) {
-    // Guarded here rather than via scalarNumericArity() -- the second
-    // argument is a table, so the all-arguments-are-numbers rule can't
-    // apply. Without this, toDoubleLenient() turns a non-numeric key into
-    // 0.0 and the lookup silently returns the table's first value.
+// upstream builtin_lookup, line for line: a non-finite key warns; the
+// first row must be exactly two numbers or the answer is undef; later rows
+// that aren't are skipped; the low/high candidates are picked in table
+// order (the first of equal keys wins), then interpolated. This used to
+// sort the table, coerce malformed rows, and accept inf/nan keys silently.
+Value builtinLookup(Evaluator& ev, const CallArgs& args, const oscad::Position* pos) {
     const Value keyArg = getArg(args, 0, "key", Value{});
-    if (!std::holds_alternative<double>(keyArg)) return Value{};
-    const double key = std::get<double>(keyArg);
-    const Value tableArg = getArg(args, 1, "table", Value{});
-    const ListPtr* tablePtr = std::get_if<ListPtr>(&tableArg);
-    if (!tablePtr || !*tablePtr) return Value{};
-
-    std::vector<std::pair<double, double>> pairs;
-    for (const Value& row : (*tablePtr)->items) {
-        const ListPtr* rowPtr = std::get_if<ListPtr>(&row);
-        if (!rowPtr || !*rowPtr || (*rowPtr)->items.size() < 2) continue;
-        pairs.emplace_back(toDoubleLenient((*rowPtr)->items[0]), toDoubleLenient((*rowPtr)->items[1]));
+    const double p = std::get<double>(keyArg);  // checkBuiltinArgs: a number
+    if (!std::isfinite(p)) {
+        ev.warn("lookup(" + fmtValue(keyArg) + ", ...) first argument is not a number", pos);
+        return Value{};
     }
-    if (pairs.empty()) return Value{};
-    std::stable_sort(pairs.begin(), pairs.end(), [](const auto& a, const auto& b) { return a.first < b.first; });
-    if (key <= pairs.front().first) return Value{pairs.front().second};
-    if (key >= pairs.back().first) return Value{pairs.back().second};
-    for (size_t i = 0; i + 1 < pairs.size(); ++i) {
-        const double k0 = pairs[i].first, k1 = pairs[i + 1].first;
-        if (k0 <= key && key <= k1) {
-            const double t = (k1 == k0) ? 0.0 : (key - k0) / (k1 - k0);
-            return Value{pairs[i].second + t * (pairs[i + 1].second - pairs[i].second)};
+    const auto& vec = std::get<ListPtr>(getArg(args, 1, "table", Value{}))->items;  // checkBuiltinArgs: a vector
+    const auto vec2 = [](const Value& v, double& a, double& b) {
+        const ListPtr* l = std::get_if<ListPtr>(&v);
+        if (!l || !*l || (*l)->items.size() != 2) return false;
+        const double* x = std::get_if<double>(&(*l)->items[0]);
+        const double* y = std::get_if<double>(&(*l)->items[1]);
+        if (!x || !y) return false;
+        a = *x;
+        b = *y;
+        return true;
+    };
+    double lowP, lowV, highP, highV;
+    if (vec.empty() || !vec2(vec[0], lowP, lowV)) return Value{};
+    highP = lowP;
+    highV = lowV;
+    for (size_t k = 1; k < vec.size(); ++k) {
+        double thisP, thisV;
+        if (!vec2(vec[k], thisP, thisV)) continue;
+        if (thisP <= p && (thisP > lowP || lowP > p)) {
+            lowP = thisP;
+            lowV = thisV;
+        }
+        if (thisP >= p && (thisP < highP || highP < p)) {
+            highP = thisP;
+            highV = thisV;
         }
     }
-    return Value{0.0};
+    if (p <= lowP) return Value{highV};
+    if (p >= highP) return Value{lowV};
+    const double f = (p - lowP) / (highP - lowP);
+    return Value{highV * f + lowV * (1 - f)};
 }
 
 std::string asStringOr(const Value& v, const std::string& fallback) {
@@ -1155,12 +1151,14 @@ const std::unordered_map<int, BuiltinCheck>& builtinChecks() {
         std::unordered_map<int, BuiltinCheck> m;
         const auto add = [&m](BuiltinFnId id, BuiltinCheck c) { m.emplace(static_cast<int>(id), std::move(c)); };
         for (BuiltinFnId id : {BuiltinFnId::Abs, BuiltinFnId::Sign, BuiltinFnId::Ceil, BuiltinFnId::Floor,
-                                BuiltinFnId::Round, BuiltinFnId::Sqrt, BuiltinFnId::Ln, BuiltinFnId::Log,
+                                BuiltinFnId::Round, BuiltinFnId::Sqrt, BuiltinFnId::Ln,
                                 BuiltinFnId::Exp, BuiltinFnId::Sin, BuiltinFnId::Cos, BuiltinFnId::Tan,
                                 BuiltinFnId::Asin, BuiltinFnId::Acos, BuiltinFnId::Atan}) {
             add(id, {1, 1, "1", {kNum}});
         }
         add(BuiltinFnId::Atan2, {2, 2, "2", {kNum, kNum}});
+        // log(x) or log(base, x); upstream's count warning names 2.
+        add(BuiltinFnId::Log, {1, 2, "2", {kNum, kNum}});
         add(BuiltinFnId::Pow, {2, 2, "2", {kNum, kNum}});
         add(BuiltinFnId::Cross, {2, 2, "2", {kVec, kVec}});
         add(BuiltinFnId::Lookup, {2, 2, "2", {kNum, kVec}});
@@ -1275,6 +1273,9 @@ BuiltinFnId builtinFnIdFor(const std::string& name) {
     return it == ids.end() ? BuiltinFnId::None : it->second;
 }
 
+Value evalBuiltinFunctionInOrder(Evaluator& ev, BuiltinFnId id, const std::string& name, const CallArgs& args,
+                                 const oscad::ASTNode& node);
+
 Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs& args, const oscad::ASTNode& node) {
     return evalBuiltinFunctionResolved(ev, builtinFnIdFor(name), builtinParamNames(name), name, args, node);
 }
@@ -1297,6 +1298,36 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
         }
     }
 
+    // Every other builtin function reads its arguments IN ORDER and ignores
+    // their names, exactly as upstream's builtin_* functions index
+    // `arguments[i]`: sin(a=90) is sin(90), pow(y=3, x=2) is 3^2, and
+    // rands(0, 1, 2, seed_value=5) is seeded. Names used to bind by this
+    // port's own spelling and drop the rest silently -- sin(a=90) was 0,
+    // concat(a=[1], b=[2]) was [], rands(seed_value=) went unseeded.
+    // (textmetrics/fontmetrics -- with declaredParams -- and dxf_dim/
+    // dxf_cross parse names upstream, through Parameters::parse.)
+    const bool byName = declaredParams || id == BuiltinFnId::DxfDim || id == BuiltinFnId::DxfCross;
+    CallArgs ordered;
+    if (!byName && node.kind() == oscad::NodeKind::PrimaryCall && !args.named.empty()) {
+        int k = 0, out = 0;
+        for (const auto& a : static_cast<const oscad::PrimaryCall&>(node).arguments) {
+            const Value* v = nullptr;
+            if (a->kind() == oscad::NodeKind::PositionalArgument) {
+                v = args.findPositional(k++);
+            } else {
+                const std::string& n = static_cast<const oscad::NamedArgument&>(*a).name->name;
+                if (isConfigVariable(n)) continue;  // a $-override, not an argument
+                v = args.findNamed(n);
+            }
+            ordered.setPositional(out++, v ? *v : Value{});
+        }
+    }
+    const CallArgs& argsInOrder = (!byName && !args.named.empty()) ? ordered : args;
+    return evalBuiltinFunctionInOrder(ev, id, name, argsInOrder, node);
+}
+
+Value evalBuiltinFunctionInOrder(Evaluator& ev, BuiltinFnId id, const std::string& name, const CallArgs& args,
+                                 const oscad::ASTNode& node) {
     // Arity and argument types, with the reference's own two diagnostics.
     // This replaced a silent version of the same gate (scalarNumericArity /
     // numericOnlyNames), which returned undef without ever saying why.
@@ -1321,8 +1352,10 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
         }
         case BuiltinFnId::Round: {
             const double x = toDoubleLenient(getArg(args, 0, "x", Value{}));
-            if (std::isnan(x) || std::isinf(x)) return Value{x};
-            return Value{x >= 0 ? std::floor(x + 0.5) : std::ceil(x - 0.5)};
+            // std::round, as upstream: halves away from zero, exactly. The
+            // floor(x + 0.5) this was rounded 0.49999999999999994 up to 1
+            // (the sum rounds to 1.0) and broke integers above 2^52.
+            return Value{std::round(x)};
         }
         case BuiltinFnId::Sqrt: {
             const double x = toDoubleLenient(getArg(args, 0, "x", Value{}));
@@ -1334,9 +1367,13 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
             return Value{x < 0 ? std::numeric_limits<double>::quiet_NaN() : std::log(x)};
         }
         case BuiltinFnId::Log: {
-            const double x = toDoubleLenient(getArg(args, 0, "x", Value{}));
-            if (x == 0) return Value{-std::numeric_limits<double>::infinity()};
-            return Value{x < 0 ? std::numeric_limits<double>::quiet_NaN() : std::log10(x)};
+            // upstream builtin_log: log(y) / log(base), base 10 by default --
+            // that formula, not log10(), so results agree to the last bit.
+            // The two-argument form was missing (log(2, 8) was undef).
+            const bool twoArgs = positionalCount(args) == 2;
+            const double base = twoArgs ? toDoubleLenient(getArg(args, 0, "base", Value{})) : 10.0;
+            const double y = toDoubleLenient(getArg(args, twoArgs ? 1 : 0, "x", Value{}));
+            return Value{std::log(y) / std::log(base)};
         }
         case BuiltinFnId::Exp: return Value{std::exp(toDoubleLenient(getArg(args, 0, "x", Value{})))};
         case BuiltinFnId::Sin: return Value{sinDegrees(toDoubleLenient(getArg(args, 0, "x", Value{})))};
@@ -1371,25 +1408,42 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
             return Value{std::sqrt(sum)};
         }
         case BuiltinFnId::Cross: {
+            // upstream builtin_cross, check for check: two 2-vectors are
+            // multiplied as they are (a non-number counts as 0, inf and nan
+            // propagate -- no checks at all); otherwise both must be
+            // 3-vectors, and each element pair is checked in order for a
+            // non-number, then NaN, then infinity, each with its own warning.
             const Value a = getArg(args, 0, "a", Value{});
             const Value b = getArg(args, 1, "b", Value{});
-            // Two distinct messages, and the size check runs first: a
-            // 4-element operand is a size complaint even when it also holds
-            // a string.
-            const auto sizeOf = [](const Value& v) {
-                const ListPtr* l = std::get_if<ListPtr>(&v);
-                return (l && *l) ? (*l)->items.size() : size_t{0};
+            const auto& va = std::get<ListPtr>(a)->items;
+            const auto& vb = std::get<ListPtr>(b)->items;
+            const auto num = [](const Value& v) {
+                const double* d = std::get_if<double>(&v);
+                return d ? *d : 0.0;
             };
-            const size_t na = sizeOf(a), nb = sizeOf(b);
-            if (na != nb || (na != 2 && na != 3)) {
+            if (va.size() == 2 && vb.size() == 2) return Value{num(va[0]) * num(vb[1]) - num(va[1]) * num(vb[0])};
+            if (va.size() != 3 || vb.size() != 3) {
                 ev.warn("Invalid vector size of parameter for cross()", &node.position());
                 return Value{};
             }
-            if (!allNumericList(a) || !allNumericList(b)) {
-                ev.warn("Invalid value in parameter vector for cross()", &node.position());
-                return Value{};
+            for (size_t k = 0; k < 3; ++k) {
+                if (!std::holds_alternative<double>(va[k]) || !std::holds_alternative<double>(vb[k])) {
+                    ev.warn("Invalid value in parameter vector for cross()", &node.position());
+                    return Value{};
+                }
+                const double d0 = std::get<double>(va[k]), d1 = std::get<double>(vb[k]);
+                if (std::isnan(d0) || std::isnan(d1)) {
+                    ev.warn("Invalid value (NaN) in parameter vector for cross()", &node.position());
+                    return Value{};
+                }
+                if (std::isinf(d0) || std::isinf(d1)) {
+                    ev.warn("Invalid value (INF) in parameter vector for cross()", &node.position());
+                    return Value{};
+                }
             }
-            return builtinCross(a, b);
+            return numList({num(va[1]) * num(vb[2]) - num(va[2]) * num(vb[1]),
+                            num(va[2]) * num(vb[0]) - num(va[0]) * num(vb[2]),
+                            num(va[0]) * num(vb[1]) - num(va[1]) * num(vb[0])});
         }
         case BuiltinFnId::Rands: {
             ev.noteRandsCall();
@@ -1493,7 +1547,7 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
             return Value{std::holds_alternative<ObjectPtr>(x) && std::get<ObjectPtr>(x) != nullptr};
         }
         case BuiltinFnId::Search: return builtinSearch(args, ev, &node.position());
-        case BuiltinFnId::Lookup: return builtinLookup(args);
+        case BuiltinFnId::Lookup: return builtinLookup(ev, args, &node.position());
         case BuiltinFnId::HasKey: {
             const Value objArg = getArg(args, 0, "object", Value{});
             const ObjectPtr* obj = std::get_if<ObjectPtr>(&objArg);

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.42.0}/src/bytecode_compiler.cpp

@@ -404,13 +404,14 @@ public:
             case NodeKind::BooleanLiteral:
                 out.push_back({Op::PushBool, static_cast<const oscad::BooleanLiteral&>(node).val ? 1 : 0, 0, nullptr});
                 return;
-            case NodeKind::StringLiteral:
-                out.push_back({Op::PushConst,
-                                internConst(Value{unescapeStringLiteral(
-                                    static_cast<const oscad::StringLiteral&>(node).val)}),
-                                0,
-                                nullptr});
+            case NodeKind::StringLiteral: {
+                const auto& lit = static_cast<const oscad::StringLiteral&>(node);
+                int undefinedEscapes = 0;
+                Value v{unescapeStringLiteral(lit.val, &undefinedEscapes)};
+                if (undefinedEscapes) chunk_.undefinedEscapeLiterals.emplace_back(&lit, undefinedEscapes);
+                out.push_back({Op::PushConst, internConst(std::move(v)), 0, nullptr});
                 return;
+            }
             case NodeKind::UndefinedLiteral:
                 out.push_back({Op::PushConst, internConst(Value{}), 0, nullptr});
                 return;
@@ -797,7 +798,7 @@ public:
                 for (size_t i = 0; i < n.assignments.size(); ++i) {
                     const auto& assign = n.assignments[i];
                     const std::string& name = assign->name->name;
-                    if (name.empty() || name[0] == '$') continue;
+                    if (name.empty() || name[0] == '$' || Evaluator::repeatsEarlierLetName(n.assignments, i)) continue;
                     if (auto candidates = collectLetrecCandidateLiterals(*assign->expr)) {
                         letrecSlot[i] = declareLocal(scope, name);
                         letrecCandidates[i] = std::move(*candidates);
@@ -860,7 +861,9 @@ public:
                             }
                         }
                     }
-                    if (!name.empty() && name[0] == '$') {
+                    if (Evaluator::repeatsEarlierLetName(n.assignments, i)) {
+                        out.push_back({Op::WarnDuplicateLet, internName(name), 0, &n.position()});
+                    } else if (!name.empty() && name[0] == '$') {
                         out.push_back({Op::StoreDyn, internName(name), 0, &assign->position()});
                     } else {
                         int slot = selfBinding ? preDeclaredSlot : declareLocal(scope, name);
@@ -910,37 +913,17 @@ public:
             }
 
             case NodeKind::AssertOp: {
+                // Every argument is evaluated, pass or fail, as OpenSCAD
+                // does -- see Evaluator::checkAssert.
                 auto& n = static_cast<const oscad::AssertOp&>(node);
-                if (n.arguments.empty()) {
-                    // Mirrors evalAssertExpr's own `raw.empty() || ...`
-                    // short-circuit exactly: a zero-argument assert() is
-                    // unconditionally true, so the check can never fail --
-                    // skip it entirely rather than compiling a check that
-                    // can never trigger.
-                    compileExpr(*n.body, out, scope, tail);
-                    return;
-                }
-                compileExpr(*argExpr(*n.arguments[0]), out, scope); // condition, never tail
-                size_t jumpPassed = out.size();
-                out.push_back({Op::JumpIfTrue, 0, 0, nullptr});
-                const bool hasMessage = n.arguments.size() > 1;
-                // Lazily compiled: only reachable on the condition-false
-                // path (guarded by the JumpIfTrue above) -- mirrors
-                // evalAssertExpr's own lazy evaluation of the message
-                // argument exactly (only evaluated when the assertion
-                // actually fails). Slot resolution is unaffected by which
-                // runtime path reaches this code -- CompileScope is purely
-                // a compile-time name/index table, same as every other
-                // conditionally-executed branch this compiler already
-                // handles (Ternary, LogicalAnd/Or, ListCompIf).
-                if (hasMessage) compileExpr(*argExpr(*n.arguments[1]), out, scope); // message, never tail
-                // Precomputed ONCE at compile time (cheaper than the
-                // interpreter, which recomputes this on every failing
-                // call) -- toString() is a pure, ctx-free AST-to-text
-                // operation.
-                int condTextIdx = internConst(Value{argExpr(*n.arguments[0])->toString()});
-                out.push_back({Op::AssertFail, hasMessage ? 1 : 0, condTextIdx, &n.position(), &n});
-                out[jumpPassed].a = static_cast<int>(out.size());
+                CompiledChunk::AssertSite site;
+                site.node = &n;
+                site.arguments = &n.arguments;
+                site.argCount = static_cast<int>(n.arguments.size());
+                for (const auto& arg : n.arguments) compileExpr(*argExpr(*arg), out, scope); // never tail
+                int siteIdx = static_cast<int>(chunk_.assertSites.size());
+                chunk_.assertSites.push_back(std::move(site));
+                out.push_back({Op::AssertStatement, siteIdx, 0, &n.position()});
                 compileExpr(*n.body, out, scope, tail);
                 return;
             }
@@ -1202,10 +1185,13 @@ public:
                 size_t placeholderIdx = out.size();
                 out.push_back({Op::OpenLocalScope, 0, 0, nullptr});
                 int slotStart = nextSlot_;
-                for (const auto& assign : n.assignments) {
+                for (size_t i = 0; i < n.assignments.size(); ++i) {
+                    const auto& assign = n.assignments[i];
                     compileExpr(*assign->expr, out, scope);
                     const std::string& name = assign->name->name;
-                    if (!name.empty() && name[0] == '$') {
+                    if (Evaluator::repeatsEarlierLetName(n.assignments, i)) {
+                        out.push_back({Op::WarnDuplicateLet, internName(name), 0, &n.position()});
+                    } else if (!name.empty() && name[0] == '$') {
                         out.push_back({Op::StoreDyn, internName(name), 0, &assign->position()});
                     } else {
                         int slot = declareLocal(scope, name);
@@ -1488,6 +1474,7 @@ public:
         const size_t numDims = n.assignments.size();
         std::function<void(size_t)> emitDim = [&](size_t d) {
             if (d == numDims) {
+                if (d == 0) return; // for() with no loop variables iterates zero times in OpenSCAD, not once.
                 if (!n.body.empty()) {
                     out.push_back({Op::NativeCheckDebugExprLevel, internNativeStatement(n.body.front().get()), 0, nullptr});
                 }
@@ -1612,50 +1599,16 @@ public:
                 return;
             }
             case NodeKind::ModularAssert: {
-                // Genuinely different contract from AssertOp's own compiled
-                // form (Op::AssertFail): the statement form supports named
-                // arguments AND evaluates every argument EAGERLY (mirrors
-                // Evaluator::evalAssertStatement's own resolveArgs() call
-                // exactly -- unlike AssertOp's lazily-compiled message,
-                // guarded by a runtime JumpIfTrue), so every argument is
-                // compiled+pushed here unconditionally, in source order.
+                // Like AssertOp's compiled form, plus chained children.
                 auto& n = static_cast<const oscad::ModularAssert&>(stmt);
                 out.push_back({Op::CheckDebugStatement, internNativeStatement(&stmt), 0, nullptr});
                 CompiledChunk::AssertSite site;
                 site.node = &n;
+                site.statement = &n;
+                site.arguments = &n.arguments;
                 site.argCount = static_cast<int>(n.arguments.size());
                 CompileScope exprScope;
-                for (size_t i = 0; i < n.arguments.size(); ++i) {
-                    compileIsolatedExpr(*argExpr(*n.arguments[i]), out, exprScope);
-                    if (n.arguments[i]->kind() == NodeKind::NamedArgument) {
-                        auto& na = static_cast<const oscad::NamedArgument&>(*n.arguments[i]);
-                        if (na.name->name == "condition") site.conditionArgIndex = static_cast<int>(i);
-                        else if (na.name->name == "message") site.messageArgIndex = static_cast<int>(i);
-                    }
-                }
-                // Second pass: positional 0/1 fill whichever logical
-                // parameter a named arg didn't already claim -- run AFTER
-                // the named pass above (not interleaved) so a named arg
-                // wins regardless of its position relative to its
-                // positional counterpart in source, matching
-                // Evaluator::getArg's own "named first" priority exactly.
-                int posCounter = 0;
-                for (size_t i = 0; i < n.arguments.size(); ++i) {
-                    if (n.arguments[i]->kind() == NodeKind::NamedArgument) continue;
-                    if (posCounter == 0 && !site.conditionArgIndex) site.conditionArgIndex = static_cast<int>(i);
-                    else if (posCounter == 1 && !site.messageArgIndex) site.messageArgIndex = static_cast<int>(i);
-                    ++posCounter;
-                }
-                // Precomputed once, like AssertFail's own condText --
-                // mirrors evalAssertStatement's `node.arguments.empty() ?
-                // "false" : argExpr(*node.arguments[0])->toString()`
-                // exactly (a MISSING condition arg -- e.g. a bare
-                // `assert(message="x");` -- reads the same as an EMPTY
-                // arg list here: no arg supplies "condition" either way).
-                site.condTextConstIdx = internConst(Value{
-                    site.conditionArgIndex
-                        ? argExpr(*n.arguments[static_cast<size_t>(*site.conditionArgIndex)])->toString()
-                        : std::string("false")});
+                for (const auto& arg : n.arguments) compileIsolatedExpr(*argExpr(*arg), out, exprScope);
                 int siteIdx = static_cast<int>(chunk_.assertSites.size());
                 chunk_.assertSites.push_back(std::move(site));
                 out.push_back({Op::AssertStatement, siteIdx, 0, &n.position()});
@@ -1683,10 +1636,14 @@ public:
                 auto& n = static_cast<const oscad::ModularLet&>(stmt);
                 CompileScope exprScope;
                 out.push_back({Op::OpenLetScope, 0, 0, nullptr});
-                for (const auto& assign : n.assignments) {
+                for (size_t i = 0; i < n.assignments.size(); ++i) {
+                    const auto& assign = n.assignments[i];
                     out.push_back({Op::CheckDebugStatement, internNativeStatement(assign.get()), 0, nullptr});
                     compileIsolatedExpr(*assign->expr, out, exprScope);
-                    out.push_back({Op::StoreLetVar, internName(assign->name->name), 0, &assign->position()});
+                    if (Evaluator::repeatsEarlierLetName(n.assignments, i))
+                        out.push_back({Op::WarnDuplicateLet, internName(assign->name->name), 0, &n.position()});
+                    else
+                        out.push_back({Op::StoreLetVar, internName(assign->name->name), 0, &assign->position()});
                 }
                 compileStatementList(n.children, out);
                 out.push_back({Op::CloseExprScope, 0, 0, nullptr});
@@ -1897,6 +1854,7 @@ public:
         const size_t numDims = n.assignments.size();
         std::function<void(size_t)> emitDim = [&](size_t d) {
             if (d == numDims) {
+                if (d == 0) return; // for() with no loop variables iterates zero times in OpenSCAD, not once.
                 const oscad::ASTNode* marker = n.body.empty() ? static_cast<const oscad::ASTNode*>(&n) : n.body.front().get();
                 out.push_back({Op::NativeCheckDebugExprLevel, internNativeStatement(marker), 0, nullptr});
                 compileStatementList(n.body, out);