openscad-cpp-evaluator 0.4.5__tar.gz → 0.4.7__tar.gz

{openscad_cpp_evaluator-0.4.5 → openscad_cpp_evaluator-0.4.7}/PKG-INFO

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

{openscad_cpp_evaluator-0.4.5 → openscad_cpp_evaluator-0.4.7}/pyproject.toml

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

{openscad_cpp_evaluator-0.4.5 → openscad_cpp_evaluator-0.4.7}/src/bytecode_compiler.cpp

@@ -675,11 +675,20 @@ public:
                 for (const auto& assign : n.incrs) {
                     compileExpr(*assign->expr, out, scope);
                     auto slot = scope.resolve(assign->name->name);
-                    // incrs always reference an already-declared init name
-                    // (real OpenSCAD grammar guarantees this); resolve()
-                    // returning nullopt would mean a malformed AST, not a
-                    // reachable runtime state.
-                    out.push_back({Op::StoreLocal, *slot, 0, &assign->position()});
+                    // An incr assignment can introduce a brand-new name
+                    // never present in the init list, then have a LATER
+                    // incr expression in the same list read it -- e.g.
+                    // BOSL2's nurbs.scad: `inc_k = ...; kind = inc_k ? ...
+                    // : kind;` (verified against real OpenSCAD and this
+                    // port's own AST interpreter, evalListElement's
+                    // ListCompCFor case in expr_eval.cpp -- both handle it
+                    // correctly). The old assumption here ("incrs always
+                    // reference an already-declared init name") was wrong
+                    // and silently dereferenced a disengaged optional (UB)
+                    // whenever it didn't hold. Declare a fresh slot on
+                    // first appearance, exactly like an init assignment.
+                    int resolvedSlot = slot ? *slot : declareLocal(scope, assign->name->name);
+                    out.push_back({Op::StoreLocal, resolvedSlot, 0, &assign->position()});
                 }
                 out.push_back({Op::Jump, static_cast<int>(loopStart), 0, nullptr});
                 out[jend].a = static_cast<int>(out.size());

{openscad_cpp_evaluator-0.4.5 → openscad_cpp_evaluator-0.4.7}/src/expr_eval.cpp

@@ -103,7 +103,23 @@ Value Evaluator::evalIdentifier(const std::string& name, const oscad::Position*
     if (const Value* v = ctx.let_->find(name)) return *v;
 
     if (!name.empty() && name[0] == '$') {
-        if (const Value* v = ctx.dyn->find(name)) return *v;
+        // $-prefixed names are dynamic variables: a completely separate
+        // namespace from lexically-scoped identifiers, never requiring a
+        // scope declaration (unlike a bare identifier). Found via
+        // BelfrySCAD/BOSL2's constants.scad `get_slop()`
+        // (`is_undef($slop) ? 0 : $slop` with $slop never assigned
+        // anywhere) producing a spurious "Ignoring unknown variable
+        // '$slop'" warning here but not through the bytecode VM's
+        // Op::LoadDyn (bytecode_vm.cpp), which already does exactly
+        // this -- find in ctx.dyn, undef if absent, no scope-lookup
+        // fallback, no warning, ever. Verified against real OpenSCAD.app:
+        // no warning for a never-set $-variable. Must return here
+        // unconditionally rather than falling through to the
+        // scope->lookupVariable() check below, which can never resolve a
+        // $-name anyway (dynamic variables aren't scope-declarable) and
+        // exists only for plain identifiers.
+        const Value* v = ctx.dyn->find(name);
+        return v ? *v : Value{};
     }
 
     if (name == "PI") return Value{std::numbers::pi};

{openscad_cpp_evaluator-0.4.5 → openscad_cpp_evaluator-0.4.7}/tests/test_bytecode_compiler.cpp

@@ -243,6 +243,22 @@ TEST(BytecodeCompiler, CStyleForAccumulates) {
               "ECHO: [0, 0, 1, 3, 6]");
 }
 
+TEST(BytecodeCompiler, CStyleForIncrCanIntroduceAndUseANewNameInTheSamePass) {
+    // Real bug found via BOSL2's nurbs.scad hanging in BelfrySCAD (produced
+    // no geometry there, silently, until traced to this): the compiler
+    // assumed every incr assignment's target name was already declared in
+    // the init list, dereferencing a disengaged scope.resolve() optional
+    // (UB) whenever an incr introduced a brand-new name -- e.g. `k` here,
+    // read by the very next incr in the same list. Verified against real
+    // OpenSCAD and this port's own AST interpreter (both handle it
+    // correctly) before fixing the compiler to match.
+    ScopedVm vm(true);
+    EXPECT_EQ(runCapturingEcho(
+                  "function f() = [for (a = 0, i = 0; i < 5; k = i >= 2, a = k ? a + 10 : a + 1, i = i + 1) a];\n"
+                  "echo(f());"),
+              "ECHO: [0, 1, 2, 12, 22]");
+}
+
 TEST(BytecodeCompiler, CStyleForExceedingMaxIterationsThrows) {
     ScopedVm vm(true);
     EXPECT_THROW(runCapturingEcho("function f() = [for (a = 0; true; a = a + 1) a];\necho(f());"), EvalError);

{openscad_cpp_evaluator-0.4.5 → openscad_cpp_evaluator-0.4.7}/tests/test_expr_eval.cpp

@@ -52,6 +52,23 @@ TEST(ExprEvalIdentifiers, UnknownVariableWarnsAndIsUndef) {
     EXPECT_NE(lastWarning.find("Ignoring unknown variable 'nope'"), std::string::npos);
 }
 
+TEST(ExprEvalIdentifiers, UndefinedDollarVariableIsUndefWithNoWarning) {
+    // Found via BOSL2's constants.scad: `function get_slop() = is_undef($slop)
+    // ? 0 : $slop;` with $slop never assigned anywhere in the script. Real
+    // OpenSCAD.app produces no warning at all -- $-prefixed names are a
+    // separate, always-implicitly-available namespace, never requiring a
+    // scope declaration the way a bare identifier does. This port's
+    // bytecode VM (Op::LoadDyn, bytecode_vm.cpp) already got this right by
+    // construction; the plain interpreter incorrectly fell through to the
+    // same "Ignoring unknown variable" path a genuinely undeclared bare
+    // identifier hits.
+    std::string lastWarning;
+    Evaluator ev([&](const std::string& msg) { lastWarning = msg; });
+    Value v = evalSrc("$slop", ev);
+    EXPECT_TRUE(std::holds_alternative<std::monostate>(v));
+    EXPECT_TRUE(lastWarning.empty());
+}
+
 TEST(ExprEvalIdentifiers, ResolvesViaScopeFallbackWhenNotEagerlyBound) {
     // "a" is a real top-level declaration but evalChildren() was never run,
     // so ctx.let_ has no eager binding for it -- this exercises