openscad-cpp-evaluator 1.2.0__tar.gz → 1.3.1__tar.gz

{openscad_cpp_evaluator-1.2.0 → openscad_cpp_evaluator-1.3.1}/PKG-INFO

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

openscad_cpp_evaluator-1.3.1/include/openscad_cpp_evaluator/format_closure.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+
+namespace oscad {
+class FunctionLiteral;
+}
+
+namespace oscadeval {
+
+// A function literal spelled the way the reference spells it when a script
+// does `str(f)` or `echo(f)`: its own source, re-printed from the AST with
+// every binary operator and ternary parenthesised.
+//
+// Deliberately not the parser's ASTNode::toString(), which is
+// precedence-minimal and which 94 places inside the parser depend on. See
+// format_closure.cpp for where each rule came from.
+std::string formatFunctionLiteral(const oscad::FunctionLiteral& fn);
+
+} // namespace oscadeval

openscad_cpp_evaluator-1.3.1/include/openscad_cpp_evaluator/osc_range.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <cmath>
+
+namespace oscadeval {
+
+// `[start:step:end]` -- a plain 3-slot struct, not an expanded list. Mirrors
+// the Python reference's OscRange object exactly: echoed as
+// "[start : step : end]", only expanded to a list when iterated (for/list
+// comprehension/intersection_for).
+struct OscRange {
+    double start = 0.0;
+    double step = 1.0;
+    double end = 0.0;
+
+    // Yields nothing: a zero step, a direction that disagrees with the
+    // bounds, or a NaN anywhere in it.
+    bool isEmpty() const {
+        if (std::isnan(start) || std::isnan(step) || std::isnan(end)) return true;
+        if (step == 0.0) return true;
+        return (end - start) / step < -1e-10;
+    }
+
+    // Two EMPTY ranges are equal whatever their bounds -- the reference
+    // compares element counts first, so `[5:1:0] == [10:1:0]` is true, and
+    // so is `[0:nan:inf] == [5:1:0]`. Only if both yield something does it
+    // compare start/step/end.
+    //
+    // This is not a NaN rule, though a NaN range is caught by it: checked
+    // against the reference, `nan == nan` is false and `[nan] == [nan]` is
+    // false, so nothing else treats NaN as equal to itself. Ranges are
+    // special because emptiness is.
+    //
+    // It matters well beyond range comparison: BOSL2 defines
+    // `is_nan(x) = (x != x)`, so a self-unequal range made typeof() answer
+    // "nan" for one, where the reference says "invalid".
+    friend bool operator==(const OscRange& a, const OscRange& b) {
+        const bool ae = a.isEmpty(), be = b.isEmpty();
+        if (ae || be) return ae && be;
+        return a.start == b.start && a.step == b.step && a.end == b.end;
+    }
+};
+
+} // namespace oscadeval

openscad_cpp_evaluator-1.3.1/include/openscad_cpp_evaluator/utf8.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace oscadeval {
+
+// A string is a sequence of CHARACTERS to a script, not of bytes. The
+// reference reports len("aé—z") as 4, indexes s[1] to "é", and iterates the
+// same four characters -- while a std::string holds 8 bytes for that. These
+// three are what keeps the two views apart.
+//
+// Storage stays UTF-8. Indexing therefore scans, which is O(n) per index and
+// so O(n^2) over a loop -- BOSL2's _str_count_leading is exactly that loop.
+// The saving grace is that a pure-ASCII string needs no scan at all: byte i
+// IS character i, and every function here takes that path first. Only a
+// string that actually holds non-ASCII pays, and those are short in
+// practice.
+
+// True when every byte is < 0x80, so byte offsets and character offsets are
+// the same thing.
+bool utf8IsAscii(const std::string& s);
+
+// Characters, not bytes. Counts lead bytes, so a malformed sequence counts
+// the same way the reference's own decoder would rather than throwing.
+size_t utf8Length(const std::string& s);
+
+// The i-th character as its own string; empty if i is past the end. Empty is
+// distinguishable from a real result because a character is never zero-length.
+std::string utf8CharAt(const std::string& s, size_t i);
+
+// Every character as its own string.
+std::vector<std::string> utf8Chars(const std::string& s);
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.2.0 → openscad_cpp_evaluator-1.3.1}/pyproject.toml

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

{openscad_cpp_evaluator-1.2.0 → openscad_cpp_evaluator-1.3.1}/src/CMakeLists.txt

@@ -1,5 +1,7 @@
 add_library(openscad_cpp_evaluator STATIC
   value.cpp
+  utf8.cpp
+  format_closure.cpp
   eval_error.cpp
   eval_context.cpp
   expr_eval.cpp

{openscad_cpp_evaluator-1.2.0 → openscad_cpp_evaluator-1.3.1}/src/builtins/function_builtins.cpp

@@ -6,6 +6,7 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
 #include "openscad_cpp_evaluator/segments.hpp"
 #include "openscad_cpp_evaluator/text_metrics.hpp"
+#include "openscad_cpp_evaluator/utf8.hpp"
 
 #include "openscad_cpp_parser/ast/ast_node.hpp"
 
@@ -613,10 +614,24 @@ Value builtinRands(double minv, double maxv, double nArg, const Value& seedArg)
 // a sequence of characters -- a `search(["a"], "abc")` vector needle sees
 // that same string as an empty table, not as characters.
 Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position* pos) {
-    const Value matchArg = getArg(args, 0, "match", Value{});
-    const Value tableArg = getArg(args, 1, "vector", Value{});
-    const double nrRaw = toDoubleLenient(getArg(args, 2, "num_returns", Value{1.0}));
-    const double icRaw = toDoubleLenient(getArg(args, 3, "index_col", Value{0.0}));
+    // The reference's own documented parameter names. These used to be
+    // "match"/"vector"/"num_returns"/"index_col", which are not names
+    // OpenSCAD ever documented, so a script written against the manual --
+    // BOSL2's in_list(), which passes num_returns_per_match and
+    // index_col_num -- bound neither and silently got the defaults.
+    //
+    // Worth knowing, though deliberately NOT copied: the reference ignores
+    // these names altogether and binds search() purely by position.
+    // `search(zzz=m, qqq=t, www=1, eee=1)` returns the right answer there,
+    // while the correct names in the wrong order return the wrong one.
+    // CallArgs keeps positional and named arguments apart and does not
+    // record where a named one was written, so matching that would mean
+    // changing how every call collects its arguments -- for a quirk no
+    // script relies on deliberately.
+    const Value matchArg = getArg(args, 0, "match_value", Value{});
+    const Value tableArg = getArg(args, 1, "string_or_vector", Value{});
+    const double nrRaw = toDoubleLenient(getArg(args, 2, "num_returns_per_match", Value{1.0}));
+    const double icRaw = toDoubleLenient(getArg(args, 3, "index_col_num", Value{0.0}));
     // Both are `unsigned int` in the reference, so a negative argument wraps
     // to a huge positive rather than meaning "unlimited"/"column 0".
     const unsigned numReturns = static_cast<unsigned>(static_cast<long long>(nrRaw));
@@ -654,11 +669,17 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
     if (const std::string* needle = std::get_if<std::string>(&matchArg)) {
         std::vector<Value> out;
         if (const std::string* hay = std::get_if<std::string>(&tableArg)) {
-            for (size_t i = 0; i < needle->size(); ++i) {
+            // Both sides walked as CHARACTERS, and the indices reported are
+            // character indices. Comparing bytes made a multi-byte needle
+            // search once per byte -- search("é", "aé—z") answered [1, 2]
+            // where the reference answers [1].
+            const std::vector<std::string> needleChars = utf8Chars(*needle);
+            const std::vector<std::string> hayChars = utf8Chars(*hay);
+            for (size_t i = 0; i < needleChars.size(); ++i) {
                 unsigned matchCount = 0;
                 std::vector<Value> resultvec;
-                for (size_t j = 0; j < hay->size(); ++j) {
-                    if ((*needle)[i] != (*hay)[j]) continue;
+                for (size_t j = 0; j < hayChars.size(); ++j) {
+                    if (needleChars[i] != hayChars[j]) continue;
                     ++matchCount;
                     if (numReturns == 1) {
                         out.push_back(num(j));
@@ -675,7 +696,10 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
         // with more than index_col elements. A single bad entry aborts the
         // WHOLE call with an empty result, not just that row -- which is
         // why `search("a", ["a","b"])` is [] and not [0].
-        for (size_t i = 0; i < needle->size(); ++i) {
+        // Character-wise here too: a needle character is what gets looked
+        // up in each row, so a multi-byte one must not be split.
+        const std::vector<std::string> needleChars = utf8Chars(*needle);
+        for (size_t i = 0; i < needleChars.size(); ++i) {
             unsigned matchCount = 0;
             std::vector<Value> resultvec;
             for (size_t j = 0; j < table.size(); ++j) {
@@ -689,7 +713,10 @@ Value builtinSearch(const CallArgs& args, Evaluator& ev, const oscad::Position*
                 }
                 const std::string* entry = std::get_if<std::string>(&entryVec[indexCol]);
                 // A type mismatch just doesn't match, exactly as `==` would.
-                if (!entry || entry->empty() || (*entry)[0] != (*needle)[i]) continue;
+                // First CHARACTER of the entry against the needle character:
+                // comparing first bytes made "é" and any other character
+                // sharing a lead byte look equal.
+                if (!entry || entry->empty() || utf8CharAt(*entry, 0) != needleChars[i]) continue;
                 ++matchCount;
                 if (numReturns == 1) {
                     out.push_back(num(j));
@@ -1367,7 +1394,8 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
         case BuiltinFnId::Len: {
             const Value x = getArg(args, 0, "x", Value{});
             if (const ListPtr* l = std::get_if<ListPtr>(&x); l && *l) return Value{static_cast<double>((*l)->items.size())};
-            if (const std::string* s = std::get_if<std::string>(&x)) return Value{static_cast<double>(s->size())};
+            // Characters, not bytes: the reference reports len("aé—z") as 4.
+            if (const std::string* s = std::get_if<std::string>(&x)) return Value{static_cast<double>(utf8Length(*s))};
             if (const ObjectPtr* o = std::get_if<ObjectPtr>(&x); o && *o) return Value{static_cast<double>((*o)->items.size())};
             return Value{};
         }

{openscad_cpp_evaluator-1.2.0 → openscad_cpp_evaluator-1.3.1}/src/expr_eval.cpp

@@ -1,4 +1,5 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
+#include "openscad_cpp_evaluator/utf8.hpp"
 
 #include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/eval_error.hpp"
@@ -803,8 +804,13 @@ Value Evaluator::applyIndexAccess(const Value& obj, const Value& idx) {
     if (const std::string* s = std::get_if<std::string>(&obj)) {
         if (const double* d = std::get_if<double>(&idx)) {
             const int i = static_cast<int>(*d);
-            if (i < 0 || static_cast<size_t>(i) >= s->size()) return Value{};
-            return Value{std::string(1, (*s)[static_cast<size_t>(i)])};
+            if (i < 0) return Value{};
+            // The i-th CHARACTER. Taking byte i split a multi-byte one and
+            // handed back half of it, which then failed to decode at the
+            // boundary -- an error, not merely a wrong answer.
+            std::string ch = utf8CharAt(*s, static_cast<size_t>(i));
+            if (ch.empty()) return Value{};
+            return Value{std::move(ch)};
         }
         return Value{};
     }

openscad_cpp_evaluator-1.3.1/src/format_closure.cpp

@@ -0,0 +1,217 @@
+// Printing a function literal back out as source, the way the reference
+// spells it when you `str()` or `echo()` one.
+//
+// Neither existing printer would do. The parser's own ASTNode::toString()
+// is precedence-MINIMAL -- it drops any parenthesis the grammar does not
+// need -- and 94 places inside the parser depend on that spelling. The
+// reference is the opposite: it parenthesises every binary operator and
+// every ternary whether or not precedence requires it, so `f(a + b)` comes
+// back as `f((a + b))`.
+//
+// BOSL2's fnliterals tests compare these strings exactly (61 of them), so
+// this has to agree with the reference character for character. Every rule
+// below was read off the reference by echoing the shape and copying what it
+// printed -- see test_format_closure.cpp, which carries the same shapes as
+// cases.
+#include "openscad_cpp_evaluator/format_closure.hpp"
+
+#include <string>
+
+#include "openscad_cpp_parser/ast.hpp"
+
+namespace oscadeval {
+namespace {
+
+using oscad::ASTNode;
+using oscad::NodeKind;
+
+std::string fmt(const ASTNode& n);
+
+// `(a + b)`, always. The reference parenthesises a binary operator
+// unconditionally -- nesting one inside another gives `((a + b) + c)`, and
+// even a call argument gets them: `f((a + b))`.
+//
+// Templated on the node type rather than casting every operator to one of
+// them. The binary classes are generated by a single macro so they do share
+// a layout, but they are distinct types with no common binary base, and
+// casting a MultiplicationOp to an AdditionOp would be undefined however
+// reliably it happens to work.
+template <typename T>
+std::string binary(const ASTNode& n, const char* op) {
+    const auto& e = static_cast<const T&>(n);
+    return "(" + fmt(*e.left) + " " + op + " " + fmt(*e.right) + ")";
+}
+
+// `-x`, not `(-x)`. A unary operator is never parenthesised itself, though
+// its operand still follows the rules: `-(a + b)`.
+template <typename T>
+std::string unary(const ASTNode& n, const char* op) {
+    const auto& e = static_cast<const T&>(n);
+    return std::string(op) + fmt(*e.expr);
+}
+
+template <typename Seq>
+std::string join(const Seq& items, const char* sep) {
+    std::string out;
+    for (size_t i = 0; i < items.size(); ++i) {
+        if (i) out += sep;
+        out += fmt(*items[i]);
+    }
+    return out;
+}
+
+// A list-comprehension body is wrapped, on top of whatever the body itself
+// prints: `[for(i = [0 : a]) ((i + 1))]`, and `(i)` for a bare identifier.
+// A plain vector element is NOT wrapped -- `[1, (2 + 3), a]` -- so the
+// parentheses belong to for/if/each rather than to the vector.
+std::string wrapped(const ASTNode& n) { return "(" + fmt(n) + ")"; }
+
+std::string fmt(const ASTNode& n) {
+    switch (n.kind()) {
+    case NodeKind::Identifier:
+        return static_cast<const oscad::Identifier&>(n).name;
+    case NodeKind::StringLiteral:
+    case NodeKind::NumberLiteral:
+    case NodeKind::BooleanLiteral:
+    case NodeKind::UndefinedLiteral:
+        // The parser already spells these the way the reference does,
+        // escaping and number formatting included.
+        return n.toString();
+
+    case NodeKind::RangeLiteral: {
+        const auto& r = static_cast<const oscad::RangeLiteral&>(n);
+        // implicitStep, not just `step != nullptr`: the parser fills in a
+        // step of 1 for `[0:a]`, and printing it back gives `[0 : 1 : a]`
+        // where the reference says `[0 : a]`. The flag is there to tell the
+        // two apart.
+        std::string s = "[" + fmt(*r.start) + " : ";
+        if (r.step && !r.implicitStep) s += fmt(*r.step) + " : ";
+        return s + fmt(*r.end) + "]";
+    }
+
+    case NodeKind::UnaryMinusOp: return unary<oscad::UnaryMinusOp>(n, "-");
+    case NodeKind::LogicalNotOp: return unary<oscad::LogicalNotOp>(n, "!");
+    case NodeKind::BitwiseNotOp: return unary<oscad::BitwiseNotOp>(n, "~");
+
+    case NodeKind::AdditionOp:            return binary<oscad::AdditionOp>(n, "+");
+    case NodeKind::SubtractionOp:         return binary<oscad::SubtractionOp>(n, "-");
+    case NodeKind::MultiplicationOp:      return binary<oscad::MultiplicationOp>(n, "*");
+    case NodeKind::DivisionOp:            return binary<oscad::DivisionOp>(n, "/");
+    case NodeKind::ModuloOp:              return binary<oscad::ModuloOp>(n, "%");
+    case NodeKind::ExponentOp:            return binary<oscad::ExponentOp>(n, "^");
+    case NodeKind::BitwiseAndOp:          return binary<oscad::BitwiseAndOp>(n, "&");
+    case NodeKind::BitwiseOrOp:           return binary<oscad::BitwiseOrOp>(n, "|");
+    case NodeKind::BitwiseShiftLeftOp:    return binary<oscad::BitwiseShiftLeftOp>(n, "<<");
+    case NodeKind::BitwiseShiftRightOp:   return binary<oscad::BitwiseShiftRightOp>(n, ">>");
+    case NodeKind::LogicalAndOp:          return binary<oscad::LogicalAndOp>(n, "&&");
+    case NodeKind::LogicalOrOp:           return binary<oscad::LogicalOrOp>(n, "||");
+    case NodeKind::EqualityOp:            return binary<oscad::EqualityOp>(n, "==");
+    case NodeKind::InequalityOp:          return binary<oscad::InequalityOp>(n, "!=");
+    case NodeKind::GreaterThanOp:         return binary<oscad::GreaterThanOp>(n, ">");
+    case NodeKind::GreaterThanOrEqualOp:  return binary<oscad::GreaterThanOrEqualOp>(n, ">=");
+    case NodeKind::LessThanOp:            return binary<oscad::LessThanOp>(n, "<");
+    case NodeKind::LessThanOrEqualOp:     return binary<oscad::LessThanOrEqualOp>(n, "<=");
+
+    case NodeKind::TernaryOp: {
+        const auto& t = static_cast<const oscad::TernaryOp&>(n);
+        return "(" + fmt(*t.condition) + " ? " + fmt(*t.trueExpr) + " : " + fmt(*t.falseExpr) + ")";
+    }
+
+    case NodeKind::PrimaryCall: {
+        const auto& c = static_cast<const oscad::PrimaryCall&>(n);
+        return fmt(*c.left) + "(" + join(c.arguments, ", ") + ")";
+    }
+    case NodeKind::PrimaryIndex: {
+        const auto& i = static_cast<const oscad::PrimaryIndex&>(n);
+        return fmt(*i.left) + "[" + fmt(*i.index) + "]";
+    }
+    case NodeKind::PrimaryMember: {
+        const auto& m = static_cast<const oscad::PrimaryMember&>(n);
+        return fmt(*m.left) + "." + m.member->name;
+    }
+
+    case NodeKind::PositionalArgument:
+        return fmt(*static_cast<const oscad::PositionalArgument&>(n).expr);
+    case NodeKind::NamedArgument: {
+        const auto& a = static_cast<const oscad::NamedArgument&>(n);
+        return a.name->name + " = " + fmt(*a.expr);
+    }
+    case NodeKind::Assignment: {
+        const auto& a = static_cast<const oscad::Assignment&>(n);
+        return a.name->name + " = " + fmt(*a.expr);
+    }
+    case NodeKind::ParameterDeclaration: {
+        const auto& p = static_cast<const oscad::ParameterDeclaration&>(n);
+        return p.defaultValue ? p.name->name + " = " + fmt(*p.defaultValue) : p.name->name;
+    }
+
+    case NodeKind::FunctionLiteral: {
+        const auto& f = static_cast<const oscad::FunctionLiteral&>(n);
+        return "function(" + join(f.parameters, ", ") + ") " + fmt(*f.body);
+    }
+    case NodeKind::LetOp: {
+        const auto& l = static_cast<const oscad::LetOp&>(n);
+        // Body bare: `let(c = (a + b)) c`. What looks like a wrapped body
+        // in `let(a = 1) (a + x)` is the binary parenthesising itself.
+        return "let(" + join(l.assignments, ", ") + ") " + fmt(*l.body);
+    }
+    case NodeKind::EchoOp: {
+        const auto& e = static_cast<const oscad::EchoOp&>(n);
+        return "echo(" + join(e.arguments, ", ") + ") " + fmt(*e.body);
+    }
+    case NodeKind::AssertOp: {
+        const auto& a = static_cast<const oscad::AssertOp&>(n);
+        return "assert(" + join(a.arguments, ", ") + ") " + fmt(*a.body);
+    }
+
+    case NodeKind::ListComprehension: {
+        const auto& c = static_cast<const oscad::ListComprehension&>(n);
+        return "[" + join(c.elements, ", ") + "]";
+    }
+    case NodeKind::ListCompFor: {
+        const auto& f = static_cast<const oscad::ListCompFor&>(n);
+        return "for(" + join(f.assignments, ", ") + ") " + wrapped(*f.body);
+    }
+    case NodeKind::ListCompCFor: {
+        const auto& f = static_cast<const oscad::ListCompCFor&>(n);
+        // The odd one out: no space after the semicolons, and the body is
+        // NOT wrapped -- `[for(i = 0;(i < a);i = (i + 1)) i]`.
+        return "for(" + join(f.inits, ", ") + ";" + fmt(*f.condition) + ";" +
+               join(f.incrs, ", ") + ") " + fmt(*f.body);
+    }
+    case NodeKind::ListCompIf: {
+        const auto& i = static_cast<const oscad::ListCompIf&>(n);
+        return "if(" + fmt(*i.condition) + ") " + wrapped(*i.trueExpr);
+    }
+    case NodeKind::ListCompIfElse: {
+        const auto& i = static_cast<const oscad::ListCompIfElse&>(n);
+        return "if(" + fmt(*i.condition) + ") " + wrapped(*i.trueExpr) +
+               " else " + wrapped(*i.falseExpr);
+    }
+    case NodeKind::ListCompEach: {
+        const auto& e = static_cast<const oscad::ListCompEach&>(n);
+        return "each " + wrapped(*e.body);
+    }
+    case NodeKind::ListCompLet: {
+        const auto& l = static_cast<const oscad::ListCompLet&>(n);
+        return "let(" + join(l.assignments, ", ") + ") " + fmt(*l.body);
+    }
+
+    case NodeKind::CommentedExpr:
+        // Comments are not part of what the reference prints.
+        return fmt(*static_cast<const oscad::CommentedExpr&>(n).expr);
+
+    default:
+        // Anything not reachable from inside a function literal's body --
+        // statements, module instantiations, include directives. Falling
+        // back to the parser's own spelling is closer than an empty string,
+        // and the value here is diagnostic rather than compared.
+        return n.toString();
+    }
+}
+
+} // namespace
+
+std::string formatFunctionLiteral(const oscad::FunctionLiteral& fn) { return fmt(fn); }
+
+} // namespace oscadeval

openscad_cpp_evaluator-1.3.1/src/utf8.cpp

@@ -0,0 +1,61 @@
+#include "openscad_cpp_evaluator/utf8.hpp"
+
+namespace oscadeval {
+namespace {
+
+// A continuation byte is 0b10xxxxxx. Every other byte starts a character,
+// which is what makes counting and stepping possible without decoding.
+inline bool isContinuation(unsigned char c) { return (c & 0xC0) == 0x80; }
+
+// Past the end of the character starting at `i`. Advances at least one byte
+// even for a malformed sequence, so no caller can loop forever on bad input.
+size_t nextCharStart(const std::string& s, size_t i) {
+    ++i;
+    while (i < s.size() && isContinuation(static_cast<unsigned char>(s[i]))) ++i;
+    return i;
+}
+
+} // namespace
+
+bool utf8IsAscii(const std::string& s) {
+    for (char c : s) {
+        if (static_cast<unsigned char>(c) >= 0x80) return false;
+    }
+    return true;
+}
+
+size_t utf8Length(const std::string& s) {
+    if (utf8IsAscii(s)) return s.size();
+    size_t n = 0;
+    for (size_t i = 0; i < s.size(); i = nextCharStart(s, i)) ++n;
+    return n;
+}
+
+std::string utf8CharAt(const std::string& s, size_t i) {
+    if (utf8IsAscii(s)) return i < s.size() ? std::string(1, s[i]) : std::string{};
+    size_t at = 0;
+    for (size_t b = 0; b < s.size(); b = nextCharStart(s, b)) {
+        if (at++ == i) {
+            const size_t end = nextCharStart(s, b);
+            return s.substr(b, end - b);
+        }
+    }
+    return {};
+}
+
+std::vector<std::string> utf8Chars(const std::string& s) {
+    std::vector<std::string> out;
+    if (utf8IsAscii(s)) {
+        out.reserve(s.size());
+        for (char c : s) out.emplace_back(1, c);
+        return out;
+    }
+    for (size_t b = 0; b < s.size();) {
+        const size_t end = nextCharStart(s, b);
+        out.push_back(s.substr(b, end - b));
+        b = end;
+    }
+    return out;
+}
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.2.0 → openscad_cpp_evaluator-1.3.1}/src/value.cpp

@@ -1,5 +1,8 @@
 #include "openscad_cpp_evaluator/value.hpp"
 
+#include "openscad_cpp_evaluator/format_closure.hpp"
+#include "openscad_cpp_evaluator/utf8.hpp"
+
 #include <algorithm>
 #include <cmath>
 #include <limits>
@@ -475,7 +478,13 @@ std::string fmtValue(const Value& v) {
         return s + "}";
     }
     if (const std::string* s = std::get_if<std::string>(&v)) return "\"" + *s + "\"";
-    return "<function-literal>"; // OscRange handled above; ClosurePtr has no meaningful textual form either
+    if (const ClosurePtr* c = std::get_if<ClosurePtr>(&v)) {
+        // The reference prints a function literal as its own source. Falling
+        // back only when the closure has no node, which nothing constructs
+        // today but the field is a pointer.
+        if (*c && (*c)->node) return formatFunctionLiteral(*(*c)->node);
+    }
+    return "<function-literal>"; // OscRange handled above
 }
 
 // (Range::numValues()'s own count, closed-form) -- 1 + floor((end-start)/step),
@@ -484,10 +493,27 @@ std::string fmtValue(const Value& v) {
 // nullopt for a step of 0 or a direction that disagrees with start/end (a
 // naturally-empty range -- 0 elements, never "too many").
 std::optional<size_t> rangeElementCount(const OscRange& r) {
-    if (r.step == 0.0) return std::nullopt;
-    const double n = (r.end - r.start) / r.step;
-    if (n < -1e-10) return std::nullopt; // wrong direction -- naturally empty
-    return static_cast<size_t>(std::floor(n + 1e-10)) + 1;
+    // Zero step, wrong direction, or a NaN anywhere: nothing to iterate, and
+    // the reference says nothing about it -- `[for (i = [nan:1:-1]) i]` is
+    // [] with no warning there. BOSL2 reaches exactly that through
+    // list_rotate() on an empty list, where ((n % 0) + 0) % 0 is NaN.
+    if (r.isEmpty()) return std::nullopt;
+
+    const double count = std::floor((r.end - r.start) / r.step + 1e-10) + 1.0;
+
+    // Casting a double past size_t's range is undefined, and the platforms
+    // disagree about it in opposite directions: x86_64 wraps to 2^63 -- the
+    // "too many elements (9223372036854775809)" a CI run reported -- while
+    // arm64 produced something small enough that an INFINITE range iterated
+    // forever instead of being rejected. Neither is a wrong number so much
+    // as an unpredictable one.
+    //
+    // Clamp to what the reference reports for such a range, its own uint32
+    // ceiling: `[0:1:1/0]` warns "too many elements (4294967295)" there and
+    // yields [].
+    constexpr double kCap = 4294967295.0;
+    if (!(count < kCap)) return static_cast<size_t>(kCap);
+    return static_cast<size_t>(count);
 }
 
 IterableValues expandIterable(const Value& v, const RangeTooManyFn& onTooMany) {
@@ -516,8 +542,9 @@ IterableValues expandIterable(const Value& v, const RangeTooManyFn& onTooMany) {
         return IterableValues{std::move(out)};
     }
     if (const std::string* s = std::get_if<std::string>(&v)) {
+        // Characters, not bytes -- `[for (c = "aé—z") c]` yields four.
         std::vector<Value> out;
-        for (char c : *s) out.push_back(Value{std::string(1, c)});
+        for (std::string& ch : utf8Chars(*s)) out.push_back(Value{std::move(ch)});
         return IterableValues{std::move(out)};
     }
     if (const ListPtr* l = std::get_if<ListPtr>(&v)) {
@@ -529,9 +556,23 @@ IterableValues expandIterable(const Value& v, const RangeTooManyFn& onTooMany) {
 void appendEachInto(std::vector<Value>& out, const Value& v) {
     if (const ListPtr* l = std::get_if<ListPtr>(&v); l && *l) {
         for (const Value& x : (*l)->items) out.push_back(x);
-    } else if (!std::holds_alternative<std::monostate>(v)) {
-        out.push_back(v);
+        return;
+    }
+    // A string and a range expand too, not just a list: the reference gives
+    // ["1", "2"] for `[each "12"]` and [0, 1, 2] for `[each [0:2]]`, where
+    // this used to hand back the string and the range whole. Reusing the
+    // expansion `for` already does keeps the two agreeing -- `[for (x = c)
+    // x]` was right over a string while `[each c]` was not, which is what
+    // broke BOSL2's str_strip(): _str_count_leading tests
+    // `in_list(s[i], [each c])` and so never matched a character.
+    //
+    // A number, a boolean and an object stay whole (`[each 5]` is [5]), and
+    // undef contributes nothing.
+    if (std::holds_alternative<std::string>(v) || std::holds_alternative<OscRange>(v)) {
+        for (const Value& x : expandIterable(v, nullptr)) out.push_back(x);
+        return;
     }
+    if (!std::holds_alternative<std::monostate>(v)) out.push_back(v);
 }
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.2.0 → openscad_cpp_evaluator-1.3.1}/tests/test_control_flow.cpp

@@ -537,11 +537,14 @@ TEST(Echo, FormatsEmptyObjectValue) {
 }
 
 TEST(Echo, FormatsFunctionLiteralValue) {
-    // fmtValue's own final fallback -- a FunctionLiteral* value has no
-    // meaningful textual form (matches the reference exactly).
+    // The reference prints a function literal as its own source, and this
+    // used to assert "<function-literal>" while claiming that matched it.
+    // It does not: `echo(function(x) x);` run through the real binary
+    // prints `ECHO: function(x) x`, byte for byte what is expected here.
+    // See format_closure.cpp.
     std::string captured;
     runScript("echo(function(x) x);", [&](const std::string& msg) { captured = msg; });
-    EXPECT_EQ(captured, "ECHO: <function-literal>");
+    EXPECT_EQ(captured, "ECHO: function(x) x");
 }
 
 TEST(AssertStatement, PassingAssertionIsANoOp) {