openscad-cpp-evaluator 0.27.1__tar.gz → 0.28.2__tar.gz

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/PKG-INFO

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

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/external/openscad_cpp_parser/src/grammar/lexer.l

@@ -99,6 +99,15 @@ NUMLIT  0[xX][0-9A-Fa-f]+|[0-9]+([.][0-9]*)?([eE][+-]?[0-9]+)?|[.][0-9]+([eE][+-
     driver.stringStart = driver.tokenStart;
     BEGIN(STR);
 }
+    /* A backslash escaping the end of the line. Flex's `.` never matches a
+       newline, so without this rule the backslash matched nothing, fell to
+       flex's default ECHO and was printed to stdout -- a stray `\` on every
+       parse of such a file -- while the newline was picked up as ordinary
+       content by the run rule below and ended up inside the string.
+       Kept verbatim rather than dropped here: the value is cooked when the
+       literal is evaluated, so the AST keeps text that reproduces the
+       source exactly, which is what the pretty-printer round-trips. */
+<STR>\\\r?\n { driver.stringBuffer.append(yytext, yyleng); }
 <STR>\\. { driver.stringBuffer.append(yytext, yyleng); }
 <STR>[^"\\]+ { driver.stringBuffer.append(yytext, yyleng); }
 <STR>\" {

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/external/openscad_cpp_parser/tests/test_lexical.cpp

@@ -436,3 +436,40 @@ TEST(SourceSpans, MultiLineStringReportsItsStartingLine) {
     EXPECT_EQ(assign->expr->position().line, 2);
     EXPECT_EQ(spanned(src, *assign->expr), "\"one\ntwo\"");
 }
+
+// -- Backslash at end of line inside a string ---------------------------
+
+// The lexer had no rule for a backslash followed by a newline: flex's `.`
+// never matches a newline, so `\\.` could not, and the backslash fell
+// through to flex's DEFAULT ECHO rule -- printed straight to stdout, a
+// stray `\` on every parse of such a file. The newline was then swallowed
+// by the content-run rule and became part of the string.
+//
+// The literal keeps both characters. Cooking happens where the literal is
+// evaluated, not here, so a StringLiteral's text still reproduces the
+// source it was parsed from -- which is what pretty-printing relies on.
+TEST(LexicalStrings, BackslashNewlineIsKeptVerbatimInTheLiteral) {
+    struct Case { std::string src; std::string want; const char* what; };
+    const Case cases[] = {
+        {"a = \"x \\\ny\";",   "x \\\ny",   "LF"},
+        {"a = \"x \\\r\ny\";", "x \\\r\ny", "CRLF"},
+    };
+    for (const Case& c : cases) {
+        auto ast = parseSrc(c.src);
+        ASSERT_EQ(ast.size(), 1u) << c.what;
+        auto* assign = dynamic_cast<Assignment*>(ast[0].get());
+        ASSERT_NE(assign, nullptr) << c.what;
+        auto* str = dynamic_cast<StringLiteral*>(assign->expr.get());
+        ASSERT_NE(str, nullptr) << c.what;
+        EXPECT_EQ(str->val, c.want) << c.what;
+    }
+}
+
+// The continued line still counts, or every position after a multi-line
+// string would be reported one line short.
+TEST(LexicalStrings, BackslashNewlineStillAdvancesTheLineNumber) {
+    auto ast = parseSrc("a = \"x \\\ny\";\nb = 2;\n");
+    ASSERT_EQ(ast.size(), 2u);
+    EXPECT_EQ(ast[0]->position().line, 1);
+    EXPECT_EQ(ast[1]->position().line, 3) << "the continuation consumed a line";
+}

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -330,6 +330,11 @@ public:
     // free function, same reasoning as tagGenerated()/builtinChildren().
     void warn(const std::string& message, const oscad::Position* position);
 
+    // Apply `!`: replace the whole tree with the first show_only
+    // subtree, discarding its ancestors and every sibling. See its
+    // definition for why this cannot be done by tagging bodies.
+    void rerootAtShowOnly(std::vector<std::unique_ptr<CSGNode>>& tree);
+
     // parent_module(idx) support: walks the live module-call stack
     // (innermost last) and returns the name `idx` levels up from the
     // current module, or undef if out of range. Public because

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/include/openscad_cpp_evaluator/value.hpp

@@ -181,6 +181,26 @@ Value matmul(const Value& a, const Value& b);
 // script's output is shown to land on one.
 std::string formatNumber(double v);
 
+// Resolve the escape sequences in a string literal's source text.
+//
+// The parser stores a StringLiteral's text exactly as written, backslashes
+// and all, so that a literal still reproduces the source it came from and
+// pretty-printing round-trips. Cooking is therefore this side's job, and
+// until this existed every escape reached scripts intact: "a\nb" was four
+// characters, a backslash and an 'n' among them, rather than three.
+//
+//   \\ \" \n \t \r    the character they name
+//   \<newline>        nothing at all -- a line continuation, so the string
+//                     carries on with no break in it. A CRLF goes whole:
+//                     leaving the CR behind, as the reference
+//                     implementation does, puts a stray control character
+//                     into the value of any script written on Windows.
+//   \<anything else>  that character, with the backslash dropped
+//
+// A trailing lone backslash is kept as itself. It can only occur in an
+// unterminated literal, which is a parse error long before this runs.
+std::string unescapeStringLiteral(const std::string& raw);
+
 // echo()/str()/assert-message display format: "undef" | "true"/"false" |
 // "[start : step : end]" (range) | formatNumber() (number) | "[e1, e2, ...]"
 // (list, recursive) | "object(k1 = v1, ...)" ("object()" if empty) |

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/pyproject.toml

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

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/src/bytecode_compiler.cpp

@@ -324,7 +324,10 @@ public:
                 out.push_back({Op::PushBool, static_cast<const oscad::BooleanLiteral&>(node).val ? 1 : 0, 0, nullptr});
                 return;
             case NodeKind::StringLiteral:
-                out.push_back({Op::PushConst, internConst(Value{static_cast<const oscad::StringLiteral&>(node).val}), 0,
+                out.push_back({Op::PushConst,
+                                internConst(Value{unescapeStringLiteral(
+                                    static_cast<const oscad::StringLiteral&>(node).val)}),
+                                0,
                                 nullptr});
                 return;
             case NodeKind::UndefinedLiteral:

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/src/csg_resolve.cpp

@@ -1,3 +1,4 @@
+#include <functional>
 #include "openscad_cpp_evaluator/dispatch.hpp"
 #include "openscad_cpp_evaluator/evaluator.hpp"
 
@@ -255,6 +256,7 @@ std::vector<ColoredBody> Evaluator::evaluateImpl(const NodeList& nodes, EvalCont
     using Clock = std::chrono::steady_clock;
     const Clock::time_point resolveStart = profiling_ ? Clock::now() : Clock::time_point{};
     std::vector<std::unique_ptr<CSGNode>> tree = resolveTreeImpl(nodes, ctx);
+    rerootAtShowOnly(tree);
     const Clock::time_point resolveEnd = profiling_ ? Clock::now() : Clock::time_point{};
     std::vector<ColoredBody> result = generateTree(tree);
     const Clock::time_point generateEnd = profiling_ ? Clock::now() : Clock::time_point{};
@@ -289,6 +291,44 @@ std::vector<ColoredBody> Evaluator::evaluateImpl(const NodeList& nodes, EvalCont
     return result;
 }
 
+
+// `!` does not merely tag what it marks -- it makes that subtree the whole
+// model. Everything else goes: siblings, and every operation wrapped around
+// it. `translate([50,0,0]) !cube(5);` puts a cube at the origin, and
+// `linear_extrude(height=10) !circle(10);` leaves a 2D circle rather than a
+// cylinder, because the extrude is an ancestor and ancestors are discarded.
+//
+// Tagging the bodies and filtering them at the end -- which is what this
+// did before -- cannot express that: by the time a body carries the tag,
+// every ancestor has already been applied to it.
+void Evaluator::rerootAtShowOnly(std::vector<std::unique_ptr<CSGNode>>& tree) {
+    std::vector<std::unique_ptr<CSGNode>*> found;
+    // Pre-order, so `found.front()` is the first one in the source.
+    std::function<void(std::vector<std::unique_ptr<CSGNode>>&)> walk =
+        [&](std::vector<std::unique_ptr<CSGNode>>& nodes) {
+            for (std::unique_ptr<CSGNode>& n : nodes) {
+                if (!n) continue;
+                if (n->kind == "show_only") found.push_back(&n);
+                walk(n->children);
+            }
+        };
+    walk(tree);
+    if (found.empty()) return;
+
+    if (found.size() > 1) {
+        // Same rule as the reference: warn, and take the first.
+        const CSGNode& second = **found[1];
+        warn("More than one Root Modifier (!)",
+             second.node ? &second.node->position() : nullptr);
+    }
+
+    // Moved out before the rest of the tree is dropped -- its owner is
+    // somewhere inside what is about to be destroyed.
+    std::unique_ptr<CSGNode> chosen = std::move(*found.front());
+    tree.clear();
+    tree.push_back(std::move(chosen));
+}
+
 std::vector<ColoredBody> Evaluator::evaluate(const std::vector<std::unique_ptr<oscad::ASTNode>>& nodes, EvalContext& ctx,
                                               const std::unordered_map<std::string, Value>& viewportParams) {
     return evaluateImpl(nodes, ctx, viewportParams);

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/src/expr_eval.cpp

@@ -396,7 +396,7 @@ Value Evaluator::evalExpr(const oscad::Expression& node, EvalContext& ctx) {
         case NodeKind::BooleanLiteral:
             return Value{static_cast<const oscad::BooleanLiteral&>(node).val};
         case NodeKind::StringLiteral:
-            return Value{static_cast<const oscad::StringLiteral&>(node).val};
+            return Value{unescapeStringLiteral(static_cast<const oscad::StringLiteral&>(node).val)};
         case NodeKind::UndefinedLiteral:
             return Value{};
         case NodeKind::CommentedExpr:

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/src/value.cpp

@@ -268,6 +268,40 @@ Value matmul(const Value& a, const Value& b) {
     return makeList(std::move(out));
 }
 
+std::string unescapeStringLiteral(const std::string& raw) {
+    // Most strings carry no escape at all, and this runs on every
+    // evaluation of a literal on the tree-walking path -- so don't build a
+    // second copy of the string unless there is something to change.
+    const size_t first = raw.find('\\');
+    if (first == std::string::npos) return raw;
+
+    std::string out;
+    out.reserve(raw.size());
+    out.append(raw, 0, first);
+    for (size_t i = first; i < raw.size(); ++i) {
+        if (raw[i] != '\\' || i + 1 >= raw.size()) {
+            out.push_back(raw[i]);  // a trailing lone backslash stands for itself
+            continue;
+        }
+        const char next = raw[i + 1];
+        switch (next) {
+            case 'n': out.push_back('\n'); ++i; break;
+            case 't': out.push_back('\t'); ++i; break;
+            case 'r': out.push_back('\r'); ++i; break;
+            case '\n': ++i; break;  // line continuation: contributes nothing
+            case '\r':
+                // Only a CRLF pair is a line continuation; a lone CR is an
+                // ordinary escaped character like any other.
+                if (i + 2 < raw.size() && raw[i + 2] == '\n') { i += 2; break; }
+                out.push_back('\r');
+                ++i;
+                break;
+            default: out.push_back(next); ++i; break;  // \\ and \" land here too
+        }
+    }
+    return out;
+}
+
 std::string formatNumber(double v) {
     if (std::isnan(v)) return "nan";
     if (std::isinf(v)) return v > 0 ? "inf" : "-inf";

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/tests/test_booleans.cpp

@@ -177,15 +177,50 @@ TEST(Modifiers, BackgroundIsExcludedFromBooleanMergeButStillReturned) {
     EXPECT_TRUE(hasBackground);
 }
 
-TEST(Modifiers, TopLevelShowOnlyFiltersOutEverythingElse) {
+TEST(Modifiers, TopLevelShowOnlyLeavesNothingButItsOwnSubtree) {
     Evaluated e = evaluateSrc("!cube(1); cube(2); #cube(3);");
-    // evaluate()'s top-level filter: any show_only body present -> keep
-    // only show_only + highlight bodies. cube(2) (role=normal) is dropped;
-    // cube(1) (show_only) and cube(3) (highlight) survive.
-    ASSERT_EQ(e.bodies.size(), 2u);
-    for (const ColoredBody& b : e.bodies) {
-        EXPECT_TRUE(b.role == BodyRole::ShowOnly || b.role == BodyRole::Highlight);
-    }
+    // `!` makes its subtree the whole model, so both siblings go -- the
+    // highlighted one included. This test previously expected cube(3) to
+    // survive on the strength of its role; the reference implementation
+    // renders only cube(1) here (checked against 2021.01).
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_EQ(e.bodies[0].role, BodyRole::ShowOnly);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 1.0, 1e-9);
+}
+
+// The reason a body-role filter could not do this: by the time a body is
+// tagged, every operation wrapped around it has already been applied.
+TEST(Modifiers, ShowOnlyDiscardsTheOperationsWrappedAroundIt) {
+    Evaluated moved = evaluateSrc("translate([50,0,0]) !cube(5);");
+    ASSERT_EQ(moved.bodies.size(), 1u);
+    const manifold::Box box = moved.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(box.min.x, 0.0, 1e-9) << "the translate is an ancestor, so it does not apply";
+    EXPECT_NEAR(box.max.x, 5.0, 1e-9);
+}
+
+// The case that prompted this: an extrude is an ancestor like any other,
+// so what is left is the 2D circle rather than the cylinder.
+TEST(Modifiers, ShowOnlyInsideAnExtrudeLeavesTheProfile) {
+    Evaluated e = evaluateSrc("linear_extrude(height=10) !circle(10);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    // What survives is 2D: a section, not a solid. Extruding it is what
+    // the discarded ancestor would have done.
+    ASSERT_TRUE(e.bodies[0].section.has_value()) << "extruded into a solid";
+    const manifold::Rect bounds = e.bodies[0].section->Bounds();
+    EXPECT_NEAR(bounds.max.x, 10.0, 0.1);
+    EXPECT_NEAR(bounds.min.x, -10.0, 0.1);
+}
+
+TEST(Modifiers, MoreThanOneShowOnlyTakesTheFirstAndWarns) {
+    std::vector<std::string> echoed;
+    Evaluated e = evaluateSrc("translate([50,0,0]) !cube(5);\n!sphere(3);",
+                              [&echoed](const std::string& m) { echoed.push_back(m); });
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const manifold::Box box = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(box.max.x, 5.0, 1e-9) << "the cube, not the sphere";
+    EXPECT_TRUE(std::any_of(echoed.begin(), echoed.end(), [](const std::string& m) {
+        return m.find("More than one Root Modifier") != std::string::npos;
+    })) << "no warning in: " << (echoed.empty() ? "(nothing)" : echoed.front());
 }
 
 TEST(Modifiers, NoShowOnlyMeansAllRolesPassThrough) {

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/tests/test_bytecode_compiler.cpp

@@ -1044,7 +1044,7 @@ TEST(BytecodeCompiler, ImportCompilesAsTailPositionBody) {
         std::ofstream out(path);
         out << R"({"a": 1, "b": 2})";
     }
-    EXPECT_EQ(runCapturingEcho("function f() = import(\"" + path.string() + "\");\necho(f());"),
+    EXPECT_EQ(runCapturingEcho("function f() = import(\"" + path.generic_string() + "\");\necho(f());"),
               "ECHO: object(a = 1, b = 2)");
     std::filesystem::remove(path);
 }
@@ -1073,7 +1073,7 @@ TEST(BytecodeCompiler, VmOffAndVmOnAgreeOnEchoAssertImportObjectCases) {
     const std::string script = "function withEcho(x) = echo(\"trace\", x) x + 1;\n"
                                 "function withAssert(x) = assert(x >= 0, \"must be non-negative\") x * 2;\n"
                                 "function withImport() = import(\"" +
-                                path.string() +
+                                path.generic_string() +
                                 "\");\n"
                                 "existing = object(m = 1);\n"
                                 "function withObject() = object(n = 2, existing, m = 3);\n"

{openscad_cpp_evaluator-0.27.1 → openscad_cpp_evaluator-0.28.2}/tests/test_dxf_svg_import.cpp

@@ -38,7 +38,7 @@ const char* kMinimalDxfSquare =
 TEST(DxfImport, ClosedLwpolylineProducesExpectedBoundingBox) {
     const auto path = tempPath("square.dxf");
     writeFile(path, kMinimalDxfSquare);
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6); // 4x3 square
@@ -49,7 +49,7 @@ TEST(DxfImport, ExpressionContextReturnsRegion) {
     const auto path = tempPath("square_expr.dxf");
     writeFile(path, kMinimalDxfSquare);
     Evaluator ev;
-    Value v = asExpr("import(\"" + path.string() + "\")", ev);
+    Value v = asExpr("import(\"" + path.generic_string() + "\")", ev);
     const auto& contours = std::get<ListPtr>(v)->items;
     ASSERT_EQ(contours.size(), 1u);
     const auto& pts = std::get<ListPtr>(contours[0])->items;
@@ -68,7 +68,7 @@ TEST(DxfImport, LayerFilterExcludesOtherLayers) {
         "0\nENDSEC\n0\nEOF\n";
     const auto path = tempPath("layered.dxf");
     writeFile(path, dxf);
-    Evaluated e = evalSrc("import(file=\"" + path.string() + "\", layer=\"keep\");");
+    Evaluated e = evalSrc("import(file=\"" + path.generic_string() + "\", layer=\"keep\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 1.0, 1e-6);
@@ -90,7 +90,7 @@ TEST(DxfImport, ClosedPolylineVertexEntityProducesExpectedArea) {
         "0\nENDSEC\n0\nEOF\n";
     const auto path = tempPath("polyline.dxf");
     writeFile(path, dxf);
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6);
@@ -111,7 +111,7 @@ TEST(DxfImport, OpenPolylineIsIgnored) {
     const auto path = tempPath("open_polyline.dxf");
     writeFile(path, dxf);
     Evaluator ev;
-    auto ast = parseSrc("import(\"" + path.string() + "\");");
+    auto ast = parseSrc("import(\"" + path.generic_string() + "\");");
     auto scope = oscad::buildScopes(ast);
     EvalContext ctx = EvalContext::makeRoot(scope.get());
     EXPECT_THROW(ev.resolveTree(ast, ctx), EvalError);
@@ -131,7 +131,7 @@ TEST(DxfImport, UnrecognizedEntityIsSkipped) {
         "0\nENDSEC\n0\nEOF\n";
     const auto path = tempPath("unrecognized.dxf");
     writeFile(path, dxf);
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6);
@@ -143,7 +143,7 @@ TEST(DxfImport, NoClosedContoursErrors) {
     const auto path = tempPath("empty.dxf");
     writeFile(path, dxf);
     Evaluator ev;
-    auto ast = parseSrc("import(\"" + path.string() + "\");");
+    auto ast = parseSrc("import(\"" + path.generic_string() + "\");");
     auto scope = oscad::buildScopes(ast);
     EvalContext ctx = EvalContext::makeRoot(scope.get());
     EXPECT_THROW(ev.resolveTree(ast, ctx), EvalError);
@@ -155,7 +155,7 @@ TEST(DxfImport, NoClosedContoursErrors) {
 TEST(SvgImport, RectProducesExpectedArea) {
     const auto path = tempPath("rect.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="4" height="3"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6);
@@ -167,7 +167,7 @@ TEST(SvgImport, PathWithGroupTransformIsTranslatedAndYFlipped) {
     writeFile(path, R"svg(<svg xmlns="http://www.w3.org/2000/svg">
         <g transform="translate(10,0)"><path d="M0,0 L4,0 L4,3 L0,3 Z"/></g>
     </svg>)svg");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     manifold::Rect bounds = e.bodies[0].section->Bounds();
@@ -183,7 +183,7 @@ TEST(SvgImport, PathWithGroupTransformIsTranslatedAndYFlipped) {
 TEST(SvgImport, CircleApproximatesAnalyticArea) {
     const auto path = tempPath("circle.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><circle cx="0" cy="0" r="5"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 3.14159265 * 25.0, 1.0); // 32-segment approximation
     std::filesystem::remove(path);
@@ -192,7 +192,7 @@ TEST(SvgImport, CircleApproximatesAnalyticArea) {
 TEST(SvgImport, CubicBezierPathIsWatertight) {
     const auto path = tempPath("bezier.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><path d="M0,0 C2,5 8,5 10,0 L10,-5 L0,-5 Z"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_GT(e.bodies[0].section->Area(), 0.0);
@@ -203,7 +203,7 @@ TEST(SvgImport, NoShapesErrors) {
     const auto path = tempPath("noshapes.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><defs><rect x="0" y="0" width="1" height="1"/></defs></svg>)");
     Evaluator ev;
-    auto ast = parseSrc("import(\"" + path.string() + "\");");
+    auto ast = parseSrc("import(\"" + path.generic_string() + "\");");
     auto scope = oscad::buildScopes(ast);
     EvalContext ctx = EvalContext::makeRoot(scope.get());
     EXPECT_THROW(ev.resolveTree(ast, ctx), EvalError);
@@ -220,7 +220,7 @@ TEST(SvgImport, EntityReferencesInAttributeValueDecodedWithoutCorruptingParse) {
     // area would come out wrong (or parsing would throw).
     const auto path = tempPath("entities.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><rect id="a&amp;b&lt;c&gt;d&quot;e&apos;f" x="0" y="0" width="4" height="3"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6);
@@ -241,7 +241,7 @@ TEST(SvgImport, CommentCdataPrologAndDoctypeAreSkipped) {
 <rect x="0" y="0" width="4" height="3"/>
 </svg>
 )");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6);
@@ -253,7 +253,7 @@ TEST(SvgImport, TransformMatrixIsApplied) {
     writeFile(path, R"svg(<svg xmlns="http://www.w3.org/2000/svg">
         <g transform="matrix(2,0,0,2,5,0)"><rect x="0" y="0" width="4" height="3"/></g>
     </svg>)svg");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 48.0, 1e-6); // 2x scale in both axes -> 4x area
     manifold::Rect bounds = e.bodies[0].section->Bounds();
@@ -267,7 +267,7 @@ TEST(SvgImport, TransformScaleWithSeparateXyIsApplied) {
     writeFile(path, R"svg(<svg xmlns="http://www.w3.org/2000/svg">
         <g transform="scale(2,3)"><rect x="0" y="0" width="4" height="3"/></g>
     </svg>)svg");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 72.0, 1e-6); // 2x * 3x -> 6x area
     std::filesystem::remove(path);
@@ -278,7 +278,7 @@ TEST(SvgImport, TransformRotateAboutOriginIsApplied) {
     writeFile(path, R"svg(<svg xmlns="http://www.w3.org/2000/svg">
         <g transform="rotate(90)"><rect x="0" y="0" width="4" height="3"/></g>
     </svg>)svg");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6); // rotation preserves area
     manifold::Rect bounds = e.bodies[0].section->Bounds();
@@ -294,7 +294,7 @@ TEST(SvgImport, TransformRotateAboutOriginIsApplied) {
 TEST(SvgImport, HorizontalAndVerticalLineCommands) {
     const auto path = tempPath("hv.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><path d="M0,0 H4 V3 H0 Z"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6);
     std::filesystem::remove(path);
@@ -303,7 +303,7 @@ TEST(SvgImport, HorizontalAndVerticalLineCommands) {
 TEST(SvgImport, SmoothCubicCommandFollowsCubic) {
     const auto path = tempPath("smoothcubic.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><path d="M0,0 C1,4 3,4 4,0 S7,-4 8,0 L8,-6 L0,-6 Z"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_GT(e.bodies[0].section->Area(), 0.0);
@@ -313,7 +313,7 @@ TEST(SvgImport, SmoothCubicCommandFollowsCubic) {
 TEST(SvgImport, SmoothQuadraticCommandFollowsQuadratic) {
     const auto path = tempPath("smoothquad.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><path d="M0,0 Q2,4 4,0 T8,0 L8,-4 L0,-4 Z"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_GT(e.bodies[0].section->Area(), 0.0);
@@ -323,7 +323,7 @@ TEST(SvgImport, SmoothQuadraticCommandFollowsQuadratic) {
 TEST(SvgImport, EllipticalArcCommand) {
     const auto path = tempPath("arc.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><path d="M0,0 A5,5 0 0,1 10,0 L10,-10 L0,-10 Z"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_GT(e.bodies[0].section->Area(), 0.0);
@@ -333,7 +333,7 @@ TEST(SvgImport, EllipticalArcCommand) {
 TEST(SvgImport, PolygonPointsAttribute) {
     const auto path = tempPath("polygon.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><polygon points="0,0 4,0 4,3 0,3"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6);
     std::filesystem::remove(path);
@@ -342,7 +342,7 @@ TEST(SvgImport, PolygonPointsAttribute) {
 TEST(SvgImport, PolylinePointsAttribute) {
     const auto path = tempPath("polyline.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><polyline points="0,0 4,0 4,3 0,3"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6);
     std::filesystem::remove(path);
@@ -351,7 +351,7 @@ TEST(SvgImport, PolylinePointsAttribute) {
 TEST(SvgImport, StrayCharacterInPointsListIsSkipped) {
     const auto path = tempPath("straypoints.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><polygon points="0,0 x 4,0 4,3 0,3"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6);
     std::filesystem::remove(path);
@@ -360,7 +360,7 @@ TEST(SvgImport, StrayCharacterInPointsListIsSkipped) {
 TEST(SvgImport, StrayCharacterInPathDataIsSkipped) {
     const auto path = tempPath("straypath.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><path d="M0,0 L4,0 @ L4,3 L0,3 Z"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6);
     std::filesystem::remove(path);
@@ -374,7 +374,7 @@ TEST(SvgImport, TransformNumberWithExponentIsParsed) {
     writeFile(path, R"svg(<svg xmlns="http://www.w3.org/2000/svg">
         <g transform="translate(1e1,0)"><rect x="0" y="0" width="4" height="3"/></g>
     </svg>)svg");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_TRUE(e.bodies[0].section.has_value());
     manifold::Rect bounds = e.bodies[0].section->Bounds();
     EXPECT_NEAR(bounds.min.x, 10.0, 1e-6);
@@ -386,7 +386,7 @@ TEST(SvgImport, PathNumberWithExponentIsParsed) {
     // path `d` attribute rather than a transform argument list.
     const auto path = tempPath("exponent_path.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><path d="M0,0 L4e0,0 L4,3 L0,3 Z"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 12.0, 1e-6);
     std::filesystem::remove(path);
@@ -400,7 +400,7 @@ TEST(SvgImport, EllipticalArcWithOutOfRangeRadiiIsScaledUp) {
     // never hit this path.
     const auto path = tempPath("arc_scaled.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><path d="M0,0 A1,1 0 0,1 10,0 L10,-10 L0,-10 Z"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_GT(e.bodies[0].section->Area(), 0.0);
@@ -413,7 +413,7 @@ TEST(SvgImport, MultipleSubpathsInOnePathProduceMultipleContours) {
     // starting a new one, distinct from an explicit `Z`.
     const auto path = tempPath("multisubpath.svg");
     writeFile(path, R"(<svg xmlns="http://www.w3.org/2000/svg"><path d="M0,0 L4,0 L4,3 L0,3 Z M10,0 L14,0 L14,3 L10,3 Z"/></svg>)");
-    Evaluated e = evalSrc("import(\"" + path.string() + "\");");
+    Evaluated e = evalSrc("import(\"" + path.generic_string() + "\");");
     ASSERT_EQ(e.bodies.size(), 1u);
     ASSERT_TRUE(e.bodies[0].section.has_value());
     EXPECT_NEAR(e.bodies[0].section->Area(), 24.0, 1e-6); // two disjoint 4x3 squares