move to own git serverHEADmaster

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