openscad-cpp-evaluator 0.32.0__tar.gz → 0.32.2__tar.gz

{openscad_cpp_evaluator-0.32.0 → openscad_cpp_evaluator-0.32.2}/PKG-INFO

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

{openscad_cpp_evaluator-0.32.0 → openscad_cpp_evaluator-0.32.2}/pyproject.toml

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

{openscad_cpp_evaluator-0.32.0 → openscad_cpp_evaluator-0.32.2}/src/builtins/function_builtins.cpp

@@ -691,8 +691,29 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
             }
             return Value{false};
         }
-        case BuiltinFnId::Version: return numList({2025.0, 1.0, 1.0});
-        case BuiltinFnId::VersionNum: return Value{20250101.0};
+        // The OpenSCAD release we track. version_num() is that same
+        // year/month/day folded as y * 10000 + m * 100 + d, exactly like the
+        // reference's own builtin_version_num (builtin_functions.cc).
+        case BuiltinFnId::Version: return numList({2026.0, 1.0, 1.0});
+        case BuiltinFnId::VersionNum: {
+            // The optional vector argument the reference also accepts: with
+            // no argument this is our own version() folded; with one, it is
+            // whatever [y, m] / [y, m, d] the caller passed, so
+            // version_num([2019, 5, 0]) == 20190500 regardless of what
+            // release we report. A 2-element vector defaults the day to 0
+            // (getVec3's own defaultval), and anything else -- a non-list, a
+            // wrong length, a non-numeric element -- is undef.
+            //
+            // One deliberate divergence: the reference's size-2 path ignores
+            // getVec2's own failure and folds uninitialized doubles for e.g.
+            // version_num(["a", "b"]). That is undef here rather than
+            // whatever happened to be on the stack.
+            const Value* arg = args.findPositional(0);
+            if (!arg) return Value{20260101.0};
+            const auto v = allNumericList(*arg);
+            if (!v || (v->size() != 2 && v->size() != 3)) return Value{};
+            return Value{(*v)[0] * 10000.0 + (*v)[1] * 100.0 + (v->size() == 3 ? (*v)[2] : 0.0)};
+        }
         case BuiltinFnId::ParentModule:
             return ev.parentModuleName(static_cast<int>(toDoubleLenient(getArg(args, 0, "index", Value{0.0}))));
     }

{openscad_cpp_evaluator-0.32.0 → openscad_cpp_evaluator-0.32.2}/tests/test_bytecode_compiler.cpp

@@ -99,6 +99,35 @@ TEST(BytecodeCompiler, TernaryAndShortCircuitLogicalOps) {
     EXPECT_EQ(runCapturingEcho("function safe(x) = is_undef(x) || x > 0;\necho(safe(undef));"), "ECHO: true");
 }
 
+// TernaryAndShortCircuitLogicalOps above only asserts the RESULT, which an
+// eager compiler computes just as correctly -- so it cannot actually fail if
+// someone drops the JumpIfFalse/JumpIfTrue the compiler emits around the
+// right operand / untaken branch. test_expr_eval.cpp's own
+// RightSideNotEvaluatedWhenShortCircuited and OnlyChosenBranchEvaluates
+// cover that for the AST interpreter only. These two do it for the compiled
+// path, watching for a marker echo() from the side that must never run.
+TEST(BytecodeCompiler, ShortCircuitDoesNotEvaluateRightOperandCompiled) {
+    ScopedVm vm(true);
+    const std::string defs = "function rhs() = echo(\"RHS RAN\") true;\n";
+    // Left operand already decides it -- rhs() must stay unevaluated.
+    EXPECT_EQ(runCapturingEcho(defs + "function f() = true || rhs();\necho(f());"), "ECHO: true");
+    EXPECT_EQ(runCapturingEcho(defs + "function f() = false && rhs();\necho(f());"), "ECHO: false");
+    // ...and the mirror image: it must still run when the left operand doesn't.
+    EXPECT_EQ(runCapturingEcho(defs + "function f() = false || rhs();\necho(f());"),
+              "ECHO: \"RHS RAN\"\nECHO: true");
+    EXPECT_EQ(runCapturingEcho(defs + "function f() = true && rhs();\necho(f());"),
+              "ECHO: \"RHS RAN\"\nECHO: true");
+}
+
+TEST(BytecodeCompiler, TernaryOnlyEvaluatesChosenBranchCompiled) {
+    ScopedVm vm(true);
+    const std::string defs = "function yes() = echo(\"TRUE-BRANCH\") 1;\n"
+                             "function no() = echo(\"FALSE-BRANCH\") 2;\n"
+                             "function pick(c) = c ? yes() : no();\n";
+    EXPECT_EQ(runCapturingEcho(defs + "echo(pick(true));"), "ECHO: \"TRUE-BRANCH\"\nECHO: 1");
+    EXPECT_EQ(runCapturingEcho(defs + "echo(pick(false));"), "ECHO: \"FALSE-BRANCH\"\nECHO: 2");
+}
+
 TEST(BytecodeCompiler, PlainListLiteralCompiles) {
     ScopedVm vm(true);
     EXPECT_EQ(runCapturingEcho("function mk(x) = [x, x * 2, x * 3];\necho(mk(2));"), "ECHO: [2, 4, 6]");

{openscad_cpp_evaluator-0.32.0 → openscad_cpp_evaluator-0.32.2}/tests/test_control_flow.cpp

@@ -279,6 +279,62 @@ TEST(ListComprehension, ForIfElseMapsBothBranches) {
     EXPECT_EQ(std::get<std::string>(items[1]), "odd");
 }
 
+// The two tests above assert only the resulting LIST, which an eager
+// implementation -- one that evaluated an `if` body whose condition failed,
+// or both sides of an `if`/`else` -- would still get right. So they cannot
+// fail if evalListElement's ListCompIf/ListCompIfElse cases (or their
+// compiled counterparts in compileListElement) lose their laziness, the way
+// `&&`/`||` demonstrably once did (see expr_eval.cpp's LogicalAndOp comment).
+// These four watch for a marker echo() from the branch that must never run.
+namespace {
+
+// Every echo() the script emits, newline-joined -- the surrounding tests'
+// own `captured = msg` lambdas keep only the last one, which is no use when
+// the point of the test is exactly how MANY echoes happened.
+std::string echoesFrom(const std::string& code) {
+    std::string captured;
+    runScript(code, [&](const std::string& msg) {
+        if (!captured.empty()) captured += "\n";
+        captured += msg;
+    });
+    return captured;
+}
+
+} // namespace
+
+TEST(ListComprehension, ForIfSkipsBodyWhenConditionFailsInterpreted) {
+    ScopedVm vm(false);
+    EXPECT_EQ(echoesFrom("function mark(i) = echo(str(\"BODY\", i)) i;\n"
+                         "x = [for (i = [0:2]) if (i == 1) mark(i)];"),
+              "ECHO: \"BODY1\"");
+}
+
+TEST(ListComprehension, ForIfSkipsBodyWhenConditionFailsCompiled) {
+    ScopedVm vm(true);
+    EXPECT_EQ(echoesFrom("function mark(i) = echo(str(\"BODY\", i)) i;\n"
+                         "function mk() = [for (i = [0:2]) if (i == 1) mark(i)];\n"
+                         "x = mk();"),
+              "ECHO: \"BODY1\"");
+}
+
+TEST(ListComprehension, ForIfElseEvaluatesOnlyTheChosenBranchInterpreted) {
+    ScopedVm vm(false);
+    // One echo per iteration, not two: i=0 takes `yes`, i=1 takes `no`.
+    EXPECT_EQ(echoesFrom("function yes() = echo(\"TRUE-BRANCH\") 1;\n"
+                         "function no() = echo(\"FALSE-BRANCH\") 2;\n"
+                         "x = [for (i = [0:1]) if (i == 0) yes() else no()];"),
+              "ECHO: \"TRUE-BRANCH\"\nECHO: \"FALSE-BRANCH\"");
+}
+
+TEST(ListComprehension, ForIfElseEvaluatesOnlyTheChosenBranchCompiled) {
+    ScopedVm vm(true);
+    EXPECT_EQ(echoesFrom("function yes() = echo(\"TRUE-BRANCH\") 1;\n"
+                         "function no() = echo(\"FALSE-BRANCH\") 2;\n"
+                         "function mk() = [for (i = [0:1]) if (i == 0) yes() else no()];\n"
+                         "x = mk();"),
+              "ECHO: \"TRUE-BRANCH\"\nECHO: \"FALSE-BRANCH\"");
+}
+
 TEST(ListComprehension, EachFlattensNestedLists) {
     RunResult r = runScript("x = [each [1,2], each [3,4]];");
     auto items = std::get<ListPtr>(varValue(r, "x"))->items;

{openscad_cpp_evaluator-0.32.0 → openscad_cpp_evaluator-0.32.2}/tests/test_function_builtins.cpp

@@ -369,7 +369,28 @@ TEST(StringListBuiltins, FunctionValuedObjectMemberIsCallable) {
 
 TEST(StringListBuiltins, VersionBuiltins) {
     Evaluator ev;
-    EXPECT_DOUBLE_EQ(asNum(evalSrc("version_num()", ev)), 20250101.0);
+    EXPECT_DOUBLE_EQ(asNum(evalSrc("version_num()", ev)), 20260101.0);
+}
+
+// version_num() also takes the optional vector the reference's own
+// builtin_version_num does -- it folds whatever y/m/d it is handed, not just
+// this build's release.
+TEST(StringListBuiltins, VersionNumFoldsAGivenVersionVector) {
+    Evaluator ev;
+    EXPECT_DOUBLE_EQ(asNum(evalSrc("version_num([2019, 5, 0])", ev)), 20190500.0);
+    EXPECT_DOUBLE_EQ(asNum(evalSrc("version_num([2021, 1, 0])", ev)), 20210100.0);
+    // A 2-element vector defaults the day to 0 (getVec3's own defaultval).
+    EXPECT_DOUBLE_EQ(asNum(evalSrc("version_num([2019, 5])", ev)), 20190500.0);
+}
+
+TEST(StringListBuiltins, VersionNumRejectsAnythingButA2Or3NumberVector) {
+    Evaluator ev;
+    EXPECT_TRUE(isUndef(evalSrc("version_num(5)", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("version_num(undef)", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("version_num([2019])", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("version_num([2019, 5, 0, 7])", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("version_num([\"a\", \"b\"])", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("version_num([\"a\", \"b\", \"c\"])", ev)));
 }
 
 TEST(StringListBuiltins, VersionReturnsThreeElementList) {
@@ -377,6 +398,12 @@ TEST(StringListBuiltins, VersionReturnsThreeElementList) {
     Value v = evalSrc("version()", ev);
     const auto& items = asList(v);
     ASSERT_EQ(items.size(), 3u);
+    // Pinned to the same release version_num() reports above -- the reference
+    // derives one from the other (y * 10000 + m * 100 + d, see
+    // builtin_version_num), so the two must not drift apart here either.
+    EXPECT_DOUBLE_EQ(asNum(items[0]), 2026.0);
+    EXPECT_DOUBLE_EQ(asNum(items[1]), 1.0);
+    EXPECT_DOUBLE_EQ(asNum(items[2]), 1.0);
 }
 
 TEST(StringListBuiltins, IsFunctionAndIsObject) {

{openscad_cpp_evaluator-0.32.0 → openscad_cpp_evaluator-0.32.2}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "0.32.0"
+version = "0.32.2"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },