openscad-cpp-evaluator 0.27.0__tar.gz → 0.28.0__tar.gz

{openscad_cpp_evaluator-0.27.0 → openscad_cpp_evaluator-0.28.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.27.0 → openscad_cpp_evaluator-0.28.0}/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.0 → openscad_cpp_evaluator-0.28.0}/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.0 → openscad_cpp_evaluator-0.28.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -225,7 +225,8 @@ public:
     // attributes there).
     // Give cached bodies fresh originalIDs so a second call site reusing
     // them is not confused with the first. See its definition.
-    void restampCachedIds(std::vector<ColoredBody>& bodies);
+    void restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node,
+                          const oscad::ASTNode* producer);
 
     std::unordered_map<uint32_t, const oscad::ASTNode*> idToNode;
     std::unordered_map<uint32_t, std::optional<std::array<float, 4>>> idToColor;
@@ -1701,6 +1702,13 @@ private:
     EchoFn echoFn_;
     std::shared_ptr<FontProvider> fontProvider_; // null until first fontProvider() call if not injected
     std::shared_ptr<ManifoldCache> manifoldCache_; // opt-in, see the constructor's own doc comment
+
+    // Cache key -> the AST node whose generation filled that entry, for
+    // this render only (cleared alongside idToNode, whose pointers share
+    // the same lifetime). restampCachedIds() uses it to tell a cached ID
+    // that stands for the reused node itself from one that stands for a
+    // node deeper inside it; see there.
+    std::unordered_map<std::string, const oscad::ASTNode*> cacheProducer_;
     std::uint64_t randsCallCount_ = 0; // see noteRandsCall()
 
     // -- Debugging (Phase 9) --------------------------------------------

{openscad_cpp_evaluator-0.27.0 → openscad_cpp_evaluator-0.28.0}/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.0 → openscad_cpp_evaluator-0.28.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.27.0 → openscad_cpp_evaluator-0.28.0}/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.0 → openscad_cpp_evaluator-0.28.0}/src/csg_generate.cpp

@@ -48,7 +48,11 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
         std::optional<std::vector<ColoredBody>> cached = key ? manifoldCache_->get(*key) : std::nullopt;
         if (cached) {
             node.bodies = std::move(*cached);
-            restampCachedIds(node.bodies);
+            if (node.node) {
+                auto producer = cacheProducer_.find(*key);
+                restampCachedIds(node.bodies, *node.node,
+                                 producer == cacheProducer_.end() ? nullptr : producer->second);
+            }
         } else {
             // Recurse into children first (bottom-up) -- populates each
             // child's own .bodies in place so flattenCsgTree/a GenerateFn
@@ -76,7 +80,10 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
                 // Mirrors generate_tree()'s own fallback.
                 node.bodies = flattenCsgTree(node.children);
             }
-            if (key) manifoldCache_->put(*key, node.bodies);
+            if (key) {
+                manifoldCache_->put(*key, node.bodies);
+                cacheProducer_[*key] = node.node;
+            }
         }
         for (const ColoredBody& b : node.bodies) topLevelBodies.push_back(b);
     }
@@ -105,7 +112,8 @@ std::vector<ColoredBody> Evaluator::generatePartialTree() {
     return generateTreeImpl(flat);
 }
 
-void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies) {
+void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::ASTNode& node,
+                                 const oscad::ASTNode* producer) {
     // A cache hit hands back the geometry AND the originalIDs of whichever
     // call site first produced it. Those IDs are provenance -- "which node
     // made this" -- not content, so two identical shapes at two call sites
@@ -113,8 +121,25 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies) {
     //
     // Each distinct run gets a fresh ID, one per run rather than one per
     // body, so a cached subtree made of several parts stays selectable
-    // part by part. Each new ID inherits the old one's node and color, so
-    // the parts keep pointing at the AST nodes that really produced them.
+    // part by part. Which node a fresh ID points at depends on what the old
+    // one stood for:
+    //
+    //   - the reused node itself (`producer`): two separate pieces of
+    //     source wrote the same shape, so this copy belongs to the node
+    //     reusing it, not the one that happened to be generated first.
+    //   - something deeper inside it -- the cube and sphere inside a module
+    //     called twice: both calls really do come from that one line of the
+    //     module body, so the old node is the honest answer and re-pointing
+    //     it at the call site would collapse every part of the call onto a
+    //     single line.
+    //
+    // Across renders the old IDs predate this render's idToNode, so nothing
+    // is known about their structure and everything falls to `node`.
+    //
+    // ponytail: two subtrees identical down to their transforms still
+    // share one attribution, since only the inner node is a cache hit and
+    // its producer check keeps the first copy's descendants. They occupy
+    // the same space, so there is nothing to select apart.
     for (ColoredBody& cb : bodies) {
         if (!cb.body || cb.body->IsEmpty()) continue;
         manifold::MeshGL mesh = cb.body->GetMeshGL();
@@ -124,8 +149,9 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies) {
             auto found = remap.find(id);
             if (found == remap.end()) {
                 const uint32_t fresh = manifold::Manifold::ReserveIDs(1);
-                auto node = idToNode.find(id);
-                if (node != idToNode.end()) idToNode[fresh] = node->second;
+                auto old = idToNode.find(id);
+                idToNode[fresh] =
+                    (old != idToNode.end() && old->second != producer) ? old->second : &node;
                 auto color = idToColor.find(id);
                 if (color != idToColor.end()) idToColor[fresh] = color->second;
                 found = remap.emplace(id, fresh).first;

{openscad_cpp_evaluator-0.27.0 → openscad_cpp_evaluator-0.28.0}/src/csg_resolve.cpp

@@ -205,6 +205,7 @@ template <typename NodeList>
 std::vector<std::unique_ptr<CSGNode>> Evaluator::resolveTreeImpl(const NodeList& nodes, EvalContext& ctx) {
     idToNode.clear();
     idToColor.clear();
+    cacheProducer_.clear(); // holds AST pointers, same lifetime as idToNode's
     treeStack_.clear();
     treeStack_.emplace_back();
     rootCtx_ = &ctx;

{openscad_cpp_evaluator-0.27.0 → openscad_cpp_evaluator-0.28.0}/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.0 → openscad_cpp_evaluator-0.28.0}/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.0 → openscad_cpp_evaluator-0.28.0}/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.0 → openscad_cpp_evaluator-0.28.0}/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