openscad-cpp-evaluator 1.4.0__tar.gz → 1.5.0__tar.gz

{openscad_cpp_evaluator-1.4.0 → openscad_cpp_evaluator-1.5.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.4.0 → openscad_cpp_evaluator-1.5.0}/external/openscad_cpp_parser/include/openscad_cpp_parser/api.hpp

@@ -48,6 +48,18 @@ std::unique_ptr<Scope> buildScopes(const std::vector<std::unique_ptr<ASTNode>>&
 // why this exists. Never takes ownership.
 std::unique_ptr<Scope> buildScopes(const std::vector<ASTNode*>& ast);
 
+// Same, but recording into a table the CALLER owns, and not attaching it to
+// the returned root.
+//
+// For a resolution that spans several files: `use <file>` builds a separate
+// root Scope per used file, but all of them are read back through one
+// evaluation, so their nodes' scopes have to land in ONE table. A per-root
+// table would leave the outer evaluation unable to see anything the nested
+// resolutions recorded -- every node of a used file would read back as
+// having no scope.
+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);
+
 // Parses `code`. Throws ParseError (with the full caret diagnostic) on a
 // syntax error.
 //

{openscad_cpp_evaluator-1.4.0 → openscad_cpp_evaluator-1.5.0}/external/openscad_cpp_parser/src/scope.cpp

@@ -8,26 +8,36 @@
 
 namespace oscad {
 
-std::unique_ptr<Scope> buildScopes(const std::vector<std::unique_ptr<ASTNode>>& ast) {
-    auto owned = std::make_unique<ScopeTable>();
-    ScopeTableScope recording(*owned);
+std::unique_ptr<Scope> buildScopesInto(const std::vector<std::unique_ptr<ASTNode>>& ast, ScopeTable& table) {
+    ScopeTableScope recording(table);
     auto root = std::make_unique<Scope>();
     collectHoistedDeclarations(ast, *root);
     for (auto& node : ast) {
         node->buildScope(*root);
     }
-    root->adoptTable(std::move(owned));
     return root;
 }
 
-std::unique_ptr<Scope> buildScopes(const std::vector<ASTNode*>& ast) {
+std::unique_ptr<Scope> buildScopes(const std::vector<std::unique_ptr<ASTNode>>& ast) {
     auto owned = std::make_unique<ScopeTable>();
-    ScopeTableScope recording(*owned);
+    auto root = buildScopesInto(ast, *owned);
+    root->adoptTable(std::move(owned));
+    return root;
+}
+
+std::unique_ptr<Scope> buildScopesInto(const std::vector<ASTNode*>& ast, ScopeTable& table) {
+    ScopeTableScope recording(table);
     auto root = std::make_unique<Scope>();
     collectHoistedDeclarations(ast, *root);
     for (ASTNode* node : ast) {
         node->buildScope(*root);
     }
+    return root;
+}
+
+std::unique_ptr<Scope> buildScopes(const std::vector<ASTNode*>& ast) {
+    auto owned = std::make_unique<ScopeTable>();
+    auto root = buildScopesInto(ast, *owned);
     root->adoptTable(std::move(owned));
     return root;
 }

{openscad_cpp_evaluator-1.4.0 → openscad_cpp_evaluator-1.5.0}/include/openscad_cpp_evaluator/utf8.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstdint>
 #include <string>
 #include <vector>
 
@@ -17,6 +18,11 @@ namespace oscadeval {
 // string that actually holds non-ASCII pays, and those are short in
 // practice.
 
+// One code point as UTF-8. The caller decides which code points are
+// legal -- chr() drops an invalid one, a \uXXXX escape substitutes a space
+// -- so this encodes whatever it is given.
+std::string utf8Encode(uint32_t cp);
+
 // True when every byte is < 0x80, so byte offsets and character offsets are
 // the same thing.
 bool utf8IsAscii(const std::string& s);

{openscad_cpp_evaluator-1.4.0 → openscad_cpp_evaluator-1.5.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.4.0 → openscad_cpp_evaluator-1.5.0}/src/builtins/function_builtins.cpp

@@ -193,29 +193,8 @@ double atan2Degrees(double y, double x) {
     return std::fabs(degs - whole) < 3.0E-14 ? whole : degs;
 }
 
-// UTF-8 encode/decode for chr()/ord() -- OpenSCAD strings are unicode text,
-// not byte arrays, so a codepoint above U+007F needs real multi-byte
-// handling, not a raw byte cast.
-std::string utf8Encode(uint32_t cp) {
-    std::string out;
-    if (cp <= 0x7F) {
-        out.push_back(static_cast<char>(cp));
-    } else if (cp <= 0x7FF) {
-        out.push_back(static_cast<char>(0xC0 | (cp >> 6)));
-        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
-    } else if (cp <= 0xFFFF) {
-        out.push_back(static_cast<char>(0xE0 | (cp >> 12)));
-        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
-        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
-    } else {
-        out.push_back(static_cast<char>(0xF0 | (cp >> 18)));
-        out.push_back(static_cast<char>(0x80 | ((cp >> 12) & 0x3F)));
-        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
-        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
-    }
-    return out;
-}
-
+// utf8Encode lives in utf8.cpp -- the string-literal escape decoder
+// (\uXXXX) needs it too.
 uint32_t utf8DecodeFirst(const std::string& s) {
     if (s.empty()) return 0;
     const auto b = [&](size_t i) { return static_cast<unsigned char>(s[i]); };

{openscad_cpp_evaluator-1.4.0 → openscad_cpp_evaluator-1.5.0}/src/eval_use.cpp

@@ -17,8 +17,19 @@ ResolvedUseScopes resolveUseScopes(const std::vector<std::unique_ptr<oscad::ASTN
     return resolveUseScopes(borrowed, currentFile, logFn);
 }
 
-ResolvedUseScopes resolveUseScopes(const std::vector<const oscad::ASTNode*>& ownNodes,
-                                    const std::string& currentFile, const std::function<void(const std::string&)>& logFn) {
+namespace {
+
+// The recursion. `table` is threaded through every level rather than each
+// level building its own: `use <file>` gives each used file its own root
+// Scope, but one evaluation reads all of them back, so every node's scope
+// has to land in ONE table. A table per level meant the outer evaluation
+// could not see anything a nested resolution recorded -- every node of a
+// used file read back as having no scope, and `use` silently resolved to
+// undef. BelfrySCAD's own suite caught that; this repo's did not.
+ResolvedUseScopes resolveUseScopesInto(const std::vector<const oscad::ASTNode*>& ownNodes,
+                                        const std::string& currentFile,
+                                        const std::function<void(const std::string&)>& logFn,
+                                        oscad::ScopeTable& table) {
     ResolvedUseScopes result;
 
     std::vector<const oscad::ASTNode*> injected;
@@ -56,7 +67,10 @@ ResolvedUseScopes resolveUseScopes(const std::vector<const oscad::ASTNode*>& own
         result.usedFileAsts.push_back(std::move(lib.ast));
         const std::vector<std::unique_ptr<oscad::ASTNode>>& libAst = result.usedFileAsts.back();
 
-        ResolvedUseScopes nested = resolveUseScopes(libAst, lib.resolvedPath, logFn);
+        std::vector<const oscad::ASTNode*> libBorrowed;
+        libBorrowed.reserve(libAst.size());
+        for (const auto& n : libAst) libBorrowed.push_back(n.get());
+        ResolvedUseScopes nested = resolveUseScopesInto(libBorrowed, lib.resolvedPath, logFn, table);
 
         std::vector<const oscad::ASTNode*> libInjected;
         for (const oscad::ASTNode* n : nested.ownNodesFiltered) {
@@ -92,12 +106,11 @@ ResolvedUseScopes resolveUseScopes(const std::vector<const oscad::ASTNode*>& own
     std::vector<oscad::ASTNode*> mutableProcessed;
     mutableProcessed.reserve(result.processedNodes.size());
     for (const oscad::ASTNode* n : result.processedNodes) mutableProcessed.push_back(const_cast<oscad::ASTNode*>(n));
-    result.rootScope = oscad::buildScopes(mutableProcessed);
+    result.rootScope = oscad::buildScopesInto(mutableProcessed, table);
 
     {
-        // Re-anchoring writes scopes too, into the same table buildScopes()
-        // just filled -- which the root scope now owns.
-        oscad::ScopeTableScope recording(*const_cast<oscad::ScopeTable*>(result.rootScope->table()));
+        // Re-anchoring writes scopes too, into the same shared table.
+        oscad::ScopeTableScope recording(table);
         for (const auto& [libInjected, libRootScope] : reanchor) {
             for (const oscad::ASTNode* n : libInjected) const_cast<oscad::ASTNode*>(n)->buildScope(*libRootScope);
         }
@@ -106,4 +119,16 @@ ResolvedUseScopes resolveUseScopes(const std::vector<const oscad::ASTNode*>& own
     return result;
 }
 
+} // namespace
+
+ResolvedUseScopes resolveUseScopes(const std::vector<const oscad::ASTNode*>& ownNodes, const std::string& currentFile,
+                                    const std::function<void(const std::string&)>& logFn) {
+    // One table for the whole resolution, handed to the root scope at the
+    // end so it lives exactly as long as the scopes it points into.
+    auto table = std::make_unique<oscad::ScopeTable>();
+    ResolvedUseScopes result = resolveUseScopesInto(ownNodes, currentFile, logFn, *table);
+    if (result.rootScope) result.rootScope->adoptTable(std::move(table));
+    return result;
+}
+
 } // namespace oscadeval

{openscad_cpp_evaluator-1.4.0 → openscad_cpp_evaluator-1.5.0}/src/utf8.cpp

@@ -17,6 +17,26 @@ size_t nextCharStart(const std::string& s, size_t i) {
 
 } // namespace
 
+std::string utf8Encode(uint32_t cp) {
+    std::string out;
+    if (cp <= 0x7F) {
+        out.push_back(static_cast<char>(cp));
+    } else if (cp <= 0x7FF) {
+        out.push_back(static_cast<char>(0xC0 | (cp >> 6)));
+        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
+    } else if (cp <= 0xFFFF) {
+        out.push_back(static_cast<char>(0xE0 | (cp >> 12)));
+        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
+        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
+    } else {
+        out.push_back(static_cast<char>(0xF0 | (cp >> 18)));
+        out.push_back(static_cast<char>(0x80 | ((cp >> 12) & 0x3F)));
+        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
+        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
+    }
+    return out;
+}
+
 bool utf8IsAscii(const std::string& s) {
     for (char c : s) {
         if (static_cast<unsigned char>(c) >= 0x80) return false;

{openscad_cpp_evaluator-1.4.0 → openscad_cpp_evaluator-1.5.0}/src/value.cpp

@@ -374,17 +374,60 @@ Value matmul(const Value& a, const Value& b, std::string* error) {
                             " and " + oscTypeName(e2));
 }
 
+namespace {
+
+// `count` hex digits starting at `at`, into `out`. False (leaving `out`
+// untouched) if any of them is not a hex digit.
+bool hexDigits(const std::string& s, size_t at, size_t count, std::uint32_t& out) {
+    std::uint32_t v = 0;
+    for (size_t k = 0; k < count; ++k) {
+        const char c = s[at + k];
+        std::uint32_t d;
+        if (c >= '0' && c <= '9') d = static_cast<std::uint32_t>(c - '0');
+        else if (c >= 'a' && c <= 'f') d = static_cast<std::uint32_t>(c - 'a' + 10);
+        else if (c >= 'A' && c <= 'F') d = static_cast<std::uint32_t>(c - 'A' + 10);
+        else return false;
+        v = (v << 4) | d;
+    }
+    out = v;
+    return true;
+}
+
+// What a well-formed \x/\u escape contributes. A code point that cannot
+// be encoded -- zero, or a lone surrogate -- becomes a SPACE rather than
+// nothing or invalid UTF-8. That is the reference's behaviour, checked by
+// equality since the bytes are hard to see: "\u0000" == " ", "\ud83d" ==
+// " ", and "\x00" == "\u0000", all true on 2026.02.01. Note chr() does
+// NOT agree -- chr(55357) is the empty string -- so the two paths differ
+// deliberately.
+std::string encodeEscapedCodePoint(std::uint32_t cp) {
+    if (cp == 0 || (cp >= 0xD800u && cp <= 0xDFFFu) || cp > 0x10FFFFu) return " ";
+    return utf8Encode(cp);
+}
+
+} // namespace
+
 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('\\');
+    // Most strings need no work at all, and this runs on every evaluation
+    // of a literal on the tree-walking path -- so don't build a second copy
+    // unless there is something to change. A bare newline counts as
+    // something to change (see the loop), so it has to open the scan too.
+    const size_t first = raw.find_first_of("\\\n");
     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) {
+        // A raw LF inside a string literal contributes NOTHING -- writing a
+        // string across two source lines joins them, keeping the second
+        // line's indentation:
+        //     s = "abcd
+        //         efgh";      // -> "abcd    efgh", 12 characters
+        // A raw CR is not special and stands for itself, so a CRLF file
+        // leaves the CR behind (len 3 for "x<CR><LF>y"). Both verified on
+        // 2026.02.01.
+        if (raw[i] == '\n') continue;
         if (raw[i] != '\\' || i + 1 >= raw.size()) {
             out.push_back(raw[i]);  // a trailing lone backslash stands for itself
             continue;
@@ -394,10 +437,44 @@ std::string unescapeStringLiteral(const std::string& raw) {
             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 'x': {
+                // \xNN, exactly two hex digits, and ASCII ONLY. The
+                // reference rejects anything above 0x7F -- a raw high byte
+                // would not be valid UTF-8, and the rest of the string is
+                // -- leaving the text to stand for itself: "\xff" is the
+                // three characters x, f, f. Verified against 2026.02.01,
+                // which takes \x00..\x7f and refuses \x80..\xff.
+                std::uint32_t cp = 0;
+                if (i + 3 < raw.size() && hexDigits(raw, i + 2, 2, cp) && cp <= 0x7Fu) {
+                    out += encodeEscapedCodePoint(cp);
+                    i += 3;
+                    break;
+                }
+                out.push_back(next);
+                ++i;
+                break;
+            }
+            case 'u': {
+                // \uXXXX, exactly four hex digits. No \u{...} form: the
+                // reference calls that an undefined escape.
+                std::uint32_t cp = 0;
+                if (i + 5 < raw.size() && hexDigits(raw, i + 2, 4, cp)) {
+                    out += encodeEscapedCodePoint(cp);
+                    i += 5;
+                    break;
+                }
+                out.push_back(next);
+                ++i;
+                break;
+            }
+            case '\n': ++i; break;  // backslash + LF: both go
             case '\r':
-                // Only a CRLF pair is a line continuation; a lone CR is an
-                // ordinary escaped character like any other.
+                // A backslash before CRLF takes the whole line ending.
+                // Deliberately unlike the reference, which treats the
+                // backslash as an undefined escape and keeps the CR --
+                // leaving a stray control character in any string wrapped
+                // in a file written on Windows. See this suite's
+                // BackslashNewlineContributesNothing.
                 if (i + 2 < raw.size() && raw[i + 2] == '\n') { i += 2; break; }
                 out.push_back('\r');
                 ++i;

{openscad_cpp_evaluator-1.4.0 → openscad_cpp_evaluator-1.5.0}/tests/test_include_cache.cpp

@@ -130,3 +130,32 @@ TEST(IncludeCache, ADerivedContextKeepsTheScopeTable) {
     ev.evaluate(used.processedNodes, ctx, {}, /*generate=*/false);
     for (const std::string& m : logs) EXPECT_EQ(m.find("Recursion"), std::string::npos) << m;
 }
+
+
+TEST(IncludeCache, NestedUseKeepsItsScopesInTheSharedTable) {
+    // `use <file>` gives each used file its own root Scope, and a used file
+    // may itself `use` another. All of them are read back by ONE
+    // evaluation, so every node's scope has to land in ONE ScopeTable.
+    //
+    // The version of this that built a table per recursion level threw the
+    // nested ones away: the outer evaluation then saw no scope at all for a
+    // used file's nodes, and combo() below resolved to undef instead of
+    // 107. Every C++ test here passed anyway -- BelfrySCAD's suite is what
+    // caught it -- so this is that case, kept where the code lives.
+    writeFile("inner.scad", "inner_val = 100;\nfunction get_inner() = inner_val;\n");
+    writeFile("lib2.scad",
+              "use <oscad_inccache_inner.scad>\n"
+              "lib2_val = 7;\n"
+              "function combo() = get_inner() + lib2_val;\n");
+    const auto main2 = writeFile("main2.scad",
+                                  "use <oscad_inccache_lib2.scad>\n"
+                                  "echo(combo());\n"
+                                  "echo(is_undef(inner_val));\n");
+
+    const std::vector<std::string> echoes = echoesOf(main2);
+    ASSERT_EQ(echoes.size(), 2u);
+    // combo() reaches through lib2's own nested use into inner.scad.
+    EXPECT_EQ(echoes[0], "ECHO: 107");
+    // ...while inner.scad's own declarations stay invisible to main2.
+    EXPECT_EQ(echoes[1], "ECHO: true");
+}

{openscad_cpp_evaluator-1.4.0 → openscad_cpp_evaluator-1.5.0}/tests/test_value.cpp

@@ -496,3 +496,109 @@ TEST(StringEscapes, BothEvaluationPathsCookTheLiteral) {
     ASSERT_EQ(echoed.size(), 1u);
     EXPECT_EQ(echoed[0], "ECHO: 3") << "line continuation, compiled path";
 }
+
+// Every expectation below was read off OpenSCAD 2026.02.01 rather than a
+// spec, because the rules are narrow and not guessable:
+//
+//   \xNN     two hex digits, ASCII ONLY -- \x80..\xff are REFUSED, since a
+//            raw high byte is not valid UTF-8 and the rest of the string is
+//   \uXXXX   exactly four hex digits; there is no \u{...} form
+//   an unencodable code point (zero, or a lone surrogate) becomes a SPACE
+//   anything else after a backslash is an "undefined escape": the
+//   backslash is dropped and the rest stands for itself
+//
+// The reference also emits "WARNING: Undefined escape sequence" for that
+// last case, at PARSE time (once per literal, not once per evaluation --
+// checked with a literal inside a for loop). This port has no parse-time
+// warning channel, so it produces the same STRING without the warning.
+TEST(StringEscapes, DecodesFourDigitUnicodeEscapes) {
+    EXPECT_EQ(unescapeStringLiteral("\\u03a9"), "Ω");   // len() of this is 1, not 5
+    EXPECT_EQ(unescapeStringLiteral("a\\u03a9b"), "aΩb");
+    EXPECT_EQ(unescapeStringLiteral("\\u0041"), "A");
+    EXPECT_EQ(unescapeStringLiteral("\\u00a9"), "©");
+    EXPECT_EQ(unescapeStringLiteral("\\uffff"), "￿");
+    EXPECT_EQ(unescapeStringLiteral("\\uFFFF"), "￿");   // hex digits are case-insensitive
+}
+
+TEST(StringEscapes, DecodesAsciiHexEscapesOnly) {
+    EXPECT_EQ(unescapeStringLiteral("\\x41"), "A");
+    EXPECT_EQ(unescapeStringLiteral("\\x7e"), "~");
+    EXPECT_EQ(unescapeStringLiteral("\\x7f"), "\x7f");
+    // Above 0x7F the reference refuses and the text stands for itself.
+    EXPECT_EQ(unescapeStringLiteral("\\x80"), "x80");
+    EXPECT_EQ(unescapeStringLiteral("\\xa9"), "xa9");
+    EXPECT_EQ(unescapeStringLiteral("\\xff"), "xff");
+}
+
+TEST(StringEscapes, AnUnencodableCodePointBecomesASpace) {
+    // Confirmed by equality on the reference, since the bytes are hard to
+    // read back: "" == " ", "\ud83d" == " " and "\x00" == ""
+    // are all true there. chr() does NOT agree -- chr(55357) is the empty
+    // string -- so the two paths differ deliberately.
+    EXPECT_EQ(unescapeStringLiteral("\\u0000"), " ");
+    EXPECT_EQ(unescapeStringLiteral("\\x00"), " ");
+    EXPECT_EQ(unescapeStringLiteral("\\ud83d"), " ");   // lone high surrogate
+    EXPECT_EQ(unescapeStringLiteral("\\udfff"), " ");   // lone low surrogate
+}
+
+TEST(StringEscapes, AnUndefinedEscapeDropsOnlyItsBackslash) {
+    EXPECT_EQ(unescapeStringLiteral("\\q"), "q");
+    EXPECT_EQ(unescapeStringLiteral("\\u12"), "u12");       // too few digits
+    EXPECT_EQ(unescapeStringLiteral("\\uZZZZ"), "uZZZZ");   // not hex
+    EXPECT_EQ(unescapeStringLiteral("\\u{41}"), "u{41}");   // no brace form
+    EXPECT_EQ(unescapeStringLiteral("\\x4"), "x4");
+    EXPECT_EQ(unescapeStringLiteral("\\xg1"), "xg1");
+}
+
+TEST(StringEscapes, LeavesTheAlreadyHandledEscapesAlone) {
+    EXPECT_EQ(unescapeStringLiteral("\\n"), "\n");
+    EXPECT_EQ(unescapeStringLiteral("\\t"), "\t");
+    EXPECT_EQ(unescapeStringLiteral("\\r"), "\r");
+    EXPECT_EQ(unescapeStringLiteral("\\\\"), "\\");
+    EXPECT_EQ(unescapeStringLiteral("\\\""), "\"");
+    EXPECT_EQ(unescapeStringLiteral("plain"), "plain");
+}
+
+TEST(StringEscapes, ATruncatedEscapeDoesNotReadPastTheEnd) {
+    // \u and \x look ahead four and two characters; one cut short at the
+    // end of the literal must stop rather than run off the buffer.
+    EXPECT_EQ(unescapeStringLiteral("\\u"), "u");
+    EXPECT_EQ(unescapeStringLiteral("\\u0"), "u0");
+    EXPECT_EQ(unescapeStringLiteral("\\u03a"), "u03a");
+    EXPECT_EQ(unescapeStringLiteral("\\x"), "x");
+    EXPECT_EQ(unescapeStringLiteral("\\x4"), "x4");
+    EXPECT_EQ(unescapeStringLiteral("\\"), "\\");
+}
+
+TEST(StringEscapes, ARawNewlineInsideALiteralContributesNothing) {
+    // Writing a string across two source lines joins them, keeping the
+    // second line's indentation -- this is how OpenSCAD lets a long string
+    // be wrapped, and it is NOT a backslash continuation.
+    //
+    //     s = "abcd
+    //         efgh";       // -> "abcd    efgh", 12 characters
+    EXPECT_EQ(unescapeStringLiteral("abcd\n    efgh"), "abcd    efgh");
+    EXPECT_EQ(unescapeStringLiteral("x\ny"), "xy");
+    EXPECT_EQ(unescapeStringLiteral("x\n\ny"), "xy");
+    EXPECT_EQ(unescapeStringLiteral("x\n  \n  y"), "x    y");
+}
+
+TEST(StringEscapes, ARawCarriageReturnStandsForItself) {
+    // Only the LF is special. A CRLF file therefore leaves the CR in the
+    // string: "x<CR><LF>y" is three characters, not two.
+    EXPECT_EQ(unescapeStringLiteral("x\ry"), "x\ry");
+    EXPECT_EQ(unescapeStringLiteral("x\r\ny"), "x\ry");
+}
+
+TEST(StringEscapes, ABackslashBeforeANewlineTakesTheWholeLineEnding) {
+    // The reference has no line-continuation escape at all: it calls the
+    // backslash an undefined escape, drops only it, then applies the
+    // ordinary newline rules -- so "x\\<CR><LF>y" is 3 characters there,
+    // the CR surviving. This port takes the whole line ending instead, on
+    // purpose, so a string wrapped in a Windows-line-ending file does not
+    // pick up a stray CR. Same reasoning as
+    // BackslashNewlineContributesNothing above.
+    EXPECT_EQ(unescapeStringLiteral("x\\\ny"), "xy");
+    EXPECT_EQ(unescapeStringLiteral("x\\\r\ny"), "xy");   // reference keeps the CR
+    EXPECT_EQ(unescapeStringLiteral("x\\\ry"), "x\ry");
+}