openscad-cpp-evaluator 0.44.0__tar.gz → 0.45.0__tar.gz

{openscad_cpp_evaluator-0.44.0 → openscad_cpp_evaluator-0.45.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.44.0 → openscad_cpp_evaluator-0.45.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.44.0 → openscad_cpp_evaluator-0.45.0}/src/builtins/function_builtins.cpp

@@ -610,6 +610,8 @@ enum class BuiltinFnId {
 // Guarding on supported_feature() is how a script says so out loud.
 const std::unordered_map<std::string, double>& featureLevels() {
     static const std::unordered_map<std::string, double> levels = {
+        {"render-expr", 1.0},        // render() in expression position
+        {"polyhedron-vnf", 1.0},     // polyhedron(vnf) / polyhedron(object)
         {"separate-children", 1.0},  // children(..., separate=true)
         {"minkowski-diff", 1.0},     // minkowski_difference()
         {"sphere-styles", 1.0},      // sphere(style=)

{openscad_cpp_evaluator-0.44.0 → openscad_cpp_evaluator-0.45.0}/src/bytecode_compiler.cpp

@@ -262,7 +262,10 @@ public:
     void compileIdentifierLoad(const std::string& name, const oscad::Position& pos, std::vector<Instruction>& out,
                                 CompileScope& scope, bool warnIfUndef) {
         if (!name.empty() && name[0] == '$') {
-            out.push_back({Op::LoadDyn, internName(name), 0, &pos});
+            // `b` is the warn flag -- a $-name reached through the
+            // is_undef() probe must stay quiet, same as LoadFreeNoWarn does
+            // for a plain one.
+            out.push_back({Op::LoadDyn, internName(name), warnIfUndef ? 1 : 0, &pos});
         } else if (auto slot = scope.resolve(name)) {
             out.push_back({Op::LoadLocal, *slot, 0, &pos});
         } else if (auto upvalSlot = resolveEnclosing(name)) {

{openscad_cpp_evaluator-0.44.0 → openscad_cpp_evaluator-0.45.0}/src/bytecode_vm.cpp

@@ -562,6 +562,8 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     } else if (const Value* v = ctx.dyn->find(name)) {
                         f.stack.push_back(*v);
                     } else {
+                        // ins.b = warn flag; see compileIdentifierLoad.
+                        if (ins.b) ev.warn("Ignoring unknown variable '" + name + "'", ins.pos);
                         f.stack.push_back(Value{});
                     }
                     ++f.pc;

{openscad_cpp_evaluator-0.44.0 → openscad_cpp_evaluator-0.45.0}/src/expr_eval.cpp

@@ -138,7 +138,19 @@ Value Evaluator::evalIdentifier(const std::string& name, const oscad::Position*
         // $-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 (v) return *v;
+        // Warns like any other unknown name. This used to return silently
+        // for EVERY $-read, on the strength of BOSL2's get_slop() --
+        // `is_undef($slop) ? 0 : $slop` with $slop never assigned -- being
+        // silent in the reference. It is, but for two narrower reasons: the
+        // probe does not warn about its own argument (undefProbeTarget), and
+        // the else branch never runs when is_undef() is true. A plain
+        // `echo($nope)` DOES warn there, in every context checked --
+        // assignment, function body, module body, comparison. Real BOSL2
+        // (gears, threading, rounded_prism, diff/attach, path_sweep) emits
+        // none of these, because it guards its own $-reads.
+        if (warnIfUndef) warn("Ignoring unknown variable '" + name + "'", position);
+        return Value{};
     }
 
     if (name == "PI") return Value{std::numbers::pi};

{openscad_cpp_evaluator-0.44.0 → openscad_cpp_evaluator-0.45.0}/tests/test_expr_eval.cpp

@@ -52,21 +52,34 @@ 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.
+TEST(ExprEvalIdentifiers, UndefinedDollarVariableIsUndefAndWarns) {
+    // A never-assigned $-name reads as undef and warns, exactly like a
+    // never-declared bare identifier.
+    //
+    // This test used to assert the opposite, on the strength of BOSL2's
+    // constants.scad -- `function get_slop() = is_undef($slop) ? 0 : $slop;`
+    // with $slop never assigned -- being silent in real OpenSCAD. It is,
+    // but not because $-reads are exempt: is_undef() does not warn about the
+    // name it probes, and the else branch never runs while is_undef() is
+    // true. Measured against the reference, a PLAIN read warns in every
+    // context tried -- echo, assignment, function body, module body,
+    // comparison -- so the old blanket exemption was over-generalised from
+    // one guarded expression.
     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());
+    EXPECT_NE(lastWarning.find("Ignoring unknown variable '$slop'"), std::string::npos) << lastWarning;
+}
+
+TEST(ExprEvalIdentifiers, TheBoslGetSlopIdiomStaysSilent) {
+    // The case the old exemption existed for, kept as a test in its own
+    // right: it must remain silent through the is_undef() probe alone.
+    std::string lastWarning;
+    Evaluator ev([&](const std::string& msg) { lastWarning = msg; });
+    Value v = evalSrc("is_undef($slop) ? 0 : $slop", ev);
+    EXPECT_TRUE(lastWarning.empty()) << lastWarning;
+    EXPECT_EQ(std::get<double>(v), 0.0);
 }
 
 TEST(ExprEvalIdentifiers, ResolvesViaScopeFallbackWhenNotEagerlyBound) {

{openscad_cpp_evaluator-0.44.0 → openscad_cpp_evaluator-0.45.0}/tests/test_feature_detection.cpp

@@ -33,8 +33,9 @@ std::vector<std::string> echoesFrom(const std::string& src) {
 
 // Every feature name the docs promise. A typo in either direction -- here or
 // in featureLevels() -- shows up as a 0.
-const char* kFeatures[] = {"separate-children", "minkowski-diff", "sphere-styles", "export-name",
-                            "simplify-op",       "expr-import",    "object-function", "roof-op"};
+const char* kFeatures[] = {"separate-children", "minkowski-diff", "sphere-styles",   "export-name",
+                            "simplify-op",       "expr-import",    "object-function", "roof-op",
+                            "render-expr",       "polyhedron-vnf"};
 
 } // namespace