00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include <stdio.h>
00013 #include <string.h>
00014
00015
00016
00017
00018 #include "qset.h"
00019 #include "mem.h"
00020
00021 #ifndef qhDEFqhull
00022 typedef struct ridgeT ridgeT;
00023 typedef struct facetT facetT;
00024 void qh_errexit(int exitcode, facetT *, ridgeT *);
00025 #endif
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038 #define SETsizeaddr_(set) (&((set)->e[(set)->maxsize].i))
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059 void qh_setaddnth(setT **setp, int nth, void *newelem) {
00060 int *sizep, oldsize, i;
00061 void **oldp, **newp;
00062
00063 if (!*setp || !*(sizep= SETsizeaddr_(*setp))) {
00064 qh_setlarger(setp);
00065 sizep= SETsizeaddr_(*setp);
00066 }
00067 oldsize= *sizep - 1;
00068 if (nth < 0 || nth > oldsize) {
00069 fprintf (qhmem.ferr, "qhull internal error (qh_setaddnth): nth %d is out-of-bounds for set:\n", nth);
00070 qh_setprint (qhmem.ferr, "", *setp);
00071 qh_errexit (qhmem_ERRqhull, NULL, NULL);
00072 }
00073 (*sizep)++;
00074 oldp= SETelemaddr_(*setp, oldsize, void);
00075 newp= oldp+1;
00076 for (i= oldsize-nth+1; i--; )
00077 *(newp--)= *(oldp--);
00078 *newp= newelem;
00079 }
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097 void qh_setaddsorted(setT **setp, void *newelem) {
00098 int newindex=0;
00099 void *elem, **elemp;
00100
00101 FOREACHelem_(*setp) {
00102 if (elem < newelem)
00103 newindex++;
00104 else if (elem == newelem)
00105 return;
00106 else
00107 break;
00108 }
00109 qh_setaddnth(setp, newindex, newelem);
00110 }
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128 void qh_setappend(setT **setp, void *newelem) {
00129 int *sizep;
00130 void **endp;
00131
00132 if (!newelem)
00133 return;
00134 if (!*setp || !*(sizep= SETsizeaddr_(*setp))) {
00135 qh_setlarger(setp);
00136 sizep= SETsizeaddr_(*setp);
00137 }
00138 *(endp= &((*setp)->e[(*sizep)++ - 1].p))= newelem;
00139 *(++endp)= NULL;
00140 }
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157 void qh_setappend_set(setT **setp, setT *setA) {
00158 int *sizep, sizeA, size;
00159 setT *oldset;
00160
00161 if (!setA)
00162 return;
00163 SETreturnsize_(setA, sizeA);
00164 if (!*setp)
00165 *setp= qh_setnew (sizeA);
00166 sizep= SETsizeaddr_(*setp);
00167 if (!(size= *sizep))
00168 size= (*setp)->maxsize;
00169 else
00170 size--;
00171 if (size + sizeA > (*setp)->maxsize) {
00172 oldset= *setp;
00173 *setp= qh_setcopy (oldset, sizeA);
00174 qh_setfree (&oldset);
00175 sizep= SETsizeaddr_(*setp);
00176 }
00177 *sizep= size+sizeA+1;
00178 if (sizeA > 0)
00179 memcpy((char *)&((*setp)->e[size].p), (char *)&(setA->e[0].p), SETelemsize *(sizeA+1));
00180 }
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199 void qh_setappend2ndlast(setT **setp, void *newelem) {
00200 int *sizep;
00201 void **endp, **lastp;
00202
00203 if (!*setp || !*(sizep= SETsizeaddr_(*setp))) {
00204 qh_setlarger(setp);
00205 sizep= SETsizeaddr_(*setp);
00206 }
00207 endp= SETelemaddr_(*setp, (*sizep)++ -1, void);
00208 lastp= endp-1;
00209 *(endp++)= *lastp;
00210 *endp= NULL;
00211 *lastp= newelem;
00212 }
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225 void qh_setcheck(setT *set, char *tname, int id) {
00226 int maxsize, size;
00227 int waserr= 0;
00228
00229 if (!set)
00230 return;
00231 SETreturnsize_(set, size);
00232 maxsize= set->maxsize;
00233 if (size > maxsize || !maxsize) {
00234 fprintf (qhmem.ferr, "qhull internal error (qh_setcheck): actual size %d of %s%d is greater than max size %d\n",
00235 size, tname, id, maxsize);
00236 waserr= 1;
00237 }else if (set->e[size].p) {
00238 fprintf (qhmem.ferr, "qhull internal error (qh_setcheck): %s%d (size %d max %d) is not null terminated.\n",
00239 tname, id, maxsize, size-1);
00240 waserr= 1;
00241 }
00242 if (waserr) {
00243 qh_setprint (qhmem.ferr, "ERRONEOUS", set);
00244 qh_errexit (qhmem_ERRqhull, NULL, NULL);
00245 }
00246 }
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267 void qh_setcompact(setT *set) {
00268 int size;
00269 void **destp, **elemp, **endp, **firstp;
00270
00271 if (!set)
00272 return;
00273 SETreturnsize_(set, size);
00274 destp= elemp= firstp= SETaddr_(set, void);
00275 endp= destp + size;
00276 while (1) {
00277 if (!(*destp++ = *elemp++)) {
00278 destp--;
00279 if (elemp > endp)
00280 break;
00281 }
00282 }
00283 qh_settruncate (set, destp-firstp);
00284 }
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301 setT *qh_setcopy(setT *set, int extra) {
00302 setT *newset;
00303 int size;
00304
00305 if (extra < 0)
00306 extra= 0;
00307 SETreturnsize_(set, size);
00308 newset= qh_setnew(size+extra);
00309 *SETsizeaddr_(newset)= size+1;
00310 memcpy((char *)&(newset->e[0].p), (char *)&(set->e[0].p), SETelemsize *(size+1));
00311 return (newset);
00312 }
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335 void *qh_setdel(setT *set, void *oldelem) {
00336 void **elemp, **lastp;
00337 int *sizep;
00338
00339 if (!set)
00340 return NULL;
00341 elemp= SETaddr_(set, void);
00342 while (*elemp != oldelem && *elemp)
00343 elemp++;
00344 if (*elemp) {
00345 sizep= SETsizeaddr_(set);
00346 if (!(*sizep)--)
00347 *sizep= set->maxsize;
00348 lastp= SETelemaddr_(set, *sizep-1, void);
00349 *elemp= *lastp;
00350 *lastp= NULL;
00351 return oldelem;
00352 }
00353 return NULL;
00354 }
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372
00373
00374 void *qh_setdellast(setT *set) {
00375 int setsize;
00376 int maxsize;
00377 int *sizep;
00378 void *returnvalue;
00379
00380 if (!set || !(set->e[0].p))
00381 return NULL;
00382 sizep= SETsizeaddr_(set);
00383 if ((setsize= *sizep)) {
00384 returnvalue= set->e[setsize - 2].p;
00385 set->e[setsize - 2].p= NULL;
00386 (*sizep)--;
00387 }else {
00388 maxsize= set->maxsize;
00389 returnvalue= set->e[maxsize - 1].p;
00390 set->e[maxsize - 1].p= NULL;
00391 *sizep= maxsize;
00392 }
00393 return returnvalue;
00394 }
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414 void *qh_setdelnth(setT *set, int nth) {
00415 void **elemp, **lastp, *elem;
00416 int *sizep;
00417
00418
00419 elemp= SETelemaddr_(set, nth, void);
00420 sizep= SETsizeaddr_(set);
00421 if (!(*sizep)--)
00422 *sizep= set->maxsize;
00423 if (nth < 0 || nth >= *sizep) {
00424 fprintf (qhmem.ferr, "qhull internal error (qh_setaddnth): nth %d is out-of-bounds for set:\n", nth);
00425 qh_setprint (qhmem.ferr, "", set);
00426 qh_errexit (qhmem_ERRqhull, NULL, NULL);
00427 }
00428 lastp= SETelemaddr_(set, *sizep-1, void);
00429 elem= *elemp;
00430 *elemp= *lastp;
00431 *lastp= NULL;
00432 return elem;
00433 }
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455 void *qh_setdelnthsorted(setT *set, int nth) {
00456 void **newp, **oldp, *elem;
00457 int *sizep;
00458
00459 sizep= SETsizeaddr_(set);
00460 if (nth < 0 || (*sizep && nth >= *sizep-1) || nth >= set->maxsize) {
00461 fprintf (qhmem.ferr, "qhull internal error (qh_setaddnth): nth %d is out-of-bounds for set:\n", nth);
00462 qh_setprint (qhmem.ferr, "", set);
00463 qh_errexit (qhmem_ERRqhull, NULL, NULL);
00464 }
00465 newp= SETelemaddr_(set, nth, void);
00466 elem= *newp;
00467 oldp= newp+1;
00468 while ((*(newp++)= *(oldp++)))
00469 ;
00470 if (!(*sizep)--)
00471 *sizep= set->maxsize;
00472 return elem;
00473 }
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493 void *qh_setdelsorted(setT *set, void *oldelem) {
00494 void **newp, **oldp;
00495 int *sizep;
00496
00497 if (!set)
00498 return NULL;
00499 newp= SETaddr_(set, void);
00500 while(*newp != oldelem && *newp)
00501 newp++;
00502 if (*newp) {
00503 oldp= newp+1;
00504 while ((*(newp++)= *(oldp++)))
00505 ;
00506 sizep= SETsizeaddr_(set);
00507 if (!(*sizep)--)
00508 *sizep= set->maxsize;
00509 return oldelem;
00510 }
00511 return NULL;
00512 }
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530 setT *qh_setduplicate (setT *set, int elemsize) {
00531 void *elem, **elemp, *newElem;
00532 setT *newSet;
00533 int size;
00534
00535 if (!(size= qh_setsize (set)))
00536 return NULL;
00537 newSet= qh_setnew (size);
00538 FOREACHelem_(set) {
00539 newElem= qh_memalloc (elemsize);
00540 memcpy (newElem, elem, elemsize);
00541 qh_setappend (&newSet, newElem);
00542 }
00543 return newSet;
00544 }
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561 int qh_setequal(setT *setA, setT *setB) {
00562 void **elemAp, **elemBp;
00563 int sizeA, sizeB;
00564
00565 SETreturnsize_(setA, sizeA);
00566 SETreturnsize_(setB, sizeB);
00567 if (sizeA != sizeB)
00568 return 0;
00569 if (!sizeA)
00570 return 1;
00571 elemAp= SETaddr_(setA, void);
00572 elemBp= SETaddr_(setB, void);
00573 if (!memcmp((char *)elemAp, (char *)elemBp, sizeA*SETelemsize))
00574 return 1;
00575 return 0;
00576 }
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599 int qh_setequal_except (setT *setA, void *skipelemA, setT *setB, void *skipelemB) {
00600 void **elemA, **elemB;
00601 int skip=0;
00602
00603 elemA= SETaddr_(setA, void);
00604 elemB= SETaddr_(setB, void);
00605 while (1) {
00606 if (*elemA == skipelemA) {
00607 skip++;
00608 elemA++;
00609 }
00610 if (skipelemB) {
00611 if (*elemB == skipelemB) {
00612 skip++;
00613 elemB++;
00614 }
00615 }else if (*elemA != *elemB) {
00616 skip++;
00617 if (!(skipelemB= *elemB++))
00618 return 0;
00619 }
00620 if (!*elemA)
00621 break;
00622 if (*elemA++ != *elemB++)
00623 return 0;
00624 }
00625 if (skip != 2 || *elemB)
00626 return 0;
00627 return 1;
00628 }
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647 int qh_setequal_skip (setT *setA, int skipA, setT *setB, int skipB) {
00648 void **elemA, **elemB, **skipAp, **skipBp;
00649
00650 elemA= SETaddr_(setA, void);
00651 elemB= SETaddr_(setB, void);
00652 skipAp= SETelemaddr_(setA, skipA, void);
00653 skipBp= SETelemaddr_(setB, skipB, void);
00654 while (1) {
00655 if (elemA == skipAp)
00656 elemA++;
00657 if (elemB == skipBp)
00658 elemB++;
00659 if (!*elemA)
00660 break;
00661 if (*elemA++ != *elemB++)
00662 return 0;
00663 }
00664 if (*elemB)
00665 return 0;
00666 return 1;
00667 }
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686 void qh_setfree(setT **setp) {
00687 int size;
00688 void **freelistp;
00689
00690 if (*setp) {
00691 size= sizeof(setT) + ((*setp)->maxsize)*SETelemsize;
00692 if (size <= qhmem.LASTsize) {
00693 qh_memfree_(*setp, size, freelistp);
00694 }else
00695 qh_memfree (*setp, size);
00696 *setp= NULL;
00697 }
00698 }
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714 void qh_setfree2 (setT **setp, int elemsize) {
00715 void *elem, **elemp;
00716
00717 FOREACHelem_(*setp)
00718 qh_memfree (elem, elemsize);
00719 qh_setfree (setp);
00720 }
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740 void qh_setfreelong(setT **setp) {
00741 int size;
00742
00743 if (*setp) {
00744 size= sizeof(setT) + ((*setp)->maxsize)*SETelemsize;
00745 if (size > qhmem.LASTsize) {
00746 qh_memfree (*setp, size);
00747 *setp= NULL;
00748 }
00749 }
00750 }
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765 int qh_setin(setT *set, void *setelem) {
00766 void *elem, **elemp;
00767
00768 FOREACHelem_(set) {
00769 if (elem == setelem)
00770 return 1;
00771 }
00772 return 0;
00773 }
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790 int qh_setindex(setT *set, void *atelem) {
00791 void **elem;
00792 int size, i;
00793
00794 SETreturnsize_(set, size);
00795 if (size > set->maxsize)
00796 return -1;
00797 elem= SETaddr_(set, void);
00798 for (i=0; i < size; i++) {
00799 if (*elem++ == atelem)
00800 return i;
00801 }
00802 return -1;
00803 }
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822 void qh_setlarger(setT **oldsetp) {
00823 int size= 1, *sizep;
00824 setT *newset, *set, **setp, *oldset;
00825 void **oldp, **newp;
00826
00827 if (*oldsetp) {
00828 oldset= *oldsetp;
00829 SETreturnsize_(oldset, size);
00830 qhmem.cntlarger++;
00831 qhmem.totlarger += size+1;
00832 newset= qh_setnew(2 * size);
00833 oldp= SETaddr_(oldset, void);
00834 newp= SETaddr_(newset, void);
00835 memcpy((char *)newp, (char *)oldp, (size+1) * SETelemsize);
00836 sizep= SETsizeaddr_(newset);
00837 *sizep= size+1;
00838 FOREACHset_((setT *)qhmem.tempstack) {
00839 if (set == oldset)
00840 *(setp-1)= newset;
00841 }
00842 qh_setfree(oldsetp);
00843 }else
00844 newset= qh_setnew(3);
00845 *oldsetp= newset;
00846 }
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861 void *qh_setlast(setT *set) {
00862 int size;
00863
00864 if (set) {
00865 size= *SETsizeaddr_(set);
00866 if (!size)
00867 return SETelem_(set, set->maxsize - 1);
00868 else if (size > 1)
00869 return SETelem_(set, size - 2);
00870 }
00871 return NULL;
00872 }
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890 setT *qh_setnew(int setsize) {
00891 setT *set;
00892 int sizereceived;
00893 int size;
00894 void **freelistp;
00895
00896 if (!setsize)
00897 setsize++;
00898 size= sizeof(setT) + setsize * SETelemsize;
00899 if ((unsigned) size <= (unsigned) qhmem.LASTsize) {
00900 qh_memalloc_(size, freelistp, set, setT);
00901 #ifndef qh_NOmem
00902 sizereceived= qhmem.sizetable[ qhmem.indextable[size]];
00903 if (sizereceived > size)
00904 setsize += (sizereceived - size)/SETelemsize;
00905 #endif
00906 }else
00907 set= (setT*)qh_memalloc (size);
00908 set->maxsize= setsize;
00909 set->e[setsize].i= 1;
00910 set->e[0].p= NULL;
00911 return (set);
00912 }
00913
00914
00915
00916
00917
00918
00919
00920
00921
00922
00923
00924
00925
00926
00927
00928
00929
00930
00931
00932
00933 setT *qh_setnew_delnthsorted(setT *set, int size, int nth, int prepend) {
00934 setT *newset;
00935 void **oldp, **newp;
00936 int tailsize= size - nth -1, newsize;
00937
00938 if (tailsize < 0) {
00939 fprintf (qhmem.ferr, "qhull internal error (qh_setaddnth): nth %d is out-of-bounds for set:\n", nth);
00940 qh_setprint (qhmem.ferr, "", set);
00941 qh_errexit (qhmem_ERRqhull, NULL, NULL);
00942 }
00943 newsize= size-1 + prepend;
00944 newset= qh_setnew(newsize);
00945 newset->e[newset->maxsize].i= newsize+1;
00946 oldp= SETaddr_(set, void);
00947 newp= SETaddr_(newset, void) + prepend;
00948 switch (nth) {
00949 case 0:
00950 break;
00951 case 1:
00952 *(newp++)= *oldp++;
00953 break;
00954 case 2:
00955 *(newp++)= *oldp++;
00956 *(newp++)= *oldp++;
00957 break;
00958 case 3:
00959 *(newp++)= *oldp++;
00960 *(newp++)= *oldp++;
00961 *(newp++)= *oldp++;
00962 break;
00963 case 4:
00964 *(newp++)= *oldp++;
00965 *(newp++)= *oldp++;
00966 *(newp++)= *oldp++;
00967 *(newp++)= *oldp++;
00968 break;
00969 default:
00970 memcpy((char *)newp, (char *)oldp, nth * SETelemsize);
00971 newp += nth;
00972 oldp += nth;
00973 break;
00974 }
00975 oldp++;
00976 switch (tailsize) {
00977 case 0:
00978 break;
00979 case 1:
00980 *(newp++)= *oldp++;
00981 break;
00982 case 2:
00983 *(newp++)= *oldp++;
00984 *(newp++)= *oldp++;
00985 break;
00986 case 3:
00987 *(newp++)= *oldp++;
00988 *(newp++)= *oldp++;
00989 *(newp++)= *oldp++;
00990 break;
00991 case 4:
00992 *(newp++)= *oldp++;
00993 *(newp++)= *oldp++;
00994 *(newp++)= *oldp++;
00995 *(newp++)= *oldp++;
00996 break;
00997 default:
00998 memcpy((char *)newp, (char *)oldp, tailsize * SETelemsize);
00999 newp += tailsize;
01000 }
01001 *newp= NULL;
01002 return(newset);
01003 }
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015 void qh_setprint(FILE *fp, char* string, setT *set) {
01016 int size, k;
01017
01018 if (!set)
01019 fprintf (fp, "%s set is null\n", string);
01020 else {
01021 SETreturnsize_(set, size);
01022 fprintf (fp, "%s set=%p maxsize=%d size=%d elems=",
01023 string, set, set->maxsize, size);
01024 if (size > set->maxsize)
01025 size= set->maxsize+1;
01026 for (k=0; k < size; k++)
01027 fprintf(fp, " %p", set->e[k].p);
01028 fprintf(fp, "\n");
01029 }
01030 }
01031
01032
01033
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046 void qh_setreplace(setT *set, void *oldelem, void *newelem) {
01047 void **elemp;
01048
01049 elemp= SETaddr_(set, void);
01050 while(*elemp != oldelem && *elemp)
01051 elemp++;
01052 if (*elemp)
01053 *elemp= newelem;
01054 else {
01055 fprintf (qhmem.ferr, "qhull internal error (qh_setreplace): elem %p not found in set\n",
01056 oldelem);
01057 qh_setprint (qhmem.ferr, "", set);
01058 qh_errexit (qhmem_ERRqhull, NULL, NULL);
01059 }
01060 }
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074
01075
01076 int qh_setsize(setT *set) {
01077 int size, *sizep;
01078
01079 if (!set)
01080 return (0);
01081 sizep= SETsizeaddr_(set);
01082 if ((size= *sizep)) {
01083 size--;
01084 if (size > set->maxsize) {
01085 fprintf (qhmem.ferr, "qhull internal error (qh_setsize): current set size %d is greater than maximum size %d\n",
01086 size, set->maxsize);
01087 qh_setprint (qhmem.ferr, "set: ", set);
01088 qh_errexit (qhmem_ERRqhull, NULL, NULL);
01089 }
01090 }else
01091 size= set->maxsize;
01092 return size;
01093 }
01094
01095
01096
01097
01098
01099
01100
01101
01102
01103
01104
01105
01106
01107
01108
01109
01110 setT *qh_settemp(int setsize) {
01111 setT *newset;
01112
01113 newset= qh_setnew (setsize);
01114 qh_setappend ((setT **)&qhmem.tempstack, newset);
01115 if (qhmem.IStracing >= 5)
01116 fprintf (qhmem.ferr, "qh_settemp: temp set %p of %d elements, depth %d\n",
01117 newset, newset->maxsize, qh_setsize ((setT*)qhmem.tempstack));
01118 return newset;
01119 }
01120
01121
01122
01123
01124
01125
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138 void qh_settempfree(setT **set) {
01139 setT *stackedset;
01140
01141 if (!*set)
01142 return;
01143 stackedset= qh_settemppop ();
01144 if (stackedset != *set) {
01145 qh_settemppush(stackedset);
01146 fprintf (qhmem.ferr, "qhull internal error (qh_settempfree): set %p (size %d) was not last temporary allocated (depth %d, set %p, size %d)\n",
01147 *set, qh_setsize(*set), qh_setsize((setT*)qhmem.tempstack)+1,
01148 stackedset, qh_setsize(stackedset));
01149 qh_errexit (qhmem_ERRqhull, NULL, NULL);
01150 }
01151 qh_setfree (set);
01152 }
01153
01154
01155
01156
01157
01158
01159
01160
01161
01162
01163
01164
01165 void qh_settempfree_all(void) {
01166 setT *set, **setp;
01167
01168 FOREACHset_((setT *)qhmem.tempstack)
01169 qh_setfree(&set);
01170 qh_setfree((setT **)&qhmem.tempstack);
01171 }
01172
01173
01174
01175
01176
01177
01178
01179
01180
01181
01182
01183
01184
01185 setT *qh_settemppop(void) {
01186 setT *stackedset;
01187
01188 stackedset= (setT*)qh_setdellast((setT *)qhmem.tempstack);
01189 if (!stackedset) {
01190 fprintf (qhmem.ferr, "qhull internal error (qh_settemppop): pop from empty temporary stack\n");
01191 qh_errexit (qhmem_ERRqhull, NULL, NULL);
01192 }
01193 if (qhmem.IStracing >= 5)
01194 fprintf (qhmem.ferr, "qh_settemppop: depth %d temp set %p of %d elements\n",
01195 qh_setsize((setT*)qhmem.tempstack)+1, stackedset, qh_setsize(stackedset));
01196 return stackedset;
01197 }
01198
01199
01200
01201
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211 void qh_settemppush(setT *set) {
01212
01213 qh_setappend ((setT**)&qhmem.tempstack, set);
01214 if (qhmem.IStracing >= 5)
01215 fprintf (qhmem.ferr, "qh_settemppush: depth %d temp set %p of %d elements\n",
01216 qh_setsize((setT*)qhmem.tempstack), set, qh_setsize(set));
01217 }
01218
01219
01220
01221
01222
01223
01224
01225
01226
01227
01228
01229
01230
01231
01232
01233 void qh_settruncate (setT *set, int size) {
01234
01235 if (size < 0 || size > set->maxsize) {
01236 fprintf (qhmem.ferr, "qhull internal error (qh_settruncate): size %d out of bounds for set:\n", size);
01237 qh_setprint (qhmem.ferr, "", set);
01238 qh_errexit (qhmem_ERRqhull, NULL, NULL);
01239 }
01240 set->e[set->maxsize].i= size+1;
01241 set->e[size].p= NULL;
01242 }
01243
01244
01245
01246
01247
01248
01249
01250
01251
01252
01253
01254
01255
01256
01257 int qh_setunique (setT **set, void *elem) {
01258
01259 if (!qh_setin (*set, elem)) {
01260 qh_setappend (set, elem);
01261 return 1;
01262 }
01263 return 0;
01264 }
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279
01280
01281
01282
01283
01284
01285 void qh_setzero (setT *set, int index, int size) {
01286 int count;
01287
01288 if (index < 0 || index >= size || size > set->maxsize) {
01289 fprintf (qhmem.ferr, "qhull internal error (qh_setzero): index %d or size %d out of bounds for set:\n", index, size);
01290 qh_setprint (qhmem.ferr, "", set);
01291 qh_errexit (qhmem_ERRqhull, NULL, NULL);
01292 }
01293 set->e[set->maxsize].i= size+1;
01294 count= size - index + 1;
01295 memset ((char *)SETelemaddr_(set, index, void), 0, count * SETelemsize);
01296 }
01297
01298