aboutsummaryrefslogtreecommitdiff
path: root/vcpkg/ports/triangle/enable_64bit_architecture.patch
diff options
context:
space:
mode:
Diffstat (limited to 'vcpkg/ports/triangle/enable_64bit_architecture.patch')
-rw-r--r--vcpkg/ports/triangle/enable_64bit_architecture.patch418
1 files changed, 418 insertions, 0 deletions
diff --git a/vcpkg/ports/triangle/enable_64bit_architecture.patch b/vcpkg/ports/triangle/enable_64bit_architecture.patch
new file mode 100644
index 0000000..9ad7b80
--- /dev/null
+++ b/vcpkg/ports/triangle/enable_64bit_architecture.patch
@@ -0,0 +1,418 @@
+ triangle.c | 116 ++++++++++++++++++++++++++-----------------------------------
+ triangle.h | 29 +++++++++-------
+ 2 files changed, 66 insertions(+), 79 deletions(-)
+
+diff --git a/triangle.c b/triangle.c
+index f7a5700..084902e 100644
+--- a/triangle.c
++++ b/triangle.c
+@@ -194,27 +194,8 @@
+ /* */
+ /*****************************************************************************/
+
+-/* For single precision (which will save some memory and reduce paging), */
+-/* define the symbol SINGLE by using the -DSINGLE compiler switch or by */
+-/* writing "#define SINGLE" below. */
+-/* */
+-/* For double precision (which will allow you to refine meshes to a smaller */
+-/* edge length), leave SINGLE undefined. */
+-/* */
+-/* Double precision uses more memory, but improves the resolution of the */
+-/* meshes you can generate with Triangle. It also reduces the likelihood */
+-/* of a floating exception due to overflow. Finally, it is much faster */
+-/* than single precision on 64-bit architectures like the DEC Alpha. I */
+-/* recommend double precision unless you want to generate a mesh for which */
+-/* you do not have enough memory. */
+-
+-/* #define SINGLE */
+-
+-#ifdef SINGLE
+-#define REAL float
+-#else /* not SINGLE */
+ #define REAL double
+-#endif /* not SINGLE */
++#define VOID void
+
+ /* If yours is not a Unix system, define the NO_TIMER compiler switch to */
+ /* remove the Unix-specific timing code. */
+@@ -308,12 +289,6 @@
+ #define DEADVERTEX -32768
+ #define UNDEADVERTEX -32767
+
+-/* The next line is used to outsmart some very stupid compilers. If your */
+-/* compiler is smarter, feel free to replace the "int" with "void". */
+-/* Not that it matters. */
+-
+-#define VOID int
+-
+ /* Two constants for algorithms based on random sampling. Both constants */
+ /* have been chosen empirically to optimize their respective algorithms. */
+
+@@ -340,6 +315,7 @@
+
+ #define ONETHIRD 0.333333333333333333333333333333333333333333333333333333333333
+
++#include <stdint.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+@@ -938,16 +914,16 @@ int minus1mod3[3] = {2, 0, 1};
+ /* extracted from the two least significant bits of the pointer. */
+
+ #define decode(ptr, otri) \
+- (otri).orient = (int) ((unsigned long) (ptr) & (unsigned long) 3l); \
++ (otri).orient = (int) ((uintptr_t) (ptr) & (uintptr_t) 3l); \
+ (otri).tri = (triangle *) \
+- ((unsigned long) (ptr) ^ (unsigned long) (otri).orient)
++ ((uintptr_t) (ptr) ^ (uintptr_t) (otri).orient)
+
+ /* encode() compresses an oriented triangle into a single pointer. It */
+ /* relies on the assumption that all triangles are aligned to four-byte */
+ /* boundaries, so the two least significant bits of (otri).tri are zero. */
+
+ #define encode(otri) \
+- (triangle) ((unsigned long) (otri).tri | (unsigned long) (otri).orient)
++ (triangle) ((uintptr_t) (otri).tri | (uintptr_t) (otri).orient)
+
+ /* The following handle manipulation primitives are all described by Guibas */
+ /* and Stolfi. However, Guibas and Stolfi use an edge-based data */
+@@ -1111,16 +1087,16 @@ int minus1mod3[3] = {2, 0, 1};
+
+ #define infect(otri) \
+ (otri).tri[6] = (triangle) \
+- ((unsigned long) (otri).tri[6] | (unsigned long) 2l)
++ ((uintptr_t) (otri).tri[6] | (uintptr_t) 2l)
+
+ #define uninfect(otri) \
+ (otri).tri[6] = (triangle) \
+- ((unsigned long) (otri).tri[6] & ~ (unsigned long) 2l)
++ ((uintptr_t) (otri).tri[6] & ~ (uintptr_t) 2l)
+
+ /* Test a triangle for viral infection. */
+
+ #define infected(otri) \
+- (((unsigned long) (otri).tri[6] & (unsigned long) 2l) != 0l)
++ (((uintptr_t) (otri).tri[6] & (uintptr_t) 2l) != 0l)
+
+ /* Check or set a triangle's attributes. */
+
+@@ -1158,16 +1134,16 @@ int minus1mod3[3] = {2, 0, 1};
+ /* are masked out to produce the real pointer. */
+
+ #define sdecode(sptr, osub) \
+- (osub).ssorient = (int) ((unsigned long) (sptr) & (unsigned long) 1l); \
++ (osub).ssorient = (int) ((uintptr_t) (sptr) & (uintptr_t) 1l); \
+ (osub).ss = (subseg *) \
+- ((unsigned long) (sptr) & ~ (unsigned long) 3l)
++ ((uintptr_t) (sptr) & ~ (uintptr_t) 3l)
+
+ /* sencode() compresses an oriented subsegment into a single pointer. It */
+ /* relies on the assumption that all subsegments are aligned to two-byte */
+ /* boundaries, so the least significant bit of (osub).ss is zero. */
+
+ #define sencode(osub) \
+- (subseg) ((unsigned long) (osub).ss | (unsigned long) (osub).ssorient)
++ (subseg) ((uintptr_t) (osub).ss | (uintptr_t) (osub).ssorient)
+
+ /* ssym() toggles the orientation of a subsegment. */
+
+@@ -3891,7 +3867,7 @@ struct memorypool *pool;
+ #endif /* not ANSI_DECLARATORS */
+
+ {
+- unsigned long alignptr;
++ uintptr_t alignptr = 0;
+
+ pool->items = 0;
+ pool->maxitems = 0;
+@@ -3899,11 +3875,11 @@ struct memorypool *pool;
+ /* Set the currently active block. */
+ pool->nowblock = pool->firstblock;
+ /* Find the first item in the pool. Increment by the size of (VOID *). */
+- alignptr = (unsigned long) (pool->nowblock + 1);
++ alignptr = (uintptr_t) (pool->nowblock + 1);
+ /* Align the item on an `alignbytes'-byte boundary. */
+ pool->nextitem = (VOID *)
+- (alignptr + (unsigned long) pool->alignbytes -
+- (alignptr % (unsigned long) pool->alignbytes));
++ (alignptr + (uintptr_t) pool->alignbytes -
++ (alignptr % (uintptr_t) pool->alignbytes));
+ /* There are lots of unallocated items left in this block. */
+ pool->unallocateditems = pool->itemsfirstblock;
+ /* The stack of deallocated items is empty. */
+@@ -4008,7 +3984,7 @@ struct memorypool *pool;
+ {
+ VOID *newitem;
+ VOID **newblock;
+- unsigned long alignptr;
++ uintptr_t alignptr = 0;
+
+ /* First check the linked list of dead items. If the list is not */
+ /* empty, allocate an item from the list rather than a fresh one. */
+@@ -4033,11 +4009,11 @@ struct memorypool *pool;
+ pool->nowblock = (VOID **) *(pool->nowblock);
+ /* Find the first item in the block. */
+ /* Increment by the size of (VOID *). */
+- alignptr = (unsigned long) (pool->nowblock + 1);
++ alignptr = (uintptr_t) (pool->nowblock + 1);
+ /* Align the item on an `alignbytes'-byte boundary. */
+ pool->nextitem = (VOID *)
+- (alignptr + (unsigned long) pool->alignbytes -
+- (alignptr % (unsigned long) pool->alignbytes));
++ (alignptr + (uintptr_t) pool->alignbytes -
++ (alignptr % (uintptr_t) pool->alignbytes));
+ /* There are lots of unallocated items left in this block. */
+ pool->unallocateditems = pool->itemsperblock;
+ }
+@@ -4092,16 +4068,16 @@ struct memorypool *pool;
+ #endif /* not ANSI_DECLARATORS */
+
+ {
+- unsigned long alignptr;
++ uintptr_t alignptr = 0;
+
+ /* Begin the traversal in the first block. */
+ pool->pathblock = pool->firstblock;
+ /* Find the first item in the block. Increment by the size of (VOID *). */
+- alignptr = (unsigned long) (pool->pathblock + 1);
++ alignptr = (uintptr_t) (pool->pathblock + 1);
+ /* Align with item on an `alignbytes'-byte boundary. */
+ pool->pathitem = (VOID *)
+- (alignptr + (unsigned long) pool->alignbytes -
+- (alignptr % (unsigned long) pool->alignbytes));
++ (alignptr + (uintptr_t) pool->alignbytes -
++ (alignptr % (uintptr_t) pool->alignbytes));
+ /* Set the number of items left in the current block. */
+ pool->pathitemsleft = pool->itemsfirstblock;
+ }
+@@ -4129,7 +4105,7 @@ struct memorypool *pool;
+
+ {
+ VOID *newitem;
+- unsigned long alignptr;
++ uintptr_t alignptr = 0;
+
+ /* Stop upon exhausting the list of items. */
+ if (pool->pathitem == pool->nextitem) {
+@@ -4141,11 +4117,11 @@ struct memorypool *pool;
+ /* Find the next block. */
+ pool->pathblock = (VOID **) *(pool->pathblock);
+ /* Find the first item in the block. Increment by the size of (VOID *). */
+- alignptr = (unsigned long) (pool->pathblock + 1);
++ alignptr = (uintptr_t) (pool->pathblock + 1);
+ /* Align with item on an `alignbytes'-byte boundary. */
+ pool->pathitem = (VOID *)
+- (alignptr + (unsigned long) pool->alignbytes -
+- (alignptr % (unsigned long) pool->alignbytes));
++ (alignptr + (uintptr_t) pool->alignbytes -
++ (alignptr % (uintptr_t) pool->alignbytes));
+ /* Set the number of items left in the current block. */
+ pool->pathitemsleft = pool->itemsperblock;
+ }
+@@ -4197,16 +4173,16 @@ int subsegbytes;
+ #endif /* not ANSI_DECLARATORS */
+
+ {
+- unsigned long alignptr;
++ uintptr_t alignptr = 0;
+
+ /* Set up `dummytri', the `triangle' that occupies "outer space." */
+ m->dummytribase = (triangle *) trimalloc(trianglebytes +
+ m->triangles.alignbytes);
+ /* Align `dummytri' on a `triangles.alignbytes'-byte boundary. */
+- alignptr = (unsigned long) m->dummytribase;
++ alignptr = (uintptr_t) m->dummytribase;
+ m->dummytri = (triangle *)
+- (alignptr + (unsigned long) m->triangles.alignbytes -
+- (alignptr % (unsigned long) m->triangles.alignbytes));
++ (alignptr + (uintptr_t) m->triangles.alignbytes -
++ (alignptr % (uintptr_t) m->triangles.alignbytes));
+ /* Initialize the three adjoining triangles to be "outer space." These */
+ /* will eventually be changed by various bonding operations, but their */
+ /* values don't really matter, as long as they can legally be */
+@@ -4226,10 +4202,10 @@ int subsegbytes;
+ m->dummysubbase = (subseg *) trimalloc(subsegbytes +
+ m->subsegs.alignbytes);
+ /* Align `dummysub' on a `subsegs.alignbytes'-byte boundary. */
+- alignptr = (unsigned long) m->dummysubbase;
++ alignptr = (uintptr_t) m->dummysubbase;
+ m->dummysub = (subseg *)
+- (alignptr + (unsigned long) m->subsegs.alignbytes -
+- (alignptr % (unsigned long) m->subsegs.alignbytes));
++ (alignptr + (uintptr_t) m->subsegs.alignbytes -
++ (alignptr % (uintptr_t) m->subsegs.alignbytes));
+ /* Initialize the two adjoining subsegments to be the omnipresent */
+ /* subsegment. These will eventually be changed by various bonding */
+ /* operations, but their values don't really matter, as long as they */
+@@ -4586,7 +4562,7 @@ int number;
+ {
+ VOID **getblock;
+ char *foundvertex;
+- unsigned long alignptr;
++ uintptr_t alignptr = 0;
+ int current;
+
+ getblock = m->vertices.firstblock;
+@@ -4603,9 +4579,9 @@ int number;
+ }
+
+ /* Now find the right vertex. */
+- alignptr = (unsigned long) (getblock + 1);
+- foundvertex = (char *) (alignptr + (unsigned long) m->vertices.alignbytes -
+- (alignptr % (unsigned long) m->vertices.alignbytes));
++ alignptr = (uintptr_t) (getblock + 1);
++ foundvertex = (char *) (alignptr + (uintptr_t) m->vertices.alignbytes -
++ (alignptr % (uintptr_t) m->vertices.alignbytes));
+ return (vertex) (foundvertex + m->vertices.itembytes * (number - current));
+ }
+
+@@ -4883,6 +4859,7 @@ struct osub *newsubseg;
+ /* */
+ /*****************************************************************************/
+
++static
+ void exactinit()
+ {
+ REAL half;
+@@ -4956,6 +4933,7 @@ void exactinit()
+ /* */
+ /*****************************************************************************/
+
++static
+ #ifdef ANSI_DECLARATORS
+ int fast_expansion_sum_zeroelim(int elen, REAL *e, int flen, REAL *f, REAL *h)
+ #else /* not ANSI_DECLARATORS */
+@@ -5050,6 +5028,7 @@ REAL *h;
+ /* */
+ /*****************************************************************************/
+
++static
+ #ifdef ANSI_DECLARATORS
+ int scale_expansion_zeroelim(int elen, REAL *e, REAL b, REAL *h)
+ #else /* not ANSI_DECLARATORS */
+@@ -5106,6 +5085,7 @@ REAL *h;
+ /* */
+ /*****************************************************************************/
+
++static
+ #ifdef ANSI_DECLARATORS
+ REAL estimate(int elen, REAL *e)
+ #else /* not ANSI_DECLARATORS */
+@@ -5303,6 +5283,7 @@ vertex pc;
+ /* */
+ /*****************************************************************************/
+
++static
+ #ifdef ANSI_DECLARATORS
+ REAL incircleadapt(vertex pa, vertex pb, vertex pc, vertex pd, REAL permanent)
+ #else /* not ANSI_DECLARATORS */
+@@ -5882,6 +5863,7 @@ REAL permanent;
+ return finnow[finlength - 1];
+ }
+
++static
+ #ifdef ANSI_DECLARATORS
+ REAL incircle(struct mesh *m, struct behavior *b,
+ vertex pa, vertex pb, vertex pc, vertex pd)
+@@ -5964,6 +5946,7 @@ vertex pd;
+ /* */
+ /*****************************************************************************/
+
++static
+ #ifdef ANSI_DECLARATORS
+ REAL orient3dadapt(vertex pa, vertex pb, vertex pc, vertex pd,
+ REAL aheight, REAL bheight, REAL cheight, REAL dheight,
+@@ -6389,6 +6372,7 @@ REAL permanent;
+ return finnow[finlength - 1];
+ }
+
++static
+ #ifdef ANSI_DECLARATORS
+ REAL orient3d(struct mesh *m, struct behavior *b,
+ vertex pa, vertex pb, vertex pc, vertex pd,
+@@ -7649,7 +7633,7 @@ struct otri *searchtri;
+ char *firsttri;
+ struct otri sampletri;
+ vertex torg, tdest;
+- unsigned long alignptr;
++ uintptr_t alignptr = 0;
+ REAL searchdist, dist;
+ REAL ahead;
+ long samplesperblock, totalsamplesleft, samplesleft;
+@@ -7721,11 +7705,11 @@ struct otri *searchtri;
+ population = totalpopulation;
+ }
+ /* Find a pointer to the first triangle in the block. */
+- alignptr = (unsigned long) (sampleblock + 1);
++ alignptr = (uintptr_t) (sampleblock + 1);
+ firsttri = (char *) (alignptr +
+- (unsigned long) m->triangles.alignbytes -
++ (uintptr_t) m->triangles.alignbytes -
+ (alignptr %
+- (unsigned long) m->triangles.alignbytes));
++ (uintptr_t) m->triangles.alignbytes));
+
+ /* Choose `samplesleft' randomly sampled triangles in this block. */
+ do {
+diff --git a/triangle.h b/triangle.h
+index 9df1f39..8d9c754 100644
+--- a/triangle.h
++++ b/triangle.h
+@@ -248,16 +248,20 @@
+ /* */
+ /*****************************************************************************/
+
++#ifdef __cplusplus
++extern "C" {
++#endif
++
+ struct triangulateio {
+- REAL *pointlist; /* In / out */
+- REAL *pointattributelist; /* In / out */
++ double *pointlist; /* In / out */
++ double *pointattributelist; /* In / out */
+ int *pointmarkerlist; /* In / out */
+ int numberofpoints; /* In / out */
+ int numberofpointattributes; /* In / out */
+
+ int *trianglelist; /* In / out */
+- REAL *triangleattributelist; /* In / out */
+- REAL *trianglearealist; /* In only */
++ double *triangleattributelist; /* In / out */
++ double *trianglearealist; /* In only */
+ int *neighborlist; /* Out only */
+ int numberoftriangles; /* In / out */
+ int numberofcorners; /* In / out */
+@@ -267,23 +271,22 @@ struct triangulateio {
+ int *segmentmarkerlist; /* In / out */
+ int numberofsegments; /* In / out */
+
+- REAL *holelist; /* In / pointer to array copied out */
++ double *holelist; /* In / pointer to array copied out */
+ int numberofholes; /* In / copied out */
+
+- REAL *regionlist; /* In / pointer to array copied out */
++ double *regionlist; /* In / pointer to array copied out */
+ int numberofregions; /* In / copied out */
+
+ int *edgelist; /* Out only */
+ int *edgemarkerlist; /* Not used with Voronoi diagram; out only */
+- REAL *normlist; /* Used only with Voronoi diagram; out only */
++ double *normlist; /* Used only with Voronoi diagram; out only */
+ int numberofedges; /* Out only */
+ };
+
+-#ifdef ANSI_DECLARATORS
+ void triangulate(char *, struct triangulateio *, struct triangulateio *,
+ struct triangulateio *);
+-void trifree(VOID *memptr);
+-#else /* not ANSI_DECLARATORS */
+-void triangulate();
+-void trifree();
+-#endif /* not ANSI_DECLARATORS */
++void trifree(void *memptr);
++
++#ifdef __cplusplus
++}
++#endif
+\ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-15 00:54:42 +0000