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

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

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

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

@@ -505,7 +505,7 @@ enum class Op {
     // anything compileStatementList doesn't give its own real bytecode.
     // (Assignment/ModularEcho/ModularAssert/ModularLet used to fall here
     // too; they now have their own real bytecode -- Op::StoreModuleVar/
-    // Op::Echo/Op::AssertStatement/Op::OpenLetScope+StoreLetVar -- purely
+    // Op::Echo/Op::AssertPass+AssertFail/Op::OpenLetScope+StoreLetVar -- purely
     // a throughput change, since none of these were ever the recursion-
     // depth risk this compiler targets. `#`/`%`/`!` modifiers and
     // translate/rotate/scale/mirror/multmatrix/resize/color used to fall
@@ -634,14 +634,9 @@ enum class Op {
     // the position recorded into dynPositions).
     StoreModuleVar,
 
-    // ModularEcho/ModularAssert's own statement form share Op::Echo/a
-    // dedicated AssertStatement op (below) for the "pop N already-compiled
-    // argument values" mechanics -- see those ops' own doc comments
-    // (Op::Echo, above; Op::AssertStatement, below) for why the
-    // EXPRESSION-form opcodes are directly reusable (statement-shaped
-    // already: no value pushed, straight fall-through) while assert's
-    // needs its own op (named-argument support + eager-not-lazy message
-    // evaluation, both genuinely different from AssertOp's own contract).
+    // ModularEcho/ModularAssert's own statement form share Op::Echo and
+    // Op::AssertPass/AssertFail (below) with the expression forms: both are
+    // statement-shaped already (no value pushed, straight fall-through).
 
     // Isolates ONE inline-compiled sub-expression's own `$`-writes from the
     // rest of this chunk's shared, long-lived ctx -- pushes ctx.
@@ -697,12 +692,15 @@ enum class Op {
     // the handler itself, kept for consistency/future debugging only).
     StoreLetVar,
 
-    // a = index into CompiledChunk::assertSites. Pops site.argCount values
-    // (every argument of an assert() statement or expression, pushed in
-    // source order) and hands them to Evaluator::checkAssert; a statement
-    // then runs any chained children natively (rare; not worth its own
-    // compiled path).
-    AssertStatement,
+    // assert(): the condition is compiled first, then JumpIfFalse to the
+    // failure path; the passing path never evaluates any other argument
+    // (see Evaluator::evalAssert). a = index into CompiledChunk::assertSites.
+    // AssertPass prints the site's unexpected-argument warnings and runs a
+    // statement's chained children; it is emitted only when the site has
+    // either. AssertFail pops every non-condition argument (source order)
+    // and throws via Evaluator::failAssert.
+    AssertPass,
+    AssertFail,
     // a = nativeStatements index of the AST node whose arm this is. Emitted
     // only when the Evaluator was built with coverage on (compile-time
     // flag, and chunks are per-Evaluator): Evaluator::coverHit(node), nothing
@@ -711,6 +709,17 @@ enum class Op {
     Cover,
 };
 
+// Which of an assert() call's arguments are its condition and message, and
+// whether the call has any unexpected argument to warn about -- all fixed by
+// the call's shape, so worked out once per call site (assertLayout,
+// stmt_eval.cpp). -1 = not given.
+struct AssertLayout {
+    int cond = -1;
+    int msg = -1;
+    bool warns = false;
+};
+AssertLayout assertLayout(const std::vector<std::unique_ptr<oscad::Argument>>& arguments);
+
 struct Instruction {
     Op op;
     int a = 0;
@@ -1014,10 +1023,10 @@ struct CompiledChunk {
         const oscad::ASTNode* node = nullptr;
     };
 
-    // One Op::AssertStatement site. `statement` is null for the expression
-    // form, which has no children.
+    // One Op::AssertPass/AssertFail site. `statement` is null for the
+    // expression form, which has no children.
     struct AssertSite {
-        int argCount = 0;
+        AssertLayout layout;
         const std::vector<std::unique_ptr<oscad::Argument>>* arguments = nullptr;
         const oscad::ASTNode* node = nullptr;
         const oscad::ModularAssert* statement = nullptr;

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

@@ -565,13 +565,20 @@ public:
     void warnUndefinedEscapes(const oscad::StringLiteral& lit, int count);
     // let() keeps the FIRST binding of a repeated name: OpenSCAD evaluates
     // the later right-hand side, warns with its value, and discards it.
-    // OpenSCAD's Assert::performAssert, given every argument's value in
-    // source order -- it evaluates them all, pass or fail, so a passing
-    // `assert(true, nosuch)` still warns. Warns about unexpected arguments;
-    // throws via error() when the condition is false or missing (`assert()`
-    // fails). The message prints as echo() would print it.
-    void checkAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const std::vector<Value>& values,
-                     const oscad::ASTNode& node);
+    // assert(), interpreted: the condition first, and only on failure the
+    // message and any other argument -- see the definition (stmt_eval.cpp)
+    // for why this deliberately diverges from OpenSCAD. `maybeCompiled`
+    // picks evalExprMaybeCompiled (statement form) over evalExpr.
+    void evalAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const oscad::ASTNode& node,
+                    EvalContext& ctx, bool maybeCompiled);
+    // The unexpected-argument warnings, which a passing assert still prints.
+    void warnAssertArgs(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const AssertLayout& layout);
+    // A failed (or condition-less) assert, once every non-condition argument
+    // has been evaluated: warns about unexpected arguments, then throws via
+    // error(). `message` is null when none was given; it prints as echo()
+    // would print it.
+    [[noreturn]] void failAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
+                                 const AssertLayout& layout, const Value* message, const oscad::ASTNode& node);
     void warnDuplicateLet(const std::string& name, const Value& v, const oscad::Position* position);
     template <typename Assignments>
     static bool repeatsEarlierLetName(const Assignments& assignments, size_t i) {

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

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

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

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

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.0}/src/bytecode_compiler.cpp

@@ -913,17 +913,10 @@ public:
             }
 
             case NodeKind::AssertOp: {
-                // Every argument is evaluated, pass or fail, as OpenSCAD
-                // does -- see Evaluator::checkAssert.
+                // Only the condition unless it fails -- see Evaluator::evalAssert.
                 auto& n = static_cast<const oscad::AssertOp&>(node);
-                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()});
+                compileAssert(n.arguments, n, nullptr, out,
+                              [&](const oscad::Expression& e) { compileExpr(e, out, scope); }); // never tail
                 compileExpr(*n.body, out, scope, tail);
                 return;
             }
@@ -1313,6 +1306,40 @@ public:
         out.push_back({Op::CloseExprScope, 0, 0, nullptr});
     }
 
+    // assert(), either form, mirroring Evaluator::evalAssert:
+    //     <condition> JumpIfFalse fail [AssertPass] Jump end
+    //   fail: <every other argument, source order> AssertFail
+    //   end:
+    // AssertPass only when there is something for it to do; with no
+    // condition at all, straight to the failure path.
+    template <typename CompileArg>
+    void compileAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const oscad::ASTNode& node,
+                       const oscad::ModularAssert* statement, std::vector<Instruction>& out, CompileArg compileArg) {
+        CompiledChunk::AssertSite site;
+        site.layout = assertLayout(arguments);
+        site.node = &node;
+        site.statement = statement;
+        site.arguments = &arguments;
+        const int siteIdx = static_cast<int>(chunk_.assertSites.size());
+        chunk_.assertSites.push_back(site);
+        const int cond = site.layout.cond;
+        std::optional<size_t> jumpEnd;
+        if (cond >= 0) {
+            compileArg(*argExpr(*arguments[static_cast<size_t>(cond)]));
+            const size_t jumpFail = out.size();
+            out.push_back({Op::JumpIfFalse, 0, 0, nullptr});
+            if (site.layout.warns || (statement && !statement->children.empty()))
+                out.push_back({Op::AssertPass, siteIdx, 0, &node.position()});
+            jumpEnd = out.size();
+            out.push_back({Op::Jump, 0, 0, nullptr});
+            out[jumpFail].a = static_cast<int>(out.size());
+        }
+        for (size_t i = 0; i < arguments.size(); ++i)
+            if (static_cast<int>(i) != cond) compileArg(*argExpr(*arguments[i]));
+        out.push_back({Op::AssertFail, siteIdx, 0, &node.position()});
+        if (jumpEnd) out[*jumpEnd].a = static_cast<int>(out.size());
+    }
+
     // 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
@@ -1544,7 +1571,7 @@ public:
                 return;
             // Assignment/ModularEcho/ModularAssert: real bytecode instead
             // of Op::NativeStatement -- a throughput improvement (see
-            // CheckDebugStatement/StoreModuleVar/AssertStatement's own doc
+            // CheckDebugStatement/StoreModuleVar/AssertPass+AssertFail's own doc
             // comments, bytecode.hpp), NOT a recursion-safety one (these
             // were never the risk Stage 2 targeted -- see NativeStatement's
             // own doc comment). Assignment specifically closes a real
@@ -1602,16 +1629,9 @@ public:
                 // 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 (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()});
+                compileAssert(n.arguments, n, &n, out,
+                              [&](const oscad::Expression& e) { compileIsolatedExpr(e, out, exprScope); });
                 return;
             }
             case NodeKind::ModularLet: {

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.0}/src/bytecode_vm.cpp

@@ -1105,7 +1105,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     ev.emitEcho(pairs);
                     // The STATEMENT form can carry children and the
                     // reference renders them; same tail as
-                    // Op::AssertStatement below. Null node = the expression
+                    // Op::AssertPass below. Null node = the expression
                     // form (`echo(...) 1+1`), which has none.
                     if (site.node && !site.node->children.empty())
                         ev.evalChildren(site.node->children, ctx);
@@ -1567,14 +1567,9 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     ++f.pc;
                     break;
                 }
-                case Op::AssertStatement: {
+                case Op::AssertPass: {
                     const CompiledChunk::AssertSite& site = f.chunk->assertSites[static_cast<size_t>(ins.a)];
-                    std::vector<Value> args(static_cast<size_t>(site.argCount));
-                    for (int i = site.argCount - 1; i >= 0; --i) {
-                        args[static_cast<size_t>(i)] = std::move(f.stack.back());
-                        f.stack.pop_back();
-                    }
-                    ev.checkAssert(*site.arguments, args, *site.node);
+                    ev.warnAssertArgs(*site.arguments, site.layout);
                     // Rare (assert(...) translate(...) children();-shaped) --
                     // not worth its own compiled path; evalChildren already
                     // tries ITS OWN compiled fast path internally regardless.
@@ -1583,6 +1578,19 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     ++f.pc;
                     break;
                 }
+                case Op::AssertFail: {
+                    // Every argument but the condition is on the stack, in
+                    // source order; only the message's value is wanted.
+                    const CompiledChunk::AssertSite& site = f.chunk->assertSites[static_cast<size_t>(ins.a)];
+                    const AssertLayout& layout = site.layout;
+                    Value message;
+                    for (int i = static_cast<int>(site.arguments->size()) - 1; i >= 0; --i) {
+                        if (i == layout.cond) continue;
+                        if (i == layout.msg) message = std::move(f.stack.back());
+                        f.stack.pop_back();
+                    }
+                    ev.failAssert(*site.arguments, layout, layout.msg >= 0 ? &message : nullptr, *site.node);
+                }
                 case Op::NativeCondJumpIfFalse: {
                     const oscad::Expression* cond = f.chunk->nativeExprs[static_cast<size_t>(ins.a)];
                     const bool truthyVal = truthy(ev.evalExprMaybeCompiled(*cond, ctx));

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.0}/src/expr_eval.cpp

@@ -492,9 +492,7 @@ Value Evaluator::evalProfileTimeExpr(const oscad::ProfileTimeOp& node, EvalConte
 
 Value Evaluator::evalAssertExpr(const oscad::AssertOp& node, EvalContext& ctx) {
     checkDebug(node, ctx); // _expr_assert, before the condition is evaluated
-    std::vector<Value> values;
-    for (const auto& arg : node.arguments) values.push_back(evalExpr(*argExpr(*arg), ctx));
-    checkAssert(node.arguments, values, node);
+    evalAssert(node.arguments, node, ctx, /*maybeCompiled=*/false);
     return evalExpr(*node.body, ctx);
 }
 

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.0}/src/stmt_eval.cpp

@@ -74,41 +74,79 @@ void Evaluator::doEcho(const std::vector<std::unique_ptr<oscad::Argument>>& argu
     emitEcho(pairs);
 }
 
-void Evaluator::checkAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
-                            const std::vector<Value>& values, const oscad::ASTNode& node) {
-    static const std::vector<std::string> kParams{"condition", "message"};
-    warnUnexpectedArgs(*this, kParams, arguments);
+namespace {
+const std::vector<std::string> kAssertParams{"condition", "message"};
+}
+
+AssertLayout assertLayout(const std::vector<std::unique_ptr<oscad::Argument>>& arguments) {
     // A named argument wins; positional 0/1 fill whichever is left.
-    std::optional<size_t> cond, msg;
+    AssertLayout layout;
     for (size_t i = 0; i < arguments.size(); ++i) {
         if (arguments[i]->kind() != oscad::NodeKind::NamedArgument) continue;
         const std::string& name = static_cast<const oscad::NamedArgument&>(*arguments[i]).name->name;
-        if (name == "condition" && !cond) cond = i;
-        else if (name == "message" && !msg) msg = i;
+        if (name == "condition" && layout.cond < 0) layout.cond = static_cast<int>(i);
+        else if (name == "message" && layout.msg < 0) layout.msg = static_cast<int>(i);
+        else if (name != "condition" && name != "message" && !isConfigVariable(name)) layout.warns = true;
     }
-    size_t positional = 0;
+    int positional = 0;
     for (size_t i = 0; i < arguments.size(); ++i) {
         if (arguments[i]->kind() == oscad::NodeKind::NamedArgument) continue;
-        if (positional == 0 && !cond) cond = i;
-        else if (positional == 1 && !msg) msg = i;
-        ++positional;
+        if (positional == 0 && layout.cond < 0) layout.cond = static_cast<int>(i);
+        else if (positional == 1 && layout.msg < 0) layout.msg = static_cast<int>(i);
+        if (++positional > static_cast<int>(kAssertParams.size())) layout.warns = true;
     }
-    if (cond && truthy(values[*cond])) return;
+    return layout;
+}
+
+void Evaluator::warnAssertArgs(const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
+                               const AssertLayout& layout) {
+    if (layout.warns) warnUnexpectedArgs(*this, kAssertParams, arguments);
+}
+
+void Evaluator::failAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments,
+                           const AssertLayout& layout, const Value* message, const oscad::ASTNode& node) {
+    warnAssertArgs(arguments, layout);
     std::string err = "Assertion";
-    if (cond) err += " '" + formatExpression(*argExpr(*arguments[*cond])) + "'";
+    if (layout.cond >= 0) err += " '" + formatExpression(*argExpr(*arguments[static_cast<size_t>(layout.cond)])) + "'";
     err += " failed";
-    if (msg) err += ": " + fmtValue(values[*msg]);
+    if (message) err += ": " + fmtValue(*message);
     error(err, node, "assert");
 }
 
+// DELIBERATE DIVERGENCE FROM OPENSCAD: a passing assert() evaluates its
+// condition and nothing else, the way `||` skips its right operand.
+// OpenSCAD's Assert::performAssert evaluates every argument first, so there
+// a passing `assert(true, echo("e") "m")` echoes, `assert(true, nosuch)`
+// warns, and a message calling a user function runs it; here none of them
+// does. BOSL2 validates nearly every call with `assert(cond, str(...))`,
+// and building those never-shown messages was ~4% of its evaluation time.
+// A failing (or condition-less) assert evaluates every other argument, in
+// source order, after the condition, so its output is unchanged; the
+// unexpected-argument warnings depend only on the call's shape and still
+// print on every call. The compiled form (Op::AssertPass/AssertFail) does
+// the same.
+void Evaluator::evalAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const oscad::ASTNode& node,
+                           EvalContext& ctx, bool maybeCompiled) {
+    const AssertLayout layout = assertLayout(arguments);
+    auto eval = [&](size_t i) {
+        const oscad::Expression& e = *argExpr(*arguments[i]);
+        return maybeCompiled ? evalExprMaybeCompiled(e, ctx) : evalExpr(e, ctx);
+    };
+    if (layout.cond >= 0 && truthy(eval(static_cast<size_t>(layout.cond)))) {
+        warnAssertArgs(arguments, layout);
+        return;
+    }
+    Value message;
+    for (size_t i = 0; i < arguments.size(); ++i) {
+        if (static_cast<int>(i) == layout.cond) continue;
+        Value v = eval(i);
+        if (static_cast<int>(i) == layout.msg) message = std::move(v);
+    }
+    failAssert(arguments, layout, layout.msg >= 0 ? &message : nullptr, node);
+}
+
 void Evaluator::evalAssertStatement(const oscad::ModularAssert& node, EvalContext& ctx) {
-    // The statement form supports named arguments (assert(condition=...,
-    // message=...)), unlike the expression form's raw positional indexing
-    // -- see evalAssertExpr. Mirrors _eval_statement_impl's ModularAssert
-    // branch exactly.
-    std::vector<Value> values;
-    for (const auto& arg : node.arguments) values.push_back(evalExprMaybeCompiled(*argExpr(*arg), ctx));
-    checkAssert(node.arguments, values, node);
+    evalAssert(node.arguments, node, ctx, /*maybeCompiled=*/true);
     // Assertion passed -- propagate any chained child geometry (e.g.
     // `assert(...) translate(...) children();`).
     if (!node.children.empty()) evalChildren(node.children, ctx);

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.0}/src/user_calls.cpp

@@ -532,9 +532,7 @@ std::variant<Value, Evaluator::TailStep, Evaluator::NotTailStep> Evaluator::simp
             // Mirrors evalAssertExpr.
             auto& n = static_cast<const oscad::AssertOp&>(node);
             checkDebug(n, ctx);
-            std::vector<Value> values;
-            for (const auto& arg : n.arguments) values.push_back(evalExpr(*argExpr(*arg), ctx));
-            checkAssert(n.arguments, values, n);
+            evalAssert(n.arguments, n, ctx, /*maybeCompiled=*/false);
             TailStep step;
             step.nextExpr = n.body.get();
             step.ctx = ctx;

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.0}/src/value.cpp

@@ -4,6 +4,7 @@
 #include "openscad_cpp_evaluator/utf8.hpp"
 
 #include <algorithm>
+#include <charconv>
 #include <cmath>
 #include <cstdio>
 #include <cstdlib>
@@ -486,29 +487,59 @@ std::string unescapeStringLiteral(const std::string& raw, int* undefinedEscapes)
 }
 
 namespace {
-// The first 6 significant digits of |v|, correctly rounded with exact ties
-// rounding UP (double-conversion's ToPrecision, which OpenSCAD prints
-// with), and the power of ten of the first one. A 17-digit rendering
-// decides every case but one: when it reads exactly ...5000000000 past the
-// sixth digit, the true value may sit just either side of the tie, so the
-// exact expansion settles it.
-void sixDigits(double av, char digits[6], int& exp10) {
+// The first 7 significant digits of |v| (all[0..6]) and the power of ten of
+// the first one, plus whether the first 6 round UP: correctly rounded with
+// exact ties rounding up (double-conversion's ToPrecision, which OpenSCAD
+// prints with). A 17-digit rendering decides every case but one: when it
+// reads exactly ...5000000000 past the sixth digit, the true value may sit
+// just either side of the tie, so the exact expansion settles it.
+bool exactSevenDigits(double av, char all[17], int& exp10) {
     char buf[32];
     std::snprintf(buf, sizeof buf, "%.16e", av);  // d.dddddddddddddddde[+-]x
     exp10 = std::atoi(std::strchr(buf, 'e') + 1);
-    char all[17];
     all[0] = buf[0];
     std::memcpy(all + 1, buf + 2, 16);
-    bool up;
     if (all[6] == '5' && std::memcmp(all + 7, "0000000000", 10) == 0) {
         static thread_local char exact[1100];
         std::snprintf(exact, sizeof exact, "%.1000e", av);  // the exact expansion
         // exact[7] is the 7th significant digit ("d.dddddd..."); 5 or more
         // rounds up, an exact tie included.
-        up = exact[7] >= '5';
-    } else {
-        up = all[6] >= '5';
+        return exact[7] >= '5';
     }
+    return all[6] >= '5';
+}
+
+// The same answer from the SHORTEST round-trip rendering D (std::to_chars,
+// several times cheaper than printf), which is safe for a normal double:
+// its rounding interval is ~1e-16 relative, far narrower than the 1e-6
+// spacing of 7-digit decimals, so at most one 7-digit decimal lies in it.
+// If the rounding boundary B (a 7-digit ...5) is in the interval, D is B
+// itself; otherwise D and |v| lie on the same side of B and round alike.
+// So D decides every case except D == B exactly, where |v| may be just
+// either side of the tie -- returns false then, for exactSevenDigits. A
+// subnormal's interval is far wider (5e-324 renders shortest as "5e-324"
+// but prints as 4.94066e-324), so subnormals never come here.
+bool shortestSevenDigits(double av, char all[17], int& exp10, bool& up) {
+    char buf[32];
+    const std::to_chars_result res = std::to_chars(buf, buf + sizeof buf, av, std::chars_format::scientific);
+    int n = 0;
+    const char* p = buf;
+    for (; *p != 'e'; ++p)
+        if (*p != '.') all[n++] = *p;
+    if (n == 7 && all[6] == '5') return false;
+    for (; n < 7; ++n) all[n] = '0';
+    std::from_chars(p + (p[1] == '+' ? 2 : 1), res.ptr, exp10);
+    up = all[6] >= '5';
+    return true;
+}
+
+// The first 6 significant digits of |v|, rounded as above, and the power
+// of ten of the first one.
+void sixDigits(double av, char digits[6], int& exp10) {
+    char all[17];
+    bool up;
+    if (av < std::numeric_limits<double>::min() || !shortestSevenDigits(av, all, exp10, up))
+        up = exactSevenDigits(av, all, exp10);
     std::memcpy(digits, all, 6);
     if (up) {
         int k = 5;

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.0}/tests/test_bytecode_compiler.cpp

@@ -1867,17 +1867,91 @@ TEST(ModuleBodyCompiles, EchoStatementCompilesWithNamedAndPositionalArgs) {
     EXPECT_EQ(runCapturingEcho("echo(1, b=2, 3);"), "ECHO: 1, b = 2, 3");
 }
 
-TEST(ModuleBodyCompiles, AssertStatementCompilesWithNamedArgsMessageAndEagerSideEffects) {
+TEST(ModuleBodyCompiles, AssertStatementCompilesWithNamedArgsInReverseOrder) {
     ScopedVm vm(true);
     // Named args in reverse order (message before condition), PLUS a 3rd,
-    // logically-unused positional argument -- must still be evaluated
-    // eagerly for its own side effect (mirrors evalAssertStatement's own
-    // resolveArgs() call, unlike AssertOp's lazy message).
+    // logically-unused positional argument: the condition is found, the
+    // pass skips every other argument (see Evaluator::evalAssert), and the
+    // extra positional argument still warns.
     std::string captured =
-        runCapturingEcho("assert(message=\"unused, condition true\", condition=true, echo(\"side effect\"));\n"
+        runCapturingEcho("assert(message=\"unused, condition true\", condition=true, echo(\"side effect\") 1);\n"
                           "echo(\"reached\");\n");
-    EXPECT_NE(captured.find("ECHO: \"side effect\""), std::string::npos);
-    EXPECT_NE(captured.find("ECHO: \"reached\""), std::string::npos);
+    EXPECT_EQ(captured.find("ECHO: \"side effect\""), std::string::npos) << captured;
+    EXPECT_NE(captured.find("ECHO: \"reached\""), std::string::npos) << captured;
+}
+
+// A passing assert() evaluates only its condition -- a deliberate
+// divergence from OpenSCAD, which evaluates the message too (see
+// Evaluator::evalAssert). Each script runs interpreted and compiled, in
+// both the statement and the expression form.
+namespace {
+struct AssertRun {
+    std::string log;
+    std::string error;
+};
+AssertRun runAssert(const std::string& code, bool vm) {
+    ScopedVm scoped(vm);
+    AssertRun r;
+    Evaluator ev([&](const std::string& msg) { r.log += (r.log.empty() ? "" : "\n") + msg; });
+    auto ast = parseSrc(code);
+    auto scope = oscad::buildScopes(ast);
+    EvalContext ctx = EvalContext::makeRoot(scope.get());
+    try {
+        ev.resolveTree(ast, ctx);
+    } catch (const EvalError& e) {
+        r.error = e.what();
+    }
+    return r;
+}
+const char* const kAssertPrelude = "function noisy() = echo(\"called\") \"m\";\n";
+} // namespace
+
+TEST(AssertShortCircuit, PassingAssertSkipsTheMessage) {
+    for (bool vm : {false, true}) {
+        for (const std::string msg : {"echo(\"e\") \"m\"", "nosuch", "noisy()", "undef + 1"}) {
+            for (const std::string code : {"assert(true, " + msg + ");",
+                                           "function f(x) = assert(x, " + msg + ") 1; y = f(true);",
+                                           "x = assert(true, " + msg + ") 2;"}) {
+                const AssertRun r = runAssert(kAssertPrelude + code, vm);
+                EXPECT_EQ(r.log, "") << "vm=" << vm << ": " << code;
+                EXPECT_EQ(r.error, "") << "vm=" << vm << ": " << code;
+            }
+        }
+    }
+}
+
+TEST(AssertShortCircuit, FailingAssertStillEvaluatesTheMessage) {
+    for (bool vm : {false, true}) {
+        for (const std::string code : {"assert(false, noisy());", "function f(x) = assert(x, noisy()) 1; y = f(false);",
+                                       "x = assert(false, noisy()) 2;"}) {
+            const AssertRun r = runAssert(kAssertPrelude + code, vm);
+            EXPECT_EQ(r.log, "ECHO: \"called\"") << "vm=" << vm << ": " << code;
+            EXPECT_NE(r.error.find("failed: \"m\""), std::string::npos) << "vm=" << vm << ": " << r.error;
+        }
+        const AssertRun w = runAssert("assert(0, nosuch);", vm);
+        EXPECT_NE(w.log.find("Ignoring unknown variable \"nosuch\""), std::string::npos) << "vm=" << vm << ": " << w.log;
+        EXPECT_NE(w.error.find("Assertion '0' failed: undef"), std::string::npos) << "vm=" << vm << ": " << w.error;
+        // Message given before the condition: the condition is still
+        // evaluated first.
+        const AssertRun o = runAssert("assert(message=echo(\"msg\") \"m\", condition=echo(\"cond\") false);", vm);
+        EXPECT_EQ(o.log, "ECHO: \"cond\"\nECHO: \"msg\"") << "vm=" << vm;
+        EXPECT_NE(o.error.find("failed: \"m\""), std::string::npos) << "vm=" << vm << ": " << o.error;
+    }
+}
+
+TEST(AssertShortCircuit, PassingAssertStillWarnsAboutUnexpectedArguments) {
+    for (bool vm : {false, true}) {
+        for (const std::string code : {"assert(true, \"m\", 3);", "function f(x) = assert(x, \"m\", 3) 1; y = f(true);",
+                                       "assert(true, bogus=1);", "x = assert(true, bogus=1) 2;"}) {
+            const AssertRun r = runAssert(code, vm);
+            EXPECT_TRUE(r.log.find("Too many unnamed arguments supplied") != std::string::npos ||
+                        r.log.find("variable bogus not specified as parameter") != std::string::npos)
+                << "vm=" << vm << ": " << code << " -> " << r.log;
+            EXPECT_EQ(r.error, "") << "vm=" << vm << ": " << code;
+        }
+        // `assert(...) children` still runs the children once passed.
+        EXPECT_EQ(runAssert("assert(true, nosuch) echo(\"child\");", vm).log, "ECHO: \"child\"") << "vm=" << vm;
+    }
 }
 
 TEST(ModuleBodyCompiles, AssertStatementCompiledFormFailsWithNamedMessage) {

{openscad_cpp_evaluator-1.44.0 → openscad_cpp_evaluator-1.45.0}/tests/test_openscad_parity.cpp

@@ -446,8 +446,10 @@ std::string assertError(const std::string& src) {
 }
 }  // namespace
 
-// assert() passed; a message was always quoted; an undef message vanished;
-// the message was only evaluated on failure.
+// assert() passed; a message was always quoted; an undef message vanished.
+// The message is only evaluated on failure -- which OpenSCAD does NOT do: it
+// evaluates every argument, pass or fail. That divergence is deliberate (see
+// Evaluator::evalAssert).
 TEST(Parity, AssertFollowsUpstream) {
     EXPECT_NE(assertError("assert();").find("Assertion failed"), std::string::npos);
     EXPECT_NE(assertError("function f() = assert() 1; x = f();").find("Assertion failed"), std::string::npos);
@@ -455,7 +457,7 @@ TEST(Parity, AssertFollowsUpstream) {
     EXPECT_NE(assertError("x = assert(false, \"m\") 1;").find("Assertion 'false' failed: \"m\""), std::string::npos);
     EXPECT_NE(assertError("assert(undef, undef);").find("failed: undef"), std::string::npos);
     EXPECT_NE(assertError("assert(message=\"m\");").find("Assertion failed: \"m\""), std::string::npos);
-    EXPECT_TRUE(logged(run("x = assert(true, echo(\"eager\") 1) 2;"), "ECHO: \"eager\""));
+    EXPECT_FALSE(logged(run("x = assert(true, echo(\"lazy\") 1) 2;"), "ECHO: \"lazy\""));
     EXPECT_TRUE(logged(run("assert(1, 2, 3);"), "Too many unnamed arguments supplied"));
 }