openscad-cpp-evaluator 1.41.0__tar.gz → 1.43.0__tar.gz

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/CLAUDE.md

@@ -63,7 +63,7 @@ plus gating the silent `is_undef` probe on the call actually resolving to the bu
 CSG-tree shape like union/difference/intersection, role-split via the shared `splitByRole`),
 `linear_extrude()`/`rotate_extrude()`/`projection(cut=)`, and `roof()`; and (Phase 7) `offset()`,
 `surface()` (`.dat` text + PNG/JPEG/BMP/GIF via `stb_image`), hand-rolled DXF (`LWPOLYLINE`/2D
-`POLYLINE`) and SVG (`path`/`polygon`/`polyline`/`rect`/`circle`/`ellipse`, nested
+`POLYLINE`) and SVG (a port of upstream's libsvg: shapes, strokes, `<use>`, layers, nested
 `transform=`, all path commands including elliptical arcs) 2D contour import in both module
 (Region geometry) and expression (Region value) contexts, and the `FontProvider` abstraction
 (`font_provider.hpp`) + built-in FreeType/HarfBuzz backend + `text()`/`textmetrics()`/
@@ -1248,9 +1248,13 @@ grep for `ponytail:`.
   the module *and* expression forms, enclosing transforms still apply to a selected element (it
   has to land where it does in the drawing), and **a filter that matches nothing imports nothing
   and warns** rather than falling back to the whole file — a cut layer that quietly became every
-  layer is the worst answer available. `layer=` stays DXF-only on purpose: upstream reuses the
-  name for SVG but reads only Inkscape's `inkscape:label`, a vendor convention rather than
-  anything SVG defines, so it cannot match a layer from any other tool. `id` had been in
+  layer is the worst answer available. `layer=` (and deprecated `layername=`) also selects in
+  SVG, as upstream does: an Inkscape layer (`inkscape:groupmode="layer"` with an
+  `inkscape:label`). Alone it takes that layer's own group; with `id=`/`class=` it restricts them
+  to elements inside the named layer at any depth. The selection rules were read off the binary:
+  the nearest selected or `display:none` ancestor-or-self decides whether a shape is drawn, so an
+  id selects an element even under a hidden layer, while `layer=` alone does not reach into a
+  hidden sublayer. The miss warning names `id`, `layer`, `class` in that order. `id` had been in
   `registry.cpp`'s declared parameter list since long before anything read it, so a script
   filtering by id was accepted in full and silently handed the whole drawing.
   `resolveFilePath()` (also declared here, defined in import.cpp) — resolves a file argument
@@ -1281,20 +1285,37 @@ grep for `ponytail:`.
   triangle-count parity.
 - `include/openscad_cpp_evaluator/dxf_svg_import.hpp`, `src/import/dxf_import.cpp`,
   `src/import/svg_import.cpp` — hand-rolled, dependency-free 2D-contour loaders (no XML/DXF library
-  pulled in, matching the plan's §9 dependency table). `loadDxfContours()` reads DXF's group-code
-  text format directly (closed `LWPOLYLINE`/2D `POLYLINE` entities only, optional layer filter) --
-  covers the same narrow entity set the reference's own `ezdxf`-based loader does, nothing more.
+  pulled in, matching the plan's §9 dependency table). `loadDxf()` reads DXF's group-code
+  text format directly and matches OpenSCAD 2026.02.01's import, established black-box (its DXF
+  source is GPL; do not read or port it): `LINE`/`CIRCLE`/`ARC`/`ELLIPSE`/`LWPOLYLINE`/`INSERT`
+  become segments (arcs by the circle fragment rules), points snap to a 1/1024 grid, segments chain
+  into paths that are ALL closed (an open chain gets a straight closing edge), filled even-odd;
+  `origin=`/`scale=`/`layer=` and its warnings ("Illegal value", "Not enough input values",
+  "Unsupported DXF Entity") as OpenSCAD has them. The notes atop `dxf_import.cpp` list the rules,
+  the two ellipse bugs deliberately not copied, and the `POLYLINE` extension.
   `loadSvgContours()` pairs a minimal recursive-descent XML tree parser (open/close/self-closing
-  tags, quoted attributes, comments/CDATA/prolog skipping, entity decoding — no namespace URI
-  resolution, a tag's `prefix:` is stripped textually) with a close port of the reference's own
-  path-command tokenizer/flattener (`M`/`L`/`H`/`V`/`C`/`S`/`Q`/`T`/`A`, both absolute and relative,
-  cubic/quadratic Bezier flattening, full elliptical-arc endpoint-to-center parameterization) plus
-  `rect`/`circle`/`ellipse`/`polygon`/`polyline` and nested `transform="matrix()/translate()/
-  scale()/rotate()"` composition (including through `<g>` groups), in SVG user units at the
-  point-transform step, `applyMat()` (named to avoid colliding with `std::apply` in an ADL lookup
-  that broke the build once — see its own comment). **Placement is `pageMap()`, a port of the
-  reference's `import_svg.cc`**: the page's `width`/`height` to mm (a unitless length at `dpi=`,
-  72 by default; `px` at 96), the `viewBox` scaled onto the page under `preserveAspectRatio`
+  tags, quoted attributes, comments/CDATA/prolog skipping, entity and character-reference
+  decoding, attribute whitespace normalisation; a tag keeps its `prefix:`, as libxml2 reports it,
+  so `<svg:rect>` is not a rect -- in OpenSCAD either) with **a port of upstream's MIT-licensed
+  `src/libsvg`** (its copyright notice is in the file): its `d` tokenizer with every quirk (a `-`
+  is a token, `1.5.5` is two numbers, a number with trailing junk is 0), Beziers in `max($fn, 20)`
+  segments, arcs and circles/ellipses through `Discretizer::circular` (circles at least 40),
+  rounded `rect`s rebuilt as path data printed at 6 digits, `transform` with `skewX`/`skewY` and
+  libsvg's argument-count checks, `<use>` of a shape in an earlier `<defs>` only, unknown
+  elements (`<a>`, `<symbol>`, `<switch>`) see-through with their transform ignored, and
+  **strokes**: an open subpath, `<line>` and `<polyline>` become their stroke's outline via
+  Clipper2's `ClipperOffset` at 2^27 per user unit (measured), with `stroke-width` (below 0.01 is
+  1), `stroke-linecap` and `stroke-linejoin` (`bevel` maps to Clipper's Square, as libsvg has it).
+  Each element then fills even-odd on its own and the elements union (`fill()`), which is what
+  the reference does: separate overlapping rects union, one path's overlapping subpaths cancel.
+  Two departures: an arc with a zero radius or coincident endpoints is a line or nothing, as the
+  SVG spec says, where libsvg divides by zero and draws NaN vertices at the origin; and
+  OpenSCAD's 2D pipeline drops vertices within ~1.1e-8 mm of collinear, which ours (any 2D
+  shape, not just SVG) does not -- spec `paths-cubic02` keeps two such vertices at an S-curve's
+  inflection. **Placement is `pageMap()`, matching the reference's `import_svg.cc` by its
+  output**: the page's `width`/`height` to mm (a unitless length at `dpi=`,
+  72 by default; `px` at 96; a `dpi` below 0.001 warns and is 72), the `viewBox` scaled onto the
+  page under `preserveAspectRatio`
   (default `xMidYMid meet`), and Y flipped about the page HEIGHT -- or about the drawing's centre
   with `center=true`. Negating Y alone, as this did before, put a unitless 100-unit drawing in 2.8x
   too large and below the X axis. Bounds match OpenSCAD 2026.02.01 (`SvgPlacement` tests).
@@ -1670,7 +1691,7 @@ the side-quad diagonal choice changes a twisted solid without changing its trian
   default below 3, so these are an extrude warped round Z. The warp inverts the solid for a positive
   angle, hence the mirror-in-Y dance.
 - Kept departure: `$fa`/`$fs` <= 0 fall back to 12/2 rather than upstream's clamp-to-0.01 with a warning.
-- Not ported: `linear_extrude(v=)` (accepted, ignored); DXF/SVG import arcs don't read the discretizer.
+- Not ported: `linear_extrude(v=)` (accepted, ignored); DXF import arcs don't read the discretizer.
 
 ## Cancel and the module recursion limit (#554)
 

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.41.0
+Version: 1.43.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
-License-Expression: MIT
+License-Expression: MIT AND OFL-1.1
 License-File: LICENSE
+License-File: resources/fonts/LICENSE
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent

openscad_cpp_evaluator-1.43.0/external/openscad_cpp_parser/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 BelfrySCAD Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -43,6 +43,7 @@ enum class Op {
     StoreLocal,     // a = slot index (pops)
     LoadDyn,        // a = name pool index ($-prefixed)
     StoreDyn,       // a = name pool index (pops; also marks dynExplicit)
+    WarnDuplicateLet, // a = name pool index (pops; warns, binds nothing -- see Evaluator::warnDuplicateLet)
     LoadFree,       // a = name pool index -- Evaluator::evalIdentifier fallback (warnIfUndef=true)
     // Same as LoadFree, but Evaluator::evalIdentifier's warnIfUndef=false --
     // only ever emitted for a PrimaryCall's own callee probe (bytecode_
@@ -240,20 +241,6 @@ enum class Op {
     // there's no branch to emit here).
     Echo,
 
-    // Only ever emitted for a non-empty-argument AssertOp (see
-    // bytecode_compiler.cpp's own AssertOp case -- a zero-argument
-    // assert() is unconditionally true and compiles straight through with
-    // no check at all). Reached only on the condition-false path (guarded
-    // by a JumpIfTrue the compiler emits around it, mirroring LogicalOrOp's
-    // own jump-then-patch shape) -- always throws via Evaluator::error(),
-    // i.e. [[noreturn]] at runtime. a = 1 if a message Value was compiled
-    // and pushed (pop it), else 0. b = constant-pool index of condText
-    // (the condition expression's own source text, interned ONCE at
-    // compile time via its toString() -- cheaper than the interpreter,
-    // which recomputes this on every failing call). pos/node: same
-    // Evaluator::error() TRACE-walk need CheckIterLimit already has.
-    AssertFail,
-
     // -- Module-body compilation (Stage 2) --------------------------------
     // A call to a user module resolved to a specific ModuleDeclaration AT
     // COMPILE TIME (see CompiledChunk::ModuleCallSite) -- the module-side
@@ -717,16 +704,10 @@ enum class Op {
     StoreLetVar,
 
     // a = index into CompiledChunk::assertSites. Pops site.argCount values
-    // (all of this statement's own arguments, already compiled+pushed in
-    // source order via compileExpr -- EVERY one, not just condition/
-    // message, mirrors evalAssertStatement's own eager resolveArgs() over
-    // AssertOp's lazy-message contract) and replicates
-    // Evaluator::evalAssertStatement exactly: named "condition"/"message"
-    // win over positional 0/1 (resolved at COMPILE time into
-    // AssertSite::conditionArgIndex/messageArgIndex -- the argument SHAPE
-    // is static, only values vary per call), throws via Evaluator::error()
-    // on failure, otherwise runs any chained node.children natively (rare;
-    // not worth its own compiled path -- see AssertSite's own doc comment).
+    // (every argument of an assert() statement or expression, pushed in
+    // source order) and hands them to Evaluator::checkAssert; a statement
+    // then runs any chained children natively (rare; not worth its own
+    // compiled path).
     AssertStatement,
     // a = nativeStatements index of the AST node whose arm this is. Emitted
     // only when the Evaluator was built with coverage on (compile-time
@@ -763,6 +744,10 @@ struct Instruction {
 // applyDefaults()'s existing sibling-isolated defaultCtx; empty if that
 // parameter has no default. `bodyCode` is the function's own expression body.
 struct CompiledChunk {
+    // String literals whose text holds an escape OpenSCAD calls undefined,
+    // with how many: the Evaluator warns for them once, when the chunk is
+    // compiled (it has the warning channel; the compiler does not).
+    std::vector<std::pair<const oscad::StringLiteral*, int>> undefinedEscapeLiterals;
     struct Param {
         std::string name;
         int slot = 0; // unused when isDyn is true -- $-params are never slot-addressed
@@ -1036,30 +1021,13 @@ struct CompiledChunk {
         const oscad::ASTNode* node = nullptr;
     };
 
-    // One Op::AssertStatement site -- see that op's own doc comment for
-    // the full contract. `conditionArgIndex`/`messageArgIndex` are indices
-    // into the site's own argCount-sized popped-argument array (source
-    // order), resolved at COMPILE time via the same "named wins over
-    // positional 0/1" priority Evaluator::getArg applies at runtime --
-    // nullopt means "no argument supplies this logical parameter" (mirrors
-    // getArg's own defaultValue fallback: absent condition reads as
-    // `Value{true}`, absent message means no ": ..." suffix).
-    // `condTextConstIdx`: constants[] index of the condition argument's own
-    // source text (or "false" when no condition argument exists, matching
-    // evalAssertStatement's `node.arguments.empty() ? "false" : ...`),
-    // interned once at compile time. `node`: for both Evaluator::error()'s
-    // TRACE walk and the (rare) chained-children fallback below.
-    //
-    // ponytail: a script with TWO named args of the SAME name (e.g.
-    // `assert(condition=true, condition=false)`) would resolve to the
-    // LAST one here, not getArg's own first-match; not worth the extra
-    // bookkeeping to fix for input that's already nonsensical.
+    // One Op::AssertStatement site. `statement` is null for the expression
+    // form, which has no children.
     struct AssertSite {
         int argCount = 0;
-        std::optional<int> conditionArgIndex;
-        std::optional<int> messageArgIndex;
-        int condTextConstIdx = -1;
-        const oscad::ModularAssert* node = nullptr;
+        const std::vector<std::unique_ptr<oscad::Argument>>* arguments = nullptr;
+        const oscad::ASTNode* node = nullptr;
+        const oscad::ModularAssert* statement = nullptr;
     };
 
     // Every distinct chunk this SPECIFIC CompiledChunk owns is either a

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -188,7 +188,7 @@ std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodi
                                             double flatHeight = kTopLevel2dHeight);
 
 // A 3D affine transform as it acts on the XY plane: rows x and y, columns
-// x, y and translation -- what OpenSCAD's GeometryEvaluator applies to 2D
+// x, y and translation -- what OpenSCAD applies to 2D
 // geometry (z, and everything out of the plane, simply drops away).
 manifold::mat2x3 projectTo2d(const manifold::mat3x4& m);
 
@@ -203,10 +203,10 @@ bool projectSectionXform(ColoredBody& b);
 
 // Applies `m`, projected onto the plane, to a CrossSection. A singular
 // projection -- scale([0,1]), a quarter turn about X -- empties it, as
-// upstream's Polygon2d::transform does, and returns false.
+// OpenSCAD does, and returns false.
 bool transformSection(manifold::CrossSection& cs, const manifold::mat3x4& m);
 
-// Upstream's warning for that case, word for word.
+// OpenSCAD's warning for that case, word for word.
 inline constexpr const char* kZeroScale2dWarning = "Scaling a 2D object with 0 - removing object";
 
 } // namespace oscadeval

openscad_cpp_evaluator-1.43.0/include/openscad_cpp_evaluator/dxf_svg_import.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "openscad_cpp_evaluator/segments.hpp"
+
+#include <array>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace oscadeval {
+
+using Contour2d = std::vector<std::array<double, 2>>;
+
+// import()'s DXF arguments. `disc` carries $fn/$fa/$fs/$fe for arcs.
+struct DxfOptions {
+    std::optional<std::string> layer;
+    double xorigin = 0.0, yorigin = 0.0, scale = 1.0;
+    Discretizer disc;
+};
+
+// The outlines, to be filled even-odd, and OpenSCAD's warnings about the
+// file, in the order it prints them.
+struct DxfImport {
+    std::vector<Contour2d> contours;
+    std::vector<std::string> warnings;
+};
+
+// Hand-rolled DXF reader matching OpenSCAD 2026.02.01's import (see the
+// notes atop dxf_import.cpp): LINE, CIRCLE, ARC, ELLIPSE, LWPOLYLINE,
+// POLYLINE and INSERT, chained into closed outlines. Throws
+// std::runtime_error on I/O failure.
+DxfImport loadDxf(const std::string& path, const DxfOptions& opts = {});
+
+// SVG reader, as OpenSCAD 2026.02.01 reads it (a port of its MIT-licensed
+// libsvg): <path>, <rect>, <circle>, <ellipse>, <line>, <polygon>,
+// <polyline> and <use>, with transforms, display:none, and strokes -- an
+// open path, <line> or <polyline> is drawn as its stroke's outline. Curves
+// split by `disc`. Y is flipped (SVG's is down, OpenSCAD's is up). Throws
+// std::runtime_error on I/O/parse failure.
+//: Which part of the drawing to import. All unset means the whole file.
+//: `id` matches an element's `id` attribute; `cls` (not an OpenSCAD
+//: parameter) one entry of its space-separated `class` list; either takes
+//: everything under the element, so naming a <g> means "that group".
+//: `layer` names an Inkscape layer (inkscape:groupmode="layer", by its
+//: inkscape:label): alone it takes that layer, with id/cls it restricts
+//: them to elements inside it.
+struct SvgFilter {
+    std::optional<std::string> id;
+    std::optional<std::string> cls;
+    std::optional<std::string> layer;
+};
+
+// `matched`, when given, reports whether the filter found anything. A miss
+// imports nothing rather than falling back to the whole drawing; the caller
+// warns. Always true when no filter was set.
+// Placed as OpenSCAD places them: page units to mm (a unitless length at
+// `dpi`), the viewBox under preserveAspectRatio, Y flipped about the page
+// height -- or about the drawing's centre with `center`. The result is
+// filled: overlapping contours have already been combined.
+std::vector<Contour2d> loadSvgContours(const std::string& path,
+                                       const SvgFilter& filter = {},
+                                       bool* matched = nullptr,
+                                       double dpi = 72.0,
+                                       bool center = false,
+                                       const Discretizer& disc = {});
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -2,6 +2,8 @@
 
 #include "openscad_cpp_evaluator/bound_args.hpp"
 #include "openscad_cpp_evaluator/bytecode.hpp"
+
+#include <unordered_set>
 #include "openscad_cpp_evaluator/bytecode_vm.hpp"
 #include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/csg_node.hpp"
@@ -557,10 +559,39 @@ public:
     // Public: builtins/import.cpp's not-manifold warning is emitted from a
     // free function, same reasoning as tagGenerated()/builtinChildren().
     void warn(const std::string& message, const oscad::Position* position);
+    // OpenSCAD's lexer warns "Undefined escape sequence" once per bad escape
+    // in the source. This warns for a literal the first time it is
+    // evaluated or compiled, and never again for that literal.
+    void warnUndefinedEscapes(const oscad::StringLiteral& lit, int count);
+    // let() keeps the FIRST binding of a repeated name: OpenSCAD evaluates
+    // the later right-hand side, warns with its value, and discards it.
+    // OpenSCAD's Assert::performAssert, given every argument's value in
+    // source order -- it evaluates them all, pass or fail, so a passing
+    // `assert(true, nosuch)` still warns. Warns about unexpected arguments;
+    // throws via error() when the condition is false or missing (`assert()`
+    // fails). The message prints as echo() would print it.
+    void checkAssert(const std::vector<std::unique_ptr<oscad::Argument>>& arguments, const std::vector<Value>& values,
+                     const oscad::ASTNode& node);
+    void warnDuplicateLet(const std::string& name, const Value& v, const oscad::Position* position);
+    template <typename Assignments>
+    static bool repeatsEarlierLetName(const Assignments& assignments, size_t i) {
+        for (size_t j = 0; j < i; ++j)
+            if (assignments[j]->name->name == assignments[i]->name->name) return true;
+        return false;
+    }
+    std::unordered_set<const oscad::StringLiteral*> undefinedEscapesWarned_;
+    void warnUndefinedEscapes(const CompiledChunk& chunk) {
+        for (const auto& [lit, n] : chunk.undefinedEscapeLiterals) warnUndefinedEscapes(*lit, n);
+    }
     // Hands one already-formatted warning line to echoFn_, recording it in
     // warnCapture first when one is active. Every warning path goes through
     // here, including a ManifoldCache hit replaying a cached line.
     void emitWarning(const std::string& formatted);
+    // "ERROR: {message}{locSuffix(position)}" that does NOT stop the run:
+    // OpenSCAD logs several of its errors this way and carries on.
+    void nonFatalError(const std::string& message, const oscad::Position* position) {
+        emitWarning("ERROR: " + message + locSuffix(position));
+    }
 
     // Applies OpenSCAD's mixed-2D/3D rules to a node's children just
     // before its GenerateFn runs -- see csg_generate.cpp.

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/include/openscad_cpp_evaluator/export.hpp

@@ -167,7 +167,7 @@ struct ExportSvgOptions {
 void writeSvg(const std::string& path, const std::vector<ColoredBody>& bodies,
               const ExportSvgOptions& opts = {});
 
-// DXF, the third 2D writer: OpenSCAD's own export_dxf.cc layout (an AC1006
+// DXF, the third 2D writer: byte-compatible with OpenSCAD's layout (an AC1006
 // header with the model's extents, one CONTINUOUS linetype, layer 0) and
 // every contour of every body a closed LWPOLYLINE on layer 0 -- holes are
 // contours like any other, as in OpenSCAD. A 1-vertex contour is a POINT
@@ -259,13 +259,10 @@ struct ExportPovOptions {
 // POV-Ray scene description. Every object splitBodiesForExport produces is
 // one mesh2 -- a welded vertex list, a texture per colour, and a texture
 // index per triangle, so per-triangle colour needs no unwelding -- with
-// inside_vector, which makes it a SOLID to POV-Ray (refraction, CSG). That
-// is the difference from OpenSCAD's export_pov.cc, which writes every face
-// as its own flat polygon object. The rest of the scene is OpenSCAD's: its
-// header, MATERIAL finish and ior 1.32 interior, 27 lights around the
-// bounding box, its camera, and radiosity from rad_def.inc. Colour is rgbf
-// with filter = 1 - alpha, as OpenSCAD writes it. Numbers are the shortest
-// text that round-trips, in the classic locale.
+// inside_vector, which makes it a SOLID to POV-Ray (refraction, CSG). The
+// rest of the scene (material, lights, default camera) is spec section F2.
+// Colour is rgbf with filter = 1 - alpha. Numbers are the shortest text that
+// round-trips, in the classic locale.
 void writePov(const std::string& path, const std::vector<ExportObject>& objects,
               const ExportPovOptions& opts = {});
 

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/include/openscad_cpp_evaluator/import_builtin.hpp

@@ -9,12 +9,14 @@ class ASTNode;
 namespace oscadeval {
 
 class Evaluator;
+struct EvalContext;
 
 // import() used as an expression (not a geometry statement): returns a VNF
 // ([[verts],[faces]]) for a mesh file (.stl/.obj/.off/.3mf), or the JSON
 // file's content converted to native values (.json). DXF/SVG-as-Region
 // import lands alongside their module-context counterparts in a later
 // phase. Mirrors Evaluator._import_as_value (minus the dxf/svg branch).
-Value importAsValue(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node);
+// `ctx` supplies $fn/$fa/$fs/$fe for an SVG's curves.
+Value importAsValue(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node, const EvalContext& ctx);
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/include/openscad_cpp_evaluator/segments.hpp

@@ -11,34 +11,25 @@
 
 namespace oscadeval {
 
-// How curves become polygons: OpenSCAD's CurveDiscretizer (src/core/
-// CurveDiscretizer.cc, upstream master cc19000e0), ported. Every count here
-// matches the 2026.02.01 binary's.
-//
-// $fn > $fe > $fa/$fs. $fe is the most a curve's polygon may stray from the
-// true circle, measured along a radius to an edge's midpoint; when set (>=
-// 2^-20) it replaces $fa/$fs entirely. Upstream reads $fe only behind
-// --enable=discretization-by-error; this evaluator always honours it, and
-// advertises that as supported_feature("discretization-by-error").
-//
-// Departures from upstream, kept from before this port: $fa/$fs <= 0 fall
-// back to their defaults (12/2) rather than clamping to 0.01 with a warning.
+// How curves become polygons: segment and slice counts from $fn/$fe/$fa/$fs
+// (spec sections B7 and C6). $fe is always honoured here (OpenSCAD reads it
+// only behind --enable=discretization-by-error), advertised as
+// supported_feature("discretization-by-error").
 struct Discretizer {
     double fn = 0.0;
     double fe = 0.0;
     double fa = 12.0;
     double fs = 2.0;
 
-    // `warn`, when given, receives upstream's clamping warnings.
+    // `warn`, when given, receives the clamping warnings (spec section B7).
     static Discretizer fromCtx(const EvalContext& ctx, const std::function<void(const std::string&)>& warn = {});
     // Stored in, and read back from, a node's params -- they are part of its
     // cache key, and generate has only the params to go on.
     static Discretizer fromParams(const CSGParams& params);
     void store(CSGParams& params) const;
 
-    // Segments for `angle` degrees of arc at radius r. nullopt where
-    // upstream has none (r below 2^-20, a non-finite $fn/$fe/angle): every
-    // caller supplies its own fallback, as upstream's value_or() does.
+    // Segments for `angle` degrees of arc at radius r. nullopt where there is
+    // no count (spec section B7); every caller supplies its own fallback.
     std::optional<int> circular(double r, double angleDegrees = 360.0) const;
 
     // linear_extrude slice counts: twist without scale, twist with uniform
@@ -54,8 +45,8 @@ struct Discretizer {
                                          double scaleX, double scaleY, unsigned slices, unsigned segments) const;
 };
 
-// Full-circle segment count from ctx's $fn/$fe/$fa/$fs at radius r;
-// upstream's primitives fall back to 3.
+// Full-circle segment count from ctx's $fn/$fe/$fa/$fs at radius r, or 3
+// when there is none.
 int fnSegmentsFromCtx(const EvalContext& ctx, double r = 0.0,
                       const std::function<void(const std::string&)>& warn = {});
 

openscad_cpp_evaluator-1.43.0/include/openscad_cpp_evaluator/surface_load.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace oscadeval {
+
+// Height data for surface() (spec section D3). Never throws: a file that
+// cannot be read gives no heights and a warning, and the script carries on.
+// `heights[row * cols + col]`; `minVal` is what the base sits 1 below.
+struct SurfaceData {
+    std::vector<double> heights;
+    int rows = 0;
+    int cols = 0;
+    double minVal = 0;
+    std::vector<std::string> warnings;
+};
+SurfaceData loadSurface(const std::string& path, bool invert);
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/include/openscad_cpp_evaluator/value.hpp

@@ -268,12 +268,9 @@ Value vecSub(const Value& a, const Value& b);
 // behavior in the reference implementation -- revisit only if a real
 // script's `*` on a bool-containing vector is shown to need it.
 //
-// `error`, when non-null, receives the reference's own diagnostic text for
-// whichever undefined case was hit (multiply_visitor / multvecvec /
-// multmatvec / multvecmat in the reference's Value.cc) -- "vector*vector
-// requires matching lengths (2 != 3)", "Matrix must be rectangular. Problem
-// at row 1", and so on. applyBinaryOp warns with it; a caller that only
-// wants the value can leave it null. It is only written on an undef result.
+// `error`, when non-null, receives the diagnostic for whichever undefined
+// case was hit (spec section A6); applyBinaryOp warns with it. It is only
+// written on an undef result.
 Value matmul(const Value& a, const Value& b, std::string* error = nullptr);
 
 // OpenSCAD's echo()/str() number formatting: at most 6 significant digits,
@@ -306,7 +303,9 @@ std::string formatNumber(double v);
 //
 // 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);
+// `undefinedEscapes`, when given, counts the escapes OpenSCAD's lexer calls
+// undefined (it warns once for each).
+std::string unescapeStringLiteral(const std::string& raw, int* undefinedEscapes = nullptr);
 
 // echo()/str()/assert-message display format: "undef" | "true"/"false" |
 // "[start : step : end]" (range) | formatNumber() (number) | "[e1, e2, ...]"

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.41.0"
+version = "1.43.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"
-license = "MIT"
-license-files = ["LICENSE"]
+license = "MIT AND OFL-1.1"
+license-files = ["LICENSE", "resources/fonts/LICENSE"]
 authors = [{ name = "NeuSCAD Contributors" }]
 classifiers = [
     "Development Status :: 3 - Alpha",

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/src/CMakeLists.txt

@@ -68,7 +68,7 @@ target_include_directories(openscad_cpp_evaluator PRIVATE ${stb_SOURCE_DIR} ${CM
 add_dependencies(openscad_cpp_evaluator generate_bundled_font)
 
 target_link_libraries(openscad_cpp_evaluator PUBLIC openscad_cpp_parser manifold Boost::polygon)
-target_link_libraries(openscad_cpp_evaluator PRIVATE linenoise freetype harfbuzz)
+target_link_libraries(openscad_cpp_evaluator PRIVATE linenoise freetype harfbuzz Clipper2)
 target_compile_options(openscad_cpp_evaluator PRIVATE
   $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall;-Wextra>
 )

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/src/builtins/booleans.cpp

@@ -392,8 +392,8 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
         }
 
         RoleSplit split = splitByRole(stmtBodies);
-        // A `%` statement is scenery, not an operand: upstream leaves it out
-        // of the CSG entirely (collectChildren skips isBackground()), so the
+        // A `%` statement is scenery, not an operand: OpenSCAD leaves it out
+        // of the CSG entirely, so the
         // NEXT statement is the minuend of a difference(), and an
         // intersection() is not cancelled by it. It was taken as an empty
         // operand, which emptied both. Only the `%` statement itself: a

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/src/builtins/builtins.hpp

@@ -271,15 +271,28 @@ std::vector<ColoredBody> generateSurface(Evaluator& ev, const CSGParams& params,
 // operand (and so empties an intersection) -- see resolveCsg.
 bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt);
 
-// OpenSCAD's sin_degrees/cos_degrees: exact at multiples of 30 and 45 degrees.
+// OpenSCAD's sin_degrees/cos_degrees/tan_degrees/atan2_degrees: exact at
+// multiples of 30 and 45 degrees.
 double sinDeg(double x);
 double cosDeg(double x);
+double tanDeg(double x);
+double atan2Deg(double y, double x);
 
-// OpenSCAD's lookup_radius() (primitives_2d.cpp): `d` beats `r`, numbers only.
+// A radius/diameter argument pair: a numeric `d` beats `r`, numbers only.
 std::optional<double> lookupRadius(Evaluator& ev, const CallArgs& args, std::optional<int> rPos,
                                    std::optional<int> dPos, const std::string& rName, const std::string& dName,
                                    const oscad::Position* where);
 
+// "ERROR: <text>" at `where`, for input a primitive repairs and carries on with.
+void emitInputError(Evaluator& ev, const std::string& text, const oscad::Position* where);
+
+// Reads polygon() paths or polyhedron() faces (`listName`): each entry a
+// list of point indices. Entries that are not lists and indices that are not
+// numbers are reported as ERRORs and skipped; out-of-range indices are
+// WARNINGs and skipped. Every surviving entry is returned, however short.
+std::vector<std::vector<size_t>> readIndexLists(Evaluator& ev, const ValueList& lists, const std::string& listName,
+                                                size_t pointCount, const oscad::Position* where);
+
 CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 
 // The font size text()/textmetrics()/fontmetrics() draw at: `size`

{openscad_cpp_evaluator-1.41.0 → openscad_cpp_evaluator-1.43.0}/src/builtins/control.cpp

@@ -118,15 +118,14 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
     // needs `i` visible in `j`'s own range expression).
     std::function<void(size_t, EvalContext&)> recurse = [&](size_t depth, EvalContext& parentCtx) {
         if (depth == node.assignments.size()) {
+            if (depth == 0) return; // for() with no loop variables iterates zero times in OpenSCAD, not once.
             // One body-entry marker per full cartesian-product iteration
             // and nothing per individual variable binding (unlike
             // evalFor) -- mirrors _resolve_intersection_for's single
             // `_check_debug(body_node[0], loop_ctx, expr_level=True)`.
             if (!bodyNodes.empty()) ev.checkDebug(*bodyNodes.front(), parentCtx, /*forced=*/false, /*exprLevel=*/true);
-            // One operand per child STATEMENT of every iteration: upstream
-            // instantiates the children straight into the intersection
-            // node (control.cc), so they are intersected flat, not
-            // unioned per iteration first.
+            // One operand per child STATEMENT of every iteration: OpenSCAD
+            // intersects them flat, not unioned per iteration first.
             std::vector<const oscad::ASTNode*> assigns, stmts;
             for (const oscad::ASTNode* stmt : bodyNodes) {
                 if (stmt->kind() == oscad::NodeKind::Assignment) assigns.push_back(stmt);