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

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

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

{openscad_cpp_evaluator-1.4.1 → 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.1 → 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.1"
+version = "1.5.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.4.1 → 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.1 → 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.1 → 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.1 → 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");
+}