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

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

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

{openscad_cpp_evaluator-0.44.0 → openscad_cpp_evaluator-0.45.1}/bindings/module.cpp

@@ -385,17 +385,36 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
     {
         nb::gil_scoped_release rel;
         auto logFn = [&echoes](const std::string& m) { echoes.push_back(m); };
-        std::vector<std::unique_ptr<oscad::ASTNode>> ast = oscad::getASTFromFile(path);
-        oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(ast, path, logFn);
-        oscadeval::Evaluator ev(logFn, nullptr, manifoldCache, oscadeval::DebugHooks{}, profile);
-        oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
-        bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp));
-        collectIdSpans(ev, idSpans);
-        csgTree = std::move(ev.csgTree);
-        profileResult = std::move(ev.profileResult);
-        {
-            nb::gil_scoped_acquire g; // building Python objects needs the GIL back
-            std::tie(dyn, dynExplicit) = dynStateToPy(ctx);
+        try {
+            std::vector<std::unique_ptr<oscad::ASTNode>> ast = oscad::getASTFromFile(path);
+            oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(ast, path, logFn);
+            oscadeval::Evaluator ev(logFn, nullptr, manifoldCache, oscadeval::DebugHooks{}, profile);
+            oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
+            bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp));
+            collectIdSpans(ev, idSpans);
+            csgTree = std::move(ev.csgTree);
+            profileResult = std::move(ev.profileResult);
+            {
+                nb::gil_scoped_acquire g; // building Python objects needs the GIL back
+                std::tie(dyn, dynExplicit) = dynStateToPy(ctx);
+            }
+        } catch (const std::exception& e) {
+            // `echoes` is a local, so letting this unwind past here loses
+            // every echo and warning the script produced BEFORE it failed --
+            // which is exactly the output you want when something fails. The
+            // batching that makes them cheap (no GIL round-trip per line) is
+            // also what made them disposable.
+            //
+            // Carry them out on the exception itself: args = (message,
+            // [echo, ...]). The facade replays them through echo_fn and then
+            // re-raises. Anything that only looks at str(e) is unaffected,
+            // since args[0] is still the formatted diagnostic.
+            nb::gil_scoped_acquire g;
+            nb::list partial;
+            for (const std::string& s : echoes) partial.append(s);
+            nb::object args = nb::make_tuple(nb::str(e.what()), partial);
+            PyErr_SetObject(PyExc_RuntimeError, args.ptr());
+            throw nb::python_error();
         }
     }
 

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

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "0.44.0"
+version = "0.45.1"
 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.1}/python/openscad_cpp_evaluator/__init__.py

@@ -504,6 +504,17 @@ class Evaluator:
         except EvalError:
             raise
         except Exception as e:  # ParseError/EvalError from C++ arrive as RuntimeError
+            # The binding attaches whatever the script echoed before it failed
+            # as args[1] (see bindings/module.cpp). Replay it first: a failed
+            # run's own output is the most useful thing it produced, and
+            # dropping it means the console shows the error with none of the
+            # context that led to it.
+            args = getattr(e, "args", ())
+            if len(args) == 2 and isinstance(args[1], list):
+                if self._echo_fn:
+                    for line in args[1]:
+                        self._echo_fn(line)
+                raise EvalError(str(args[0])) from e
             raise EvalError(str(e)) from e
         bodies = bodies_from_dicts(body_dicts)
         # originalID -> a node with `.position` (start/end offsets) for WYSIWYG

{openscad_cpp_evaluator-0.44.0 → openscad_cpp_evaluator-0.45.1}/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.1}/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.1}/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.1}/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.1}/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.1}/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