File Coverage

cpan/Compress-Raw-Zlib/zutil.c
Criterion Covered Total %
statement 12 17 70.6
branch n/a
condition n/a
subroutine n/a
total 12 17 70.6


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