fix compilation errors

CMakeLists.txt

@@ -86,7 +86,7 @@ if (MSVC)
   set(MANIFOLD_FLAGS ${MANIFOLD_FLAGS} /DNOMINMAX)
 else()
   if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    set(WARNING_FLAGS -Werror -Wall -Wno-sign-compare -Wno-unused -Wno-array-bounds -Wno-stringop-overflow)
+    set(WARNING_FLAGS -Werror -Wall -Wno-sign-compare -Wno-unused -Wno-array-bounds -Wno-stringop-overflow -Wno-alloc-size-larger-than)
   else()
     set(WARNING_FLAGS -Werror -Wall -Wno-sign-compare -Wno-unused)
   endif()

src/manifold/src/boolean3.cpp

@@ -92,9 +92,12 @@ SparseIndices Filter11(const Manifold::Impl &inP, const Manifold::Impl &inQ,
                        const SparseIndices &p1q2, const SparseIndices &p2q1) {
   ZoneScoped;
   SparseIndices p1q1(3 * p1q2.size() + 3 * p2q1.size());
-  for_each_n(autoPolicy(p1q2.size()), zip(countAt(0ul), countAt(0ul)),
-             p1q2.size(), CopyFaceEdges<false>({p1q2, p1q1, inQ.halfedge_}));
-  for_each_n(autoPolicy(p2q1.size()), zip(countAt(p1q2.size()), countAt(0ul)),
+  for_each_n(
+      autoPolicy(p1q2.size()),
+      zip(countAt(static_cast<size_t>(0)), countAt(static_cast<size_t>(0))),
+      p1q2.size(), CopyFaceEdges<false>({p1q2, p1q1, inQ.halfedge_}));
+  for_each_n(autoPolicy(p2q1.size()),
+             zip(countAt(p1q2.size()), countAt(static_cast<size_t>(0))),
              p2q1.size(), CopyFaceEdges<true>({p2q1, p1q1, inP.halfedge_}));
   p1q1.Unique();
   return p1q1;
@@ -261,7 +264,8 @@ std::tuple<Vec<int>, Vec<glm::vec4>> Shadow11(SparseIndices &p1q1,
   Vec<glm::vec4> xyzz11(p1q1.size());
 
   for_each_n(autoPolicy(p1q1.size()),
-             zip(countAt(0ul), xyzz11.begin(), s11.begin()), p1q1.size(),
+             zip(countAt(static_cast<size_t>(0)), xyzz11.begin(), s11.begin()),
+             p1q1.size(),
              Kernel11({inP.vertPos_, inQ.vertPos_, inP.halfedge_, inQ.halfedge_,
                        expandP, inP.vertNormal_, p1q1}));
 
@@ -352,7 +356,8 @@ std::tuple<Vec<int>, Vec<float>> Shadow02(const Manifold::Impl &inP,
 
   auto vertNormalP = forward ? inP.vertNormal_ : inQ.vertNormal_;
   for_each_n(autoPolicy(p0q2.size()),
-             zip(countAt(0ul), s02.begin(), z02.begin()), p0q2.size(),
+             zip(countAt(static_cast<size_t>(0)), s02.begin(), z02.begin()),
+             p0q2.size(),
              Kernel02({inP.vertPos_, inQ.halfedge_, inQ.vertPos_, expandP,
                        vertNormalP, p0q2, forward}));
 
@@ -456,7 +461,8 @@ std::tuple<Vec<int>, Vec<glm::vec3>> Intersect12(
   Vec<glm::vec3> v12(p1q2.size());
 
   for_each_n(
-      autoPolicy(p1q2.size()), zip(countAt(0ul), x12.begin(), v12.begin()),
+      autoPolicy(p1q2.size()),
+      zip(countAt(static_cast<size_t>(0)), x12.begin(), v12.begin()),
       p1q2.size(),
       Kernel12({p0q2.AsVec64(), s02, z02, p1q1.AsVec64(), s11, xyzz11,
                 inP.halfedge_, inQ.halfedge_, inP.vertPos_, forward, p1q2}));

src/manifold/src/boolean_result.cpp

@@ -222,7 +222,7 @@ void AddNewEdgeVerts(
         [&](size_t hash) { mutexes[hash % mutexes.size()].unlock(); },
         std::placeholders::_1);
     tbb::parallel_for(
-        tbb::blocked_range<size_t>(0ul, p1q2.size(), 32),
+        tbb::blocked_range<size_t>(static_cast<size_t>(0), p1q2.size(), 32),
         [&](const tbb::blocked_range<size_t> &range) {
           for (size_t i = range.begin(); i != range.end(); i++) processFun(i);
         },

src/manifold/src/edge_op.cpp

@@ -191,7 +191,7 @@ void Manifold::Impl::SimplifyTopology() {
     ZoneScopedN("CollapseShortEdge");
     numFlagged = 0;
     ShortEdge se{halfedge_, vertPos_, precision_};
-    for_each_n(policy, countAt(0ul), nbEdges,
+    for_each_n(policy, countAt(static_cast<size_t>(0)), nbEdges,
                [&](size_t i) { bflags[i] = se(i); });
     for (size_t i = 0; i < nbEdges; ++i) {
       if (bflags[i]) {
@@ -213,7 +213,7 @@ void Manifold::Impl::SimplifyTopology() {
     ZoneScopedN("CollapseFlaggedEdge");
     numFlagged = 0;
     FlagEdge se{halfedge_, meshRelation_.triRef};
-    for_each_n(policy, countAt(0ul), nbEdges,
+    for_each_n(policy, countAt(static_cast<size_t>(0)), nbEdges,
                [&](size_t i) { bflags[i] = se(i); });
     for (size_t i = 0; i < nbEdges; ++i) {
       if (bflags[i]) {
@@ -235,7 +235,7 @@ void Manifold::Impl::SimplifyTopology() {
     ZoneScopedN("RecursiveEdgeSwap");
     numFlagged = 0;
     SwappableEdge se{halfedge_, vertPos_, faceNormal_, precision_};
-    for_each_n(policy, countAt(0ul), nbEdges,
+    for_each_n(policy, countAt(static_cast<size_t>(0)), nbEdges,
                [&](size_t i) { bflags[i] = se(i); });
     std::vector<int> edgeSwapStack;
     std::vector<int> visited(halfedge_.size(), -1);

src/manifold/src/face_op.cpp

@@ -140,7 +140,7 @@ void Manifold::Impl::Face2Tri(const Vec<int>& faceEdge,
   triCount.back() = 0;
   // precompute number of triangles per face, and launch async tasks to
   // triangulate complex faces
-  for_each(autoPolicy(faceEdge.size()), countAt(0ul),
+  for_each(autoPolicy(faceEdge.size()), countAt(static_cast<size_t>(0)),
            countAt(faceEdge.size() - 1), [&](size_t face) {
              triCount[face] = faceEdge[face + 1] - faceEdge[face] - 2;
              ASSERT(triCount[face] >= 1, topologyErr,
@@ -155,7 +155,7 @@ void Manifold::Impl::Face2Tri(const Vec<int>& faceEdge,
   group.wait();
   // prefix sum computation (assign unique index to each face) and preallocation
   exclusive_scan(autoPolicy(triCount.size()), triCount.begin(), triCount.end(),
-                 triCount.begin(), 0ul);
+                 triCount.begin(), static_cast<size_t>(0));
   if (triCount.back() >= std::numeric_limits<int>::max())
     throw std::out_of_range("too many triangles");
   triVerts.resize(triCount.back());
@@ -172,7 +172,7 @@ void Manifold::Impl::Face2Tri(const Vec<int>& faceEdge,
       },
       std::placeholders::_1);
   // set triangles in parallel
-  for_each(autoPolicy(faceEdge.size()), countAt(0ul),
+  for_each(autoPolicy(faceEdge.size()), countAt(static_cast<size_t>(0)),
            countAt(faceEdge.size() - 1), processFace2);
 #else
   triVerts.reserve(faceEdge.size());

src/manifold/src/impl.cpp

@@ -882,10 +882,10 @@ SparseIndices Manifold::Impl::EdgeCollisions(const Impl& Q,
     q1p2 = collider_.Collisions<false, false>(QedgeBB.cview());
 
   if (inverted)
-    for_each(policy, countAt(0ul), countAt(q1p2.size()),
+    for_each(policy, countAt(static_cast<size_t>(0)), countAt(q1p2.size()),
              ReindexEdge<true>({edges, q1p2}));
   else
-    for_each(policy, countAt(0ul), countAt(q1p2.size()),
+    for_each(policy, countAt(static_cast<size_t>(0)), countAt(q1p2.size()),
              ReindexEdge<false>({edges, q1p2}));
   return q1p2;
 }

src/manifold/src/properties.cpp

@@ -275,7 +275,8 @@ bool Manifold::Impl::IsManifold() const {
   if (halfedge_.size() == 0) return true;
   auto policy = autoPolicy(halfedge_.size());
 
-  return all_of(policy, countAt(0ul), countAt(halfedge_.size()),
+  return all_of(policy, countAt(static_cast<size_t>(0)),
+                countAt(halfedge_.size()),
                 CheckHalfedges({halfedge_, vertPos_}));
 }
 

src/sdf/src/sdf.cpp

@@ -325,7 +325,7 @@ Mesh LevelSet(std::function<float(glm::vec3)> sdf, Box bounds, float edgeLength,
 
   while (1) {
     Vec<int> index(1, 0);
-    for_each_n(pol, countAt(0ul), maxMorton + 1,
+    for_each_n(pol, countAt(static_cast<size_t>(0)), maxMorton + 1,
                ComputeVerts({vertPos, index, gridVerts.D(), sdf, bounds.min,
                              gridSize + 1, spacing, level}));
 
@@ -349,7 +349,7 @@ Mesh LevelSet(std::function<float(glm::vec3)> sdf, Box bounds, float edgeLength,
   Vec<glm::ivec3> triVerts(gridVerts.Entries() * 12);  // worst case
 
   Vec<int> index(1, 0);
-  for_each_n(pol, countAt(0ul), gridVerts.Size(),
+  for_each_n(pol, countAt(static_cast<size_t>(0)), gridVerts.Size(),
              BuildTris({triVerts, index, gridVerts.D()}));
   triVerts.resize(index[0]);
 

src/utilities/include/sparse.h

@@ -57,7 +57,8 @@ class SparseIndices {
     size_t offset = pOffset;
     if (use_q) offset = 1 - offset;
     const int* p = ptr();
-    for_each(autoPolicy(out.size()), countAt(0ul), countAt(out.size()),
+    for_each(autoPolicy(out.size()), countAt(static_cast<size_t>(0)),
+             countAt(out.size()),
              [&](size_t i) { out[i] = p[i * 2 + offset]; });
     return out;
   }