File Coverage

deps/libgit2/deps/zlib/zutil.c
Criterion Covered Total %
statement 5 17 29.4
branch n/a
condition n/a
subroutine n/a
pod n/a
total 5 17 29.4


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