Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/externals/zlib/src/zutil.c

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /externals/zlib/src/zutil.c (Version 11.3.0) and /externals/zlib/src/zutil.c (Version 11.2.1)


  1 /* zutil.c -- target dependent utility functio      1 /* zutil.c -- target dependent utility functions for the compression library
  2  * Copyright (C) 1995-2017 Jean-loup Gailly         2  * Copyright (C) 1995-2017 Jean-loup Gailly
  3  * For conditions of distribution and use, see      3  * For conditions of distribution and use, see copyright notice in zlib.h
  4  */                                                 4  */
  5                                                     5 
  6 /* @(#) $Id$ */                                     6 /* @(#) $Id$ */
  7                                                     7 
  8 #include "zutil.h"                                  8 #include "zutil.h"
  9 #ifndef Z_SOLO                                      9 #ifndef Z_SOLO
 10 #  include "gzguts.h"                              10 #  include "gzguts.h"
 11 #endif                                             11 #endif
 12                                                    12 
 13 z_const char * const z_errmsg[10] = {              13 z_const char * const z_errmsg[10] = {
 14     (z_const char *)"need dictionary",     /*      14     (z_const char *)"need dictionary",     /* Z_NEED_DICT       2  */
 15     (z_const char *)"stream end",          /*      15     (z_const char *)"stream end",          /* Z_STREAM_END      1  */
 16     (z_const char *)"",                    /*      16     (z_const char *)"",                    /* Z_OK              0  */
 17     (z_const char *)"file error",          /*      17     (z_const char *)"file error",          /* Z_ERRNO         (-1) */
 18     (z_const char *)"stream error",        /*      18     (z_const char *)"stream error",        /* Z_STREAM_ERROR  (-2) */
 19     (z_const char *)"data error",          /*      19     (z_const char *)"data error",          /* Z_DATA_ERROR    (-3) */
 20     (z_const char *)"insufficient memory", /*      20     (z_const char *)"insufficient memory", /* Z_MEM_ERROR     (-4) */
 21     (z_const char *)"buffer error",        /*      21     (z_const char *)"buffer error",        /* Z_BUF_ERROR     (-5) */
 22     (z_const char *)"incompatible version",/*      22     (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
 23     (z_const char *)""                             23     (z_const char *)""
 24 };                                                 24 };
 25                                                    25 
 26                                                    26 
 27 const char * ZEXPORT zlibVersion()                 27 const char * ZEXPORT zlibVersion()
 28 {                                                  28 {
 29     return ZLIB_VERSION;                           29     return ZLIB_VERSION;
 30 }                                                  30 }
 31                                                    31 
 32 uLong ZEXPORT zlibCompileFlags()                   32 uLong ZEXPORT zlibCompileFlags()
 33 {                                                  33 {
 34     uLong flags;                                   34     uLong flags;
 35                                                    35 
 36     flags = 0;                                     36     flags = 0;
 37     switch ((int)(sizeof(uInt))) {                 37     switch ((int)(sizeof(uInt))) {
 38     case 2:     break;                             38     case 2:     break;
 39     case 4:     flags += 1;     break;             39     case 4:     flags += 1;     break;
 40     case 8:     flags += 2;     break;             40     case 8:     flags += 2;     break;
 41     default:    flags += 3;                        41     default:    flags += 3;
 42     }                                              42     }
 43     switch ((int)(sizeof(uLong))) {                43     switch ((int)(sizeof(uLong))) {
 44     case 2:     break;                             44     case 2:     break;
 45     case 4:     flags += 1 << 2;        break;     45     case 4:     flags += 1 << 2;        break;
 46     case 8:     flags += 2 << 2;        break;     46     case 8:     flags += 2 << 2;        break;
 47     default:    flags += 3 << 2;                   47     default:    flags += 3 << 2;
 48     }                                              48     }
 49     switch ((int)(sizeof(voidpf))) {               49     switch ((int)(sizeof(voidpf))) {
 50     case 2:     break;                             50     case 2:     break;
 51     case 4:     flags += 1 << 4;        break;     51     case 4:     flags += 1 << 4;        break;
 52     case 8:     flags += 2 << 4;        break;     52     case 8:     flags += 2 << 4;        break;
 53     default:    flags += 3 << 4;                   53     default:    flags += 3 << 4;
 54     }                                              54     }
 55     switch ((int)(sizeof(z_off_t))) {              55     switch ((int)(sizeof(z_off_t))) {
 56     case 2:     break;                             56     case 2:     break;
 57     case 4:     flags += 1 << 6;        break;     57     case 4:     flags += 1 << 6;        break;
 58     case 8:     flags += 2 << 6;        break;     58     case 8:     flags += 2 << 6;        break;
 59     default:    flags += 3 << 6;                   59     default:    flags += 3 << 6;
 60     }                                              60     }
 61 #ifdef ZLIB_DEBUG                                  61 #ifdef ZLIB_DEBUG
 62     flags += 1 << 8;                               62     flags += 1 << 8;
 63 #endif                                             63 #endif
 64     /*                                             64     /*
 65 #if defined(ASMV) || defined(ASMINF)               65 #if defined(ASMV) || defined(ASMINF)
 66     flags += 1 << 9;                               66     flags += 1 << 9;
 67 #endif                                             67 #endif
 68      */                                            68      */
 69 #ifdef ZLIB_WINAPI                                 69 #ifdef ZLIB_WINAPI
 70     flags += 1 << 10;                              70     flags += 1 << 10;
 71 #endif                                             71 #endif
 72 #ifdef BUILDFIXED                                  72 #ifdef BUILDFIXED
 73     flags += 1 << 12;                              73     flags += 1 << 12;
 74 #endif                                             74 #endif
 75 #ifdef DYNAMIC_CRC_TABLE                           75 #ifdef DYNAMIC_CRC_TABLE
 76     flags += 1 << 13;                              76     flags += 1 << 13;
 77 #endif                                             77 #endif
 78 #ifdef NO_GZCOMPRESS                               78 #ifdef NO_GZCOMPRESS
 79     flags += 1L << 16;                             79     flags += 1L << 16;
 80 #endif                                             80 #endif
 81 #ifdef NO_GZIP                                     81 #ifdef NO_GZIP
 82     flags += 1L << 17;                             82     flags += 1L << 17;
 83 #endif                                             83 #endif
 84 #ifdef PKZIP_BUG_WORKAROUND                        84 #ifdef PKZIP_BUG_WORKAROUND
 85     flags += 1L << 20;                             85     flags += 1L << 20;
 86 #endif                                             86 #endif
 87 #ifdef FASTEST                                     87 #ifdef FASTEST
 88     flags += 1L << 21;                             88     flags += 1L << 21;
 89 #endif                                             89 #endif
 90 #if defined(STDC) || defined(Z_HAVE_STDARG_H)      90 #if defined(STDC) || defined(Z_HAVE_STDARG_H)
 91 #  ifdef NO_vsnprintf                              91 #  ifdef NO_vsnprintf
 92     flags += 1L << 25;                             92     flags += 1L << 25;
 93 #    ifdef HAS_vsprintf_void                       93 #    ifdef HAS_vsprintf_void
 94     flags += 1L << 26;                             94     flags += 1L << 26;
 95 #    endif                                         95 #    endif
 96 #  else                                            96 #  else
 97 #    ifdef HAS_vsnprintf_void                      97 #    ifdef HAS_vsnprintf_void
 98     flags += 1L << 26;                             98     flags += 1L << 26;
 99 #    endif                                         99 #    endif
100 #  endif                                          100 #  endif
101 #else                                             101 #else
102     flags += 1L << 24;                            102     flags += 1L << 24;
103 #  ifdef NO_snprintf                              103 #  ifdef NO_snprintf
104     flags += 1L << 25;                            104     flags += 1L << 25;
105 #    ifdef HAS_sprintf_void                       105 #    ifdef HAS_sprintf_void
106     flags += 1L << 26;                            106     flags += 1L << 26;
107 #    endif                                        107 #    endif
108 #  else                                           108 #  else
109 #    ifdef HAS_snprintf_void                      109 #    ifdef HAS_snprintf_void
110     flags += 1L << 26;                            110     flags += 1L << 26;
111 #    endif                                        111 #    endif
112 #  endif                                          112 #  endif
113 #endif                                            113 #endif
114     return flags;                                 114     return flags;
115 }                                                 115 }
116                                                   116 
117 #ifdef ZLIB_DEBUG                                 117 #ifdef ZLIB_DEBUG
118 #include <stdlib.h>                               118 #include <stdlib.h>
119 #  ifndef verbose                                 119 #  ifndef verbose
120 #    define verbose 0                             120 #    define verbose 0
121 #  endif                                          121 #  endif
122 int ZLIB_INTERNAL z_verbose = verbose;            122 int ZLIB_INTERNAL z_verbose = verbose;
123                                                   123 
124 void ZLIB_INTERNAL z_error(m)                     124 void ZLIB_INTERNAL z_error(m)
125     char *m;                                      125     char *m;
126 {                                                 126 {
127     fprintf(stderr, "%s\n", m);                   127     fprintf(stderr, "%s\n", m);
128     exit(1);                                      128     exit(1);
129 }                                                 129 }
130 #endif                                            130 #endif
131                                                   131 
132 /* exported to allow conversion of error code     132 /* exported to allow conversion of error code to string for compress() and
133  * uncompress()                                   133  * uncompress()
134  */                                               134  */
135 const char * ZEXPORT zError(err)                  135 const char * ZEXPORT zError(err)
136     int err;                                      136     int err;
137 {                                                 137 {
138     return ERR_MSG(err);                          138     return ERR_MSG(err);
139 }                                                 139 }
140                                                   140 
141 #if defined(_WIN32_WCE) && _WIN32_WCE < 0x800     141 #if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
142     /* The older Microsoft C Run-Time Library     142     /* The older Microsoft C Run-Time Library for Windows CE doesn't have
143      * errno.  We define it as a global variab    143      * errno.  We define it as a global variable to simplify porting.
144      * Its value is always 0 and should not be    144      * Its value is always 0 and should not be used.
145      */                                           145      */
146     int errno = 0;                                146     int errno = 0;
147 #endif                                            147 #endif
148                                                   148 
149 #ifndef HAVE_MEMCPY                               149 #ifndef HAVE_MEMCPY
150                                                   150 
151 void ZLIB_INTERNAL zmemcpy(dest, source, len)     151 void ZLIB_INTERNAL zmemcpy(dest, source, len)
152     Bytef* dest;                                  152     Bytef* dest;
153     const Bytef* source;                          153     const Bytef* source;
154     uInt  len;                                    154     uInt  len;
155 {                                                 155 {
156     if (len == 0) return;                         156     if (len == 0) return;
157     do {                                          157     do {
158         *dest++ = *source++; /* ??? to be unro    158         *dest++ = *source++; /* ??? to be unrolled */
159     } while (--len != 0);                         159     } while (--len != 0);
160 }                                                 160 }
161                                                   161 
162 int ZLIB_INTERNAL zmemcmp(s1, s2, len)            162 int ZLIB_INTERNAL zmemcmp(s1, s2, len)
163     const Bytef* s1;                              163     const Bytef* s1;
164     const Bytef* s2;                              164     const Bytef* s2;
165     uInt  len;                                    165     uInt  len;
166 {                                                 166 {
167     uInt j;                                       167     uInt j;
168                                                   168 
169     for (j = 0; j < len; j++) {                   169     for (j = 0; j < len; j++) {
170         if (s1[j] != s2[j]) return 2*(s1[j] >     170         if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
171     }                                             171     }
172     return 0;                                     172     return 0;
173 }                                                 173 }
174                                                   174 
175 void ZLIB_INTERNAL zmemzero(dest, len)            175 void ZLIB_INTERNAL zmemzero(dest, len)
176     Bytef* dest;                                  176     Bytef* dest;
177     uInt  len;                                    177     uInt  len;
178 {                                                 178 {
179     if (len == 0) return;                         179     if (len == 0) return;
180     do {                                          180     do {
181         *dest++ = 0;  /* ??? to be unrolled */    181         *dest++ = 0;  /* ??? to be unrolled */
182     } while (--len != 0);                         182     } while (--len != 0);
183 }                                                 183 }
184 #endif                                            184 #endif
185                                                   185 
186 #ifndef Z_SOLO                                    186 #ifndef Z_SOLO
187                                                   187 
188 #ifdef SYS16BIT                                   188 #ifdef SYS16BIT
189                                                   189 
190 #ifdef __TURBOC__                                 190 #ifdef __TURBOC__
191 /* Turbo C in 16-bit mode */                      191 /* Turbo C in 16-bit mode */
192                                                   192 
193 #  define MY_ZCALLOC                              193 #  define MY_ZCALLOC
194                                                   194 
195 /* Turbo C malloc() does not allow dynamic all    195 /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
196  * and farmalloc(64K) returns a pointer with a    196  * and farmalloc(64K) returns a pointer with an offset of 8, so we
197  * must fix the pointer. Warning: the pointer     197  * must fix the pointer. Warning: the pointer must be put back to its
198  * original form in order to free it, use zcfr    198  * original form in order to free it, use zcfree().
199  */                                               199  */
200                                                   200 
201 #define MAX_PTR 10                                201 #define MAX_PTR 10
202 /* 10*64K = 640K */                               202 /* 10*64K = 640K */
203                                                   203 
204 local int next_ptr = 0;                           204 local int next_ptr = 0;
205                                                   205 
206 typedef struct ptr_table_s {                      206 typedef struct ptr_table_s {
207     voidpf org_ptr;                               207     voidpf org_ptr;
208     voidpf new_ptr;                               208     voidpf new_ptr;
209 } ptr_table;                                      209 } ptr_table;
210                                                   210 
211 local ptr_table table[MAX_PTR];                   211 local ptr_table table[MAX_PTR];
212 /* This table is used to remember the original    212 /* This table is used to remember the original form of pointers
213  * to large buffers (64K). Such pointers are n    213  * to large buffers (64K). Such pointers are normalized with a zero offset.
214  * Since MSDOS is not a preemptive multitaskin    214  * Since MSDOS is not a preemptive multitasking OS, this table is not
215  * protected from concurrent access. This hack    215  * protected from concurrent access. This hack doesn't work anyway on
216  * a protected system like OS/2. Use Microsoft    216  * a protected system like OS/2. Use Microsoft C instead.
217  */                                               217  */
218                                                   218 
219 voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, un    219 voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, unsigned size)
220 {                                                 220 {
221     voidpf buf;                                   221     voidpf buf;
222     ulg bsize = (ulg)items*size;                  222     ulg bsize = (ulg)items*size;
223                                                   223 
224     (void)opaque;                                 224     (void)opaque;
225                                                   225 
226     /* If we allocate less than 65520 bytes, w    226     /* If we allocate less than 65520 bytes, we assume that farmalloc
227      * will return a usable pointer which does    227      * will return a usable pointer which doesn't have to be normalized.
228      */                                           228      */
229     if (bsize < 65520L) {                         229     if (bsize < 65520L) {
230         buf = farmalloc(bsize);                   230         buf = farmalloc(bsize);
231         if (*(ush*)&buf != 0) return buf;         231         if (*(ush*)&buf != 0) return buf;
232     } else {                                      232     } else {
233         buf = farmalloc(bsize + 16L);             233         buf = farmalloc(bsize + 16L);
234     }                                             234     }
235     if (buf == NULL || next_ptr >= MAX_PTR) re    235     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
236     table[next_ptr].org_ptr = buf;                236     table[next_ptr].org_ptr = buf;
237                                                   237 
238     /* Normalize the pointer to seg:0 */          238     /* Normalize the pointer to seg:0 */
239     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 1    239     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
240     *(ush*)&buf = 0;                              240     *(ush*)&buf = 0;
241     table[next_ptr++].new_ptr = buf;              241     table[next_ptr++].new_ptr = buf;
242     return buf;                                   242     return buf;
243 }                                                 243 }
244                                                   244 
245 void ZLIB_INTERNAL zcfree(voidpf opaque, voidp    245 void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr)
246 {                                                 246 {
247     int n;                                        247     int n;
248                                                   248 
249     (void)opaque;                                 249     (void)opaque;
250                                                   250 
251     if (*(ush*)&ptr != 0) { /* object < 64K */    251     if (*(ush*)&ptr != 0) { /* object < 64K */
252         farfree(ptr);                             252         farfree(ptr);
253         return;                                   253         return;
254     }                                             254     }
255     /* Find the original pointer */               255     /* Find the original pointer */
256     for (n = 0; n < next_ptr; n++) {              256     for (n = 0; n < next_ptr; n++) {
257         if (ptr != table[n].new_ptr) continue;    257         if (ptr != table[n].new_ptr) continue;
258                                                   258 
259         farfree(table[n].org_ptr);                259         farfree(table[n].org_ptr);
260         while (++n < next_ptr) {                  260         while (++n < next_ptr) {
261             table[n-1] = table[n];                261             table[n-1] = table[n];
262         }                                         262         }
263         next_ptr--;                               263         next_ptr--;
264         return;                                   264         return;
265     }                                             265     }
266     Assert(0, "zcfree: ptr not found");           266     Assert(0, "zcfree: ptr not found");
267 }                                                 267 }
268                                                   268 
269 #endif /* __TURBOC__ */                           269 #endif /* __TURBOC__ */
270                                                   270 
271                                                   271 
272 #ifdef M_I86                                      272 #ifdef M_I86
273 /* Microsoft C in 16-bit mode */                  273 /* Microsoft C in 16-bit mode */
274                                                   274 
275 #  define MY_ZCALLOC                              275 #  define MY_ZCALLOC
276                                                   276 
277 #if (!defined(_MSC_VER) || (_MSC_VER <= 600))     277 #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
278 #  define _halloc  halloc                         278 #  define _halloc  halloc
279 #  define _hfree   hfree                          279 #  define _hfree   hfree
280 #endif                                            280 #endif
281                                                   281 
282 voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, uI    282 voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, uInt items, uInt size)
283 {                                                 283 {
284     (void)opaque;                                 284     (void)opaque;
285     return _halloc((long)items, size);            285     return _halloc((long)items, size);
286 }                                                 286 }
287                                                   287 
288 void ZLIB_INTERNAL zcfree(voidpf opaque, voidp    288 void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr)
289 {                                                 289 {
290     (void)opaque;                                 290     (void)opaque;
291     _hfree(ptr);                                  291     _hfree(ptr);
292 }                                                 292 }
293                                                   293 
294 #endif /* M_I86 */                                294 #endif /* M_I86 */
295                                                   295 
296 #endif /* SYS16BIT */                             296 #endif /* SYS16BIT */
297                                                   297 
298                                                   298 
299 #ifndef MY_ZCALLOC /* Any system without a spe    299 #ifndef MY_ZCALLOC /* Any system without a special alloc function */
300                                                   300 
301 #ifndef STDC                                      301 #ifndef STDC
302 extern voidp  malloc OF((uInt size));             302 extern voidp  malloc OF((uInt size));
303 extern voidp  calloc OF((uInt items, uInt size    303 extern voidp  calloc OF((uInt items, uInt size));
304 extern void   free   OF((voidpf ptr));            304 extern void   free   OF((voidpf ptr));
305 #endif                                            305 #endif
306                                                   306 
307 voidpf ZLIB_INTERNAL zcalloc(opaque, items, si    307 voidpf ZLIB_INTERNAL zcalloc(opaque, items, size)
308     voidpf opaque;                                308     voidpf opaque;
309     unsigned items;                               309     unsigned items;
310     unsigned size;                                310     unsigned size;
311 {                                                 311 {
312     (void)opaque;                                 312     (void)opaque;
313     return sizeof(uInt) > 2 ? (voidpf)malloc(i    313     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
314                               (voidpf)calloc(i    314                               (voidpf)calloc(items, size);
315 }                                                 315 }
316                                                   316 
317 void ZLIB_INTERNAL zcfree(opaque, ptr)            317 void ZLIB_INTERNAL zcfree(opaque, ptr)
318     voidpf opaque;                                318     voidpf opaque;
319     voidpf ptr;                                   319     voidpf ptr;
320 {                                                 320 {
321     (void)opaque;                                 321     (void)opaque;
322     free(ptr);                                    322     free(ptr);
323 }                                                 323 }
324                                                   324 
325 #endif /* MY_ZCALLOC */                           325 #endif /* MY_ZCALLOC */
326                                                   326 
327 #endif /* !Z_SOLO */                              327 #endif /* !Z_SOLO */
328                                                   328