openscad-cpp-evaluator 1.8.0__tar.gz → 1.9.0__tar.gz

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.9.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.9.0}/bindings/module.cpp

@@ -375,7 +375,7 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
 
 nb::object evaluate(const std::string& path, nb::dict viewportParams,
                      std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, bool profile,
-                     bool generate) {
+                     bool generate, bool strictCommas) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
@@ -389,6 +389,12 @@ 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); };
         try {
+            // Constructed on the parsing thread, which is the one whose
+            // thread-local mode StrictCommaScope sets -- a flag flipped from
+            // Python before the call would sit on the wrong thread the
+            // moment a host evaluates off the main one.
+            std::optional<oscad::StrictCommaScope> strict;
+            if (strictCommas) strict.emplace();
             oscad::ParsedProgram program = oscad::getProgramFromFile(path);
             oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(program.nodes, path, logFn);
             oscadeval::Evaluator ev(logFn, nullptr, manifoldCache, oscadeval::DebugHooks{}, profile);
@@ -801,11 +807,14 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "rather than restated here, so the Python side cannot drift from what can actually be written.");
 
     m.def("evaluate", &evaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("manifold_cache") = nullptr,
-          nb::arg("profile") = false, nb::arg("generate") = true,
+          nb::arg("profile") = false, nb::arg("generate") = true, nb::arg("strict_commas") = false,
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).\n"
           "generate=False stops after the resolve pass: the script runs and reports everything "
           "it normally would, but no Manifold geometry is built, and neither bodies nor csg_tree "
-          "are populated.");
+          "are populated.\n\n"
+          "strict_commas=True makes a trailing comma in a call argument list or a let/for "
+          "assignment list a syntax error, as OpenSCAD 2021.01 did. List literals and parameter "
+          "declarations keep theirs, which 2021.01 accepted too.");
     m.def("parse_decls", &parseDecls, nb::arg("path"),
           "Parse a .scad file; return top-level declaration (namespace, name, start, end, line, column, origin) tuples.");
     m.def("strip_slivers", &stripSliversPy, nb::arg("verts"), nb::arg("tris"),

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.9.0}/external/openscad_cpp_parser/include/openscad_cpp_parser/api.hpp

@@ -60,6 +60,44 @@ std::unique_ptr<Scope> buildScopes(const std::vector<ASTNode*>& ast);
 std::unique_ptr<Scope> buildScopesInto(const std::vector<std::unique_ptr<ASTNode>>& ast, ScopeTable& table);
 std::unique_ptr<Scope> buildScopesInto(const std::vector<ASTNode*>& ast, ScopeTable& table);
 
+// Makes a trailing comma in a CALL ARGUMENT LIST a syntax error for as long
+// as it is in scope, matching OpenSCAD 2021.01:
+//
+//     cube(1,);                  // error while this is in scope
+//     echo(let(x = 1, y = 2,) x) // error -- let() parses as a call
+//     a = [2, 4,];               // still fine: 2021.01 accepts it too
+//     module m(a, b,) {}         // still fine, same reason
+//
+// One production (`arguments`) feeds every call form -- module
+// instantiation, function calls, echo, assert, render and let -- so this is
+// one rule, not a family of them. Parameter lists and list literals are
+// deliberately untouched: 2021.01 accepts a trailing comma in both, and
+// rejecting them would fail files it loads happily.
+//
+// A scope object rather than a parameter on all nine parse entry points:
+// this is a parse-wide mode, the same shape ParseNumberingScope already
+// uses, and threading a bool through getASTFromString/getASTFromFile/
+// getASTFromLibraryFile/getProgramFromFile and their helpers would touch
+// every one of them to say the same thing. Nests and restores on scope
+// exit, exceptions included; thread-local, so one thread parsing strictly
+// cannot change what another thread sees.
+//
+// getProgramFromFile()'s cache keys on this too -- a strict parse must not
+// be handed a tree an earlier lenient parse of the same file left behind.
+class StrictCommaScope {
+public:
+    StrictCommaScope();
+    ~StrictCommaScope();
+    StrictCommaScope(const StrictCommaScope&) = delete;
+    StrictCommaScope& operator=(const StrictCommaScope&) = delete;
+
+private:
+    bool previous_;
+};
+
+// Whether a StrictCommaScope is currently in effect on this thread.
+bool strictCommasEnabled();
+
 // Parses `code`. Throws ParseError (with the full caret diagnostic) on a
 // syntax error.
 //

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.9.0}/external/openscad_cpp_parser/src/api.cpp

@@ -89,6 +89,17 @@ std::string formatSyntaxError(const ParserDriver& driver, const std::string& cod
 
 } // namespace
 
+namespace {
+// See StrictCommaScope (api.hpp). Thread-local so a strict parse on one
+// thread cannot change what another thread is parsing.
+thread_local bool g_strictCommas = false;
+} // namespace
+
+StrictCommaScope::StrictCommaScope() : previous_(g_strictCommas) { g_strictCommas = true; }
+StrictCommaScope::~StrictCommaScope() { g_strictCommas = previous_; }
+
+bool strictCommasEnabled() { return g_strictCommas; }
+
 std::vector<std::unique_ptr<ASTNode>> parseAst(const std::string& code, const std::string& origin, SourceMap* sourceMap) {
     // Stamps every node this parse builds with one treeId and a dense
     // slot, so a ScopeTable can address it without the node carrying a
@@ -96,6 +107,7 @@ std::vector<std::unique_ptr<ASTNode>> parseAst(const std::string& code, const st
     ParseNumberingScope numbering;
 
     ParserDriver driver(origin);
+    driver.strictCommas = g_strictCommas;
     lexerBeginString(code);
     yy::parser parser(driver);
     int rc = parser.parse();
@@ -258,7 +270,8 @@ namespace {
 using FileAst = std::vector<std::unique_ptr<ASTNode>>;
 using FileAstPtr = std::shared_ptr<const FileAst>;
 
-// One entry per (file, comments) -- keyed by PATH, with the content stamp
+// One entry per (file, comments, strict-commas) -- keyed by PATH, with the
+// content stamp
 // stored beside the tree rather than in the key. A stale stamp REPLACES the
 // entry instead of adding a second one: an editor re-renders on every save,
 // and a stamp-in-the-key cache would keep a full copy of every version the
@@ -266,11 +279,18 @@ using FileAstPtr = std::shared_ptr<const FileAst>;
 struct CacheKey {
     std::string path;
     bool comments;
-    bool operator==(const CacheKey& o) const { return comments == o.comments && path == o.path; }
+    // Part of the key, not incidental: the same file parses differently
+    // under StrictCommaScope, so a strict parse must not be served a tree an
+    // earlier lenient parse of it left here (and vice versa).
+    bool strictCommas;
+    bool operator==(const CacheKey& o) const {
+        return comments == o.comments && strictCommas == o.strictCommas && path == o.path;
+    }
 };
 struct CacheKeyHash {
     size_t operator()(const CacheKey& k) const {
-        return std::hash<std::string>{}(k.path) ^ (k.comments ? 0x5bf03635U : 0U);
+        return std::hash<std::string>{}(k.path) ^ (k.comments ? 0x5bf03635U : 0U)
+               ^ (k.strictCommas ? 0x9e3779b9U : 0U);
     }
 };
 struct CacheEntry {
@@ -290,7 +310,7 @@ FileAstPtr parseFileShared(const std::string& absPath, bool includeComments) {
     const auto written = fs::last_write_time(absPath, ec);
     const std::int64_t stampMtime = ec ? 0 : static_cast<std::int64_t>(written.time_since_epoch().count());
 
-    const CacheKey key{absPath, includeComments};
+    const CacheKey key{absPath, includeComments, g_strictCommas};
     {
         std::lock_guard<std::mutex> lock(g_astCacheMutex);
         auto it = g_astCache.find(key);

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.9.0}/external/openscad_cpp_parser/src/grammar/driver.hpp

@@ -39,6 +39,9 @@ public:
     std::string origin_;
     NodeList result;
     bool hadError = false;
+    // Copied from the ambient StrictCommaScope at parse start (api.cpp), so
+    // one parse's mode cannot change under it mid-run.
+    bool strictCommas = false;
     int errorLine = 0;
     int errorColumn = 0;
     int errorOffset = 0;

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.9.0}/external/openscad_cpp_parser/src/grammar/parser.y

@@ -247,7 +247,18 @@ parameter:
 arguments:
     %empty                    { $$ = NodeList{}; }
   | argument_seq               { $$ = std::move($1); }
-  | argument_seq ","            { $$ = std::move($1); }
+    // The trailing comma OpenSCAD 2021.01 rejected. Still parsed, then
+    // reported -- @2 is the comma itself, so the caret lands on it rather
+    // than on the whole argument list, which a %expect-style grammar split
+    // could not manage. This one production feeds every call form (module
+    // instantiation, function calls, echo, assert, render, and let), which
+    // is why the whole feature is one rule. See StrictCommaScope (api.hpp).
+  | argument_seq ","            {
+        if (driver.strictCommas) {
+            driver.reportError(@2, "trailing comma in argument list");
+        }
+        $$ = std::move($1);
+    }
   ;
 
 argument_seq:
@@ -263,7 +274,18 @@ argument:
 assignments_expr:
     %empty                          { $$ = NodeList{}; }
   | assignment_expr_seq              { $$ = std::move($1); }
-  | assignment_expr_seq ","           { $$ = std::move($1); }
+    // 2021.01 rejected this one too. `let` does NOT go through `arguments`
+    // in this grammar -- it has its own assignment list, shared with `for`
+    // and `intersection_for` -- so the feature is two productions, not the
+    // one it looks like. 2021.01 rejects a trailing comma in all four:
+    // let(x=1,), for(i=[0:2],), intersection_for(i=[0:1],) and the list
+    // comprehension forms of for. See StrictCommaScope (api.hpp).
+  | assignment_expr_seq ","           {
+        if (driver.strictCommas) {
+            driver.reportError(@2, "trailing comma in assignment list");
+        }
+        $$ = std::move($1);
+    }
   ;
 
 assignment_expr_seq:

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.9.0}/external/openscad_cpp_parser/tests/CMakeLists.txt

@@ -26,6 +26,7 @@ add_executable(oscad_tests
   test_ast_generation.cpp
   test_node_str.cpp
   test_render_expression.cpp
+  test_strict_commas.cpp
 )
 target_link_libraries(oscad_tests PRIVATE openscad_cpp_parser GTest::gtest_main)
 

openscad_cpp_evaluator-1.9.0/external/openscad_cpp_parser/tests/test_strict_commas.cpp

@@ -0,0 +1,117 @@
+// StrictCommaScope: a trailing comma in a call argument list is an error,
+// matching OpenSCAD 2021.01 (BelfrySCAD issue #362).
+//
+// The scope is deliberately narrow. Measured against 2021.01 itself, it
+// rejected a trailing comma in CALL ARGUMENTS and accepted one everywhere
+// else -- list literals, list comprehensions, and module/function parameter
+// declarations all take one, in 2021.01 as in every version since. Rejecting
+// those would fail files 2021.01 loads happily, so they are left alone and
+// this file says so case by case.
+#include "test_helpers.hpp"
+
+#include <gtest/gtest.h>
+
+using namespace oscad;
+
+namespace {
+
+// Two productions carry it: `arguments` (every call form) and
+// `assignments_expr` (let/for/intersection_for). `let` is NOT a call in this
+// grammar -- it has its own assignment list -- which the first draft of this
+// feature got wrong and this test caught.
+const char* const kRejected[] = {
+    "cube(1,);",                            // module instantiation
+    "translate([0,0,0],) cube(1);",         // ...with a child
+    "function g(x) = x; y = g(1,);",        // user function call
+    "y = max(1, 2,);",                      // builtin function call
+    "y = str(\"a\", \"b\",);",
+    "echo(1, 2,);",
+    "assert(true, \"m\",);",
+    // assignments_expr, not arguments
+    "y = let(x = 1, y = 2,) x + y;",
+    "let(x = 1,) cube(x);",
+    "for (i = [0:2],) cube(i);",
+    "intersection_for (i = [0:1],) cube(1);",
+    "a = [for (i = [0:1],) i];",
+};
+
+// Accepted by 2021.01, so accepted here even under the scope.
+const char* const kAccepted[] = {
+    "a = [2, 4,];",                         // list literal
+    "a = [for (i = [0:2]) i,];",            // list comprehension
+    "a = [each [1, 2],];",
+    "module m(a, b,) {} m(1, 2);",          // module parameter declaration
+    "function f(a, b,) = a + b;",           // function parameter declaration
+    "cube(1);",                             // no trailing comma at all
+    "y = max(1, 2);",
+};
+
+} // namespace
+
+TEST(StrictCommas, CallArgumentTrailingCommaIsAnErrorInScope) {
+    StrictCommaScope strict;
+    for (const char* src : kRejected) {
+        EXPECT_THROW(parseSrc(src), ParseError) << src;
+    }
+}
+
+TEST(StrictCommas, EverythingElseKeepsItsTrailingComma) {
+    StrictCommaScope strict;
+    for (const char* src : kAccepted) {
+        EXPECT_NO_THROW(parseSrc(src)) << src;
+    }
+}
+
+TEST(StrictCommas, OffByDefault) {
+    // The whole set parses without the scope -- this is opt-in, and every
+    // existing caller must be unaffected.
+    for (const char* src : kRejected) {
+        EXPECT_NO_THROW(parseSrc(src)) << src;
+    }
+}
+
+TEST(StrictCommas, ScopeNestsAndRestores) {
+    EXPECT_FALSE(strictCommasEnabled());
+    {
+        StrictCommaScope outer;
+        EXPECT_TRUE(strictCommasEnabled());
+        {
+            StrictCommaScope inner;
+            EXPECT_TRUE(strictCommasEnabled());
+        }
+        EXPECT_TRUE(strictCommasEnabled()) << "an inner scope must not switch it off";
+    }
+    EXPECT_FALSE(strictCommasEnabled());
+}
+
+TEST(StrictCommas, RestoresWhenAParseThrows) {
+    try {
+        StrictCommaScope strict;
+        parseSrc("cube(1,);");
+        FAIL() << "expected ParseError";
+    } catch (const ParseError&) {
+    }
+    EXPECT_FALSE(strictCommasEnabled()) << "the scope must unwind with the exception";
+}
+
+TEST(StrictCommas, TheErrorPointsAtTheComma) {
+    StrictCommaScope strict;
+    try {
+        parseSrc("cube(1,);");
+        FAIL() << "expected ParseError";
+    } catch (const ParseError& e) {
+        const std::string what = e.what();
+        EXPECT_NE(what.find("trailing comma in argument list"), std::string::npos) << what;
+    }
+}
+
+TEST(StrictCommas, AnAssignmentListSaysSo) {
+    StrictCommaScope strict;
+    try {
+        parseSrc("y = let(x = 1,) x;");
+        FAIL() << "expected ParseError";
+    } catch (const ParseError& e) {
+        const std::string what = e.what();
+        EXPECT_NE(what.find("trailing comma in assignment list"), std::string::npos) << what;
+    }
+}

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.9.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.9.0}/python/openscad_cpp_evaluator/__init__.py

@@ -497,7 +497,7 @@ class Evaluator:
         self.dyn_explicit = set()
 
     def evaluate(self, source_path: str, viewport_params: Optional[dict] = None,
-                 generate: bool = True):
+                 generate: bool = True, strict_commas: bool = False):
         """Run `source_path` and return (bodies, id_to_node).
 
         `generate=False` stops after the resolve pass. The script still runs
@@ -508,6 +508,13 @@ class Evaluator:
         the geometry without skipping the language.
 
         Ignored on the debugger path, which has no geometry handle anyway.
+
+        `strict_commas=True` makes a trailing comma in a call argument list
+        or a let/for assignment list a syntax error, as OpenSCAD 2021.01 did
+        -- `cube(1,)` and `let(x = 1,)`, but NOT `[2, 4,]` or
+        `module m(a, b,)`, which 2021.01 accepted. For checking a script
+        against that version; off, and no divergence from current OpenSCAD,
+        otherwise. Also ignored on the debugger path.
         """
         vp = viewport_params or {}
         try:
@@ -528,7 +535,8 @@ class Evaluator:
             else:
                 (body_dicts, echoes, id_spans, csg_tree, profile_result, dyn,
                  dyn_explicit, geometry) = _ext.evaluate(
-                    source_path, vp, self._manifold_cache, self._profile, generate)
+                    source_path, vp, self._manifold_cache, self._profile, generate,
+                    strict_commas)
                 # The evaluated bodies, still on the C++ side. Stashed like
                 # csg_tree/profile_result rather than returned, so
                 # evaluate()'s own 2-tuple result is unchanged -- callers

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.9.0}/tests/test_python_bindings.py

@@ -659,3 +659,40 @@ def test_export_model_facade_accepts_split_components(tmp_path):
     # Default matches OpenSCAD: one object however many pieces.
     assert objects_in(tmp_path / "joined.3mf") == 1
     assert objects_in(tmp_path / "split.3mf", split_components=True) == 3
+
+
+def test_strict_commas_reaches_the_parser(tmp_path):
+    """Evaluator.evaluate(strict_commas=True) must survive both hand-written
+    parameter lists -- the facade's and the nanobind binding's. The last
+    argument added this way was dropped by the facade and no C++ test could
+    see it (see test_export_model_facade_accepts_split_components)."""
+    import pytest
+    from openscad_cpp_evaluator import Evaluator, EvalError
+
+    rejected = tmp_path / "call.scad"
+    rejected.write_text("cube(1,);\n")
+    accepted = tmp_path / "list.scad"
+    accepted.write_text("a = [2, 4,];\ncube(a[0]);\n")
+
+    # Off by default: both parse, as they do in current OpenSCAD.
+    Evaluator(echo_fn=lambda _m: None).evaluate(str(rejected), {})
+    Evaluator(echo_fn=lambda _m: None).evaluate(str(accepted), {})
+
+    # On: a call's trailing comma is a syntax error, a list literal's is not
+    # -- 2021.01 accepted the list.
+    with pytest.raises(EvalError):
+        Evaluator(echo_fn=lambda _m: None).evaluate(str(rejected), {}, strict_commas=True)
+    Evaluator(echo_fn=lambda _m: None).evaluate(str(accepted), {}, strict_commas=True)
+
+
+def test_strict_commas_does_not_leak_between_evaluations(tmp_path):
+    """The parser mode is a scope object; a strict parse must not leave it on
+    for the next caller."""
+    import pytest
+    from openscad_cpp_evaluator import Evaluator, EvalError
+
+    src = tmp_path / "call.scad"
+    src.write_text("cube(1,);\n")
+    with pytest.raises(EvalError):
+        Evaluator(echo_fn=lambda _m: None).evaluate(str(src), {}, strict_commas=True)
+    Evaluator(echo_fn=lambda _m: None).evaluate(str(src), {})   # must not raise

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.9.0}/tools/cli/cli_lib.cpp

@@ -222,6 +222,7 @@ int runCli(const std::vector<std::string>& args, std::istream& in, std::ostream&
     std::string profileMinSelfStr;
     std::string profileMinCallsStr;
     bool debug = false;
+    bool strictCommas = false;
     for (size_t i = 0; i < args.size(); ++i) {
         const std::string& arg = args[i];
         if (arg == "-o" && i + 1 < args.size()) {
@@ -242,6 +243,8 @@ int runCli(const std::vector<std::string>& args, std::istream& in, std::ostream&
             profileMinCallsStr = args[++i];
         } else if (arg == "--debug") {
             debug = true;
+        } else if (arg == "--strict-commas") {
+            strictCommas = true;
         } else if (inputPath.empty()) {
             inputPath = arg;
         }
@@ -249,7 +252,7 @@ int runCli(const std::vector<std::string>& args, std::istream& in, std::ostream&
     if (inputPath.empty() || outputPath.empty()) {
         err << "usage: openscad-cpp-evaluator <input.scad> -o <output.{stl,obj,off,3mf,ply,wrl,x3d}> [--format stl|obj|off|3mf|ply|wrl|x3d] [--ascii-stl] "
                "[--profile FILENAME [--profile-format text|csv] [--profile-sort self|cumulative|calls|name] "
-               "[--profile-min-self SECONDS] [--profile-min-calls N]] [--debug]\n";
+               "[--profile-min-self SECONDS] [--profile-min-calls N]] [--debug] [--strict-commas]\n";
         return 1;
     }
     const std::string fmt = formatForPath(format, outputPath);
@@ -293,6 +296,11 @@ int runCli(const std::vector<std::string>& args, std::istream& in, std::ostream&
     }
 
     try {
+        // Scoped to the parse: a trailing comma in a call argument list or a
+        // let/for assignment list is a syntax error while it is in effect,
+        // as OpenSCAD 2021.01 had it. See oscad::StrictCommaScope.
+        std::optional<oscad::StrictCommaScope> strict;
+        if (strictCommas) strict.emplace();
         std::vector<std::unique_ptr<oscad::ASTNode>> ast = oscad::getASTFromFile(inputPath);
         ResolvedUseScopes used = resolveUseScopes(ast, inputPath, [&out](const std::string& msg) { out << msg << "\n"; });