Add MANIFOLD_NO_IOSTREAM build-time option

zmerlynn · claude · zmerlynn · commit bb56ded716c9 · 2026-05-03T05:43:42.000-07:00
Wraps iostream-using overloads in the public headers (manifold.h, manifoldc.h) and their impls (src/impl.cpp, bindings/c/manifoldc.cpp) with `#ifndef MANIFOLD_NO_IOSTREAM`. Adds an `option(MANIFOLD_NO_IOSTREAM)` (default OFF) that propagates the macro as a PUBLIC compile definition on the manifold target so consumers' own includes of manifold's headers also strip the iostream-using overloads. Default behavior unchanged when off. The bundled Clipper2 (when MANIFOLD_USE_BUILTIN_CLIPPER2=ON) carries a corresponding patch that adds `CLIPPER2_NO_IOSTREAM` macro guards to its public headers — tracking AngusJohnson/Clipper2#1094, drops once that PR lands and the SHA pin moves past it. When MANIFOLD_NO_IOSTREAM=ON, manifold sets CLIPPER2_NO_IOSTREAM=ON for the bundled Clipper2 build. CMake-level conflict guards: MANIFOLD_NO_IOSTREAM=ON is incompatible with MANIFOLD_DEBUG / MANIFOLD_TIMING (those use std::cout for diagnostic output), and currently requires MANIFOLD_TEST=OFF (test fixtures use <filesystem>/<fstream>; restriction will be lifted by a follow-up MANIFOLD_NO_FILESYSTEM option). Build-time check: src/no_iostream_check.cpp + a manifold_no_iostream_check OBJECT target compile manifold/manifold.h with MANIFOLD_NO_IOSTREAM defined. Always-on; fails the build if iostream usage creeps into the public header outside the macro guards. CI: new build_no_iostream cell on Ubuntu/clang exercising MANIFOLD_NO_IOSTREAM=ON + MANIFOLD_USE_BUILTIN_CLIPPER2=ON (the patch-application path). Motivation + the broader consumer cocktail this enables: elalish#1046 (comment) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
diff --git a/.github/workflows/manifold.yml b/.github/workflows/manifold.yml
@@ -175,6 +175,46 @@ jobs:
         sudo cmake --install build
         ./scripts/test-cmake.sh
 
+  build_no_iostream:
+    name: NO_IOSTREAM (clang)
+    timeout-minutes: 20
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - name: Install apt packages
+      uses: awalsh128/cache-apt-pkgs-action@v1.6.0
+      with:
+        packages: cmake clang
+    - name: Configure + build with MANIFOLD_NO_IOSTREAM=ON
+      run: |
+        cmake \
+          -DCMAKE_BUILD_TYPE=Release \
+          -DCMAKE_C_COMPILER=clang \
+          -DCMAKE_CXX_COMPILER=clang++ \
+          -DMANIFOLD_NO_IOSTREAM=ON \
+          -DMANIFOLD_USE_BUILTIN_CLIPPER2=ON \
+          -DMANIFOLD_STRICT=ON \
+          -DMANIFOLD_TEST=OFF \
+          -DMANIFOLD_PYBIND=OFF \
+          . -B build
+        cmake --build build
+    - name: Verify conflict guards fire (NO_IOSTREAM + DEBUG)
+      run: |
+        if cmake -DMANIFOLD_NO_IOSTREAM=ON -DMANIFOLD_DEBUG=ON \
+                 -DMANIFOLD_USE_BUILTIN_CLIPPER2=ON \
+                 . -B /tmp/conflict-debug 2>&1; then
+          echo "FAIL: configure should have failed for NO_IOSTREAM + DEBUG"
+          exit 1
+        fi
+    - name: Verify conflict guards fire (NO_IOSTREAM + TEST)
+      run: |
+        if cmake -DMANIFOLD_NO_IOSTREAM=ON -DMANIFOLD_TEST=ON \
+                 -DMANIFOLD_USE_BUILTIN_CLIPPER2=ON \
+                 . -B /tmp/conflict-test 2>&1; then
+          echo "FAIL: configure should have failed for NO_IOSTREAM + TEST"
+          exit 1
+        fi
+
   build_gcc_codecov:
     name: code coverage
     timeout-minutes: 45
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -42,6 +42,11 @@ option(MANIFOLD_DEBUG "Enable debug tracing/timing" OFF)
 option(MANIFOLD_ASSERT "Enable assertions - requires MANIFOLD_DEBUG" OFF)
 option(MANIFOLD_TIMING "Enable Boolean3 phase timing without debug overhead" OFF)
 option(MANIFOLD_STRICT "Treat compile warnings as fatal build errors" OFF)
+option(
+  MANIFOLD_NO_IOSTREAM
+  "Strip iostream- and filesystem-using bits from the public API and tests; useful for freestanding/embedded builds. When ON, defines both MANIFOLD_NO_IOSTREAM and MANIFOLD_NO_FILESYSTEM."
+  OFF
+)
 option(
   MANIFOLD_DOWNLOADS
   "Allow Manifold build to download missing dependencies"
@@ -100,6 +105,28 @@ mark_as_advanced(TRACY_MEMORY_USAGE)
 mark_as_advanced(MANIFOLD_FUZZ)
 mark_as_advanced(ASSIMP_ENABLE)
 
+# MANIFOLD_NO_IOSTREAM strips iostream- and filesystem-using bits
+# from the public API. It's incompatible with options that *use*
+# iostream/filesystem for their diagnostic or test output:
+#   * MANIFOLD_DEBUG / MANIFOLD_TIMING: debug/timing output via
+#     std::cout.
+#   * MANIFOLD_TEST: most test files (polygon_test, manifold_test,
+#     polygon_fuzz, manifoldc_test) call iostream-using API or open
+#     fstreams directly outside the wrapped test_main.cpp fixtures.
+if(MANIFOLD_NO_IOSTREAM)
+  if(MANIFOLD_DEBUG OR MANIFOLD_TIMING)
+    message(FATAL_ERROR
+      "MANIFOLD_NO_IOSTREAM is incompatible with MANIFOLD_DEBUG / MANIFOLD_TIMING "
+      "(those options use std::cout for diagnostic output).")
+  endif()
+  if(MANIFOLD_TEST)
+    message(FATAL_ERROR
+      "MANIFOLD_NO_IOSTREAM=ON requires MANIFOLD_TEST=OFF "
+      "(several test files call iostream-using API or open fstreams "
+      "directly; only test_main.cpp's fixtures are wrapped).")
+  endif()
+endif()
+
 # Always build position independent code for relocatability
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
diff --git a/bindings/c/CMakeLists.txt b/bindings/c/CMakeLists.txt
@@ -43,3 +43,14 @@ install(
   FILES include/manifold/manifoldc.h include/manifold/types.h
   DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/manifold
 )
+
+# Always-on build-time check: compiles manifold/manifoldc.h with
+# MANIFOLD_NO_IOSTREAM defined. Mirrors src/no_iostream_check.cpp's
+# role for the C++ public header.
+add_library(manifoldc_no_iostream_check OBJECT no_iostream_check.cpp)
+target_link_libraries(manifoldc_no_iostream_check PRIVATE manifoldc)
+if(NOT MANIFOLD_NO_IOSTREAM)
+  target_compile_definitions(
+    manifoldc_no_iostream_check PRIVATE MANIFOLD_NO_IOSTREAM
+  )
+endif()
diff --git a/bindings/c/include/manifold/manifoldc.h b/bindings/c/include/manifold/manifoldc.h
@@ -542,6 +542,7 @@ void manifold_delete_rect(ManifoldRect* b);
 void manifold_delete_triangulation(ManifoldTriangulation* m);
 void manifold_delete_execution_context(ManifoldExecutionContext* ctx);
 
+#ifndef MANIFOLD_NO_IOSTREAM
 // MeshIO / Export
 
 // Import a manifold from a Wavefront obj file.
@@ -570,6 +571,7 @@ void manifold_write_obj(ManifoldManifold* manifold,
 //    passing additional data into the callback.
 void manifold_meshgl64_write_obj(ManifoldMeshGL64* mesh,
                                  void (*callback)(char*, void*), void* args);
+#endif  // !MANIFOLD_NO_IOSTREAM
 #ifdef __cplusplus
 }
 #endif
diff --git a/bindings/c/manifoldc.cpp b/bindings/c/manifoldc.cpp
@@ -14,7 +14,9 @@
 
 #include "manifold/manifoldc.h"
 
+#ifndef MANIFOLD_NO_IOSTREAM
 #include <sstream>
+#endif
 #include <vector>
 
 #include "conv.h"
@@ -1048,6 +1050,7 @@ void manifold_destruct_execution_context(ManifoldExecutionContext* ctx) {
 
 // IO
 
+#ifndef MANIFOLD_NO_IOSTREAM
 ManifoldManifold* manifold_read_obj(void* mem, char* obj_file) {
   std::istringstream iss(obj_file);
   Manifold m = Manifold::ReadOBJ(iss);
@@ -1075,6 +1078,7 @@ void manifold_meshgl64_write_obj(ManifoldMeshGL64* mesh,
   WriteOBJ(ss, *m);
   callback(ss.str().data(), args);
 }
+#endif  // !MANIFOLD_NO_IOSTREAM
 
 #ifdef __cplusplus
 }
diff --git a/bindings/c/no_iostream_check.cpp b/bindings/c/no_iostream_check.cpp
@@ -0,0 +1,19 @@
+// Copyright 2026 The Manifold Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Build-time check: compiles manifold/manifoldc.h with MANIFOLD_NO_IOSTREAM
+// defined. Fails the build if iostream usage creeps into the C-API
+// header outside the macro guards.
+
+#include "manifold/manifoldc.h"
diff --git a/cmake/manifoldDeps.cmake b/cmake/manifoldDeps.cmake
@@ -119,6 +119,22 @@ if(MANIFOLD_CROSS_SECTION)
       CACHE BOOL
       "Preempt cache default of USINGZ (we only use 2d)"
     )
+    # When manifold is built with MANIFOLD_NO_IOSTREAM, also strip
+    # iostream from the bundled Clipper2 — manifold doesn't call any
+    # of Clipper2's stream operators internally, so passing this
+    # through is safe regardless. The CLIPPER2_NO_IOSTREAM macro is
+    # added by the carry-patch below; once Clipper2#1094 lands and
+    # the SHA pin moves past it, the patch drops and the option is
+    # honored natively.
+    if(MANIFOLD_NO_IOSTREAM)
+      set(
+        CLIPPER2_NO_IOSTREAM
+        ON
+        CACHE BOOL
+        "Strip iostream-using overloads from Clipper2 (set by manifold when MANIFOLD_NO_IOSTREAM=ON)"
+        FORCE
+      )
+    endif()
     FetchContent_Declare(
       Clipper2
       GIT_REPOSITORY https://github.com/AngusJohnson/Clipper2.git
@@ -127,6 +143,13 @@ if(MANIFOLD_CROSS_SECTION)
       GIT_PROGRESS TRUE
       SOURCE_SUBDIR
       CPP
+      # Carry-patch: tracks AngusJohnson/Clipper2#1094 (CLIPPER2_NO_IOSTREAM
+      # macro guards). Drops once that PR lands and the SHA pin moves past it.
+      PATCH_COMMAND
+      git
+      apply
+      --ignore-whitespace
+      ${CMAKE_SOURCE_DIR}/cmake/patches/0001-clipper2-no-iostream.patch
     )
     FetchContent_MakeAvailable(Clipper2)
     set_property(
diff --git a/cmake/patches/0001-clipper2-no-iostream.patch b/cmake/patches/0001-clipper2-no-iostream.patch
@@ -0,0 +1,122 @@
+Carry-patch: add CLIPPER2_NO_IOSTREAM macro guards to Clipper2's
+public headers so manifold can build Clipper2 without iostream when
+MANIFOLD_NO_IOSTREAM is set (e.g., for wasm32-unknown-unknown
+consumers via the wasm-cxx-shim integration).
+
+Tracks AngusJohnson/Clipper2#1094 — once that lands and manifold's
+Clipper2 SHA pin moves past it, this patch drops.
+
+Generated against Clipper2 SHA 46f639177fe418f9689e8ddb74f08a870c71f5b4
+(the SHA manifoldDeps.cmake currently pins). The headers at this SHA
+are byte-identical to upstream main, so the patch tracks #1094's diff
+exactly.
+
+Apply with: git apply -p1 0001-clipper2-no-iostream.patch
+
+diff --git a/CPP/Clipper2Lib/include/clipper2/clipper.core.h b/CPP/Clipper2Lib/include/clipper2/clipper.core.h
+index 99a5205..d3af0a0 100644
+--- a/CPP/Clipper2Lib/include/clipper2/clipper.core.h
++++ b/CPP/Clipper2Lib/include/clipper2/clipper.core.h
+@@ -14,7 +14,9 @@
+ #include <cstdint>
+ #include <vector>
+ #include <string>
++#ifndef CLIPPER2_NO_IOSTREAM
+ #include <iostream>
++#endif
+ #include <algorithm>
+ #include <numeric>
+ #include <cmath>
+@@ -166,11 +168,13 @@ namespace Clipper2Lib
+ 
+     void SetZ(const z_type z_value) { z = z_value; }
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+     friend std::ostream& operator<<(std::ostream& os, const Point& point)
+     {
+       os << point.x << "," << point.y << "," << point.z;
+       return os;
+     }
++#endif
+ 
+ #else
+ 
+@@ -203,11 +207,13 @@ namespace Clipper2Lib
+       return Point(x * scale, y * scale);
+     }
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+     friend std::ostream& operator<<(std::ostream& os, const Point& point)
+     {
+       os << point.x << "," << point.y;
+       return os;
+     }
++#endif
+ #endif
+ 
+     friend bool operator==(const Point& a, const Point& b)
+@@ -396,10 +402,12 @@ namespace Clipper2Lib
+       return result;
+     }
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+     friend std::ostream& operator<<(std::ostream& os, const Rect<T>& rect) {
+       os << "(" << rect.left << "," << rect.top << "," << rect.right << "," << rect.bottom << ") ";
+       return os;
+     }
++#endif
+   };
+ 
+   template <typename T1, typename T2>
+@@ -498,6 +506,7 @@ namespace Clipper2Lib
+     return Rect<T>(xmin, ymin, xmax, ymax);
+   }
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+   template <typename T>
+   std::ostream& operator << (std::ostream& outstream, const Path<T>& path)
+   {
+@@ -518,6 +527,7 @@ namespace Clipper2Lib
+       outstream << p;
+     return outstream;
+   }
++#endif
+ 
+ 
+   template <typename T1, typename T2>
+diff --git a/CPP/Clipper2Lib/include/clipper2/clipper.h b/CPP/Clipper2Lib/include/clipper2/clipper.h
+index fe1e299..deb1f7b 100644
+--- a/CPP/Clipper2Lib/include/clipper2/clipper.h
++++ b/CPP/Clipper2Lib/include/clipper2/clipper.h
+@@ -309,6 +309,7 @@ namespace Clipper2Lib {
+       return true;
+     }
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+     static void OutlinePolyPath(std::ostream& os,
+       size_t idx, bool isHole, size_t count, const std::string& preamble)
+     {
+@@ -338,6 +339,7 @@ namespace Clipper2Lib {
+         if (pp.Child(i)->Count())
+           details::OutlinePolyPathD(os, *pp.Child(i), i, preamble + "  ");
+     }
++#endif
+ 
+     template<typename T, typename U>
+     inline constexpr void MakePathGeneric(const T an_array,
+@@ -377,6 +379,7 @@ namespace Clipper2Lib {
+ 
+   } // end details namespace
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+   inline std::ostream& operator<< (std::ostream& os, const PolyTree64& pp)
+   {
+     std::string plural = (pp.Count() == 1) ? " polygon." : " polygons.";
+@@ -399,6 +402,7 @@ namespace Clipper2Lib {
+     if (!pp.Level()) os << std::endl;
+     return os;
+   }
++#endif
+ 
+   inline Paths64 PolyTreeToPaths64(const PolyTree64& polytree)
+   {
diff --git a/include/manifold/manifold.h b/include/manifold/manifold.h
@@ -273,8 +273,10 @@ using MeshGL = MeshGLP<float>;
  */
 using MeshGL64 = MeshGLP<double, uint64_t>;
 
+#ifndef MANIFOLD_NO_IOSTREAM
 MeshGL64 ReadOBJ(std::istream& stream);
 bool WriteOBJ(std::ostream& stream, const MeshGL64& mesh);
+#endif
 
 /**
  * @brief This library's internal representation of an oriented, 2-manifold,
@@ -517,8 +519,10 @@ class Manifold {
    * ofile.close();
    * @endcode
    */
+#ifndef MANIFOLD_NO_IOSTREAM
   static Manifold ReadOBJ(std::istream& stream);
   bool WriteOBJ(std::ostream& stream) const;
+#endif
 
   /** @name Testing Hooks
    *  These are just for internal testing.
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -80,6 +80,7 @@ set(
   MANIFOLD_ASSERT
   MANIFOLD_TIMING
   MANIFOLD_CROSS_SECTION
+  MANIFOLD_NO_IOSTREAM
   TRACY_ENABLE
   TRACY_MEMORY_USAGE
 )
@@ -94,6 +95,30 @@ else()
   target_compile_definitions(manifold PUBLIC MANIFOLD_PAR=-1)
 endif()
 
+# MANIFOLD_NO_IOSTREAM also defines MANIFOLD_NO_FILESYSTEM (the two
+# track together in practice — `<filesystem>` paths are only useful
+# if you can `<fstream>` them, which needs iostream). Source code
+# uses the macros separately for semantic clarity (NO_IOSTREAM gates
+# the iostream-using public API; NO_FILESYSTEM gates filesystem use
+# in test_main.cpp's fixture helpers + main()).
+if(MANIFOLD_NO_IOSTREAM)
+  target_compile_definitions(manifold PUBLIC MANIFOLD_NO_FILESYSTEM)
+endif()
+
+# Always-on build-time check: compiles manifold/manifold.h with
+# MANIFOLD_NO_IOSTREAM defined. Fails if iostream usage creeps into
+# the public header outside the macro guards. Independent of the
+# MANIFOLD_NO_IOSTREAM option's value (just inherits manifold's other
+# PUBLIC defines via target_link_libraries; sets the macro PRIVATE
+# only when the option isn't already setting it PUBLIC).
+add_library(manifold_no_iostream_check OBJECT no_iostream_check.cpp)
+target_link_libraries(manifold_no_iostream_check PRIVATE manifold)
+if(NOT MANIFOLD_NO_IOSTREAM)
+  target_compile_definitions(
+    manifold_no_iostream_check PRIVATE MANIFOLD_NO_IOSTREAM
+  )
+endif()
+
 target_include_directories(
   manifold
   PUBLIC
diff --git a/src/impl.cpp b/src/impl.cpp
diff --git a/src/no_iostream_check.cpp b/src/no_iostream_check.cpp
diff --git a/test/test_main.cpp b/test/test_main.cpp
