"Fossies" - the Fresh Open Source Software Archive 
Member "zsync-0.6.2/zlib/zutil.c" (16 Sep 2010, 7007 Bytes) of package /linux/privat/old/zsync-0.6.2.tar.gz:
As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style:
standard) with prefixed line numbers and
code folding option.
Alternatively you can here
view or
download the uninterpreted source code file.
For more information about "zutil.c" see the
Fossies "Dox" file reference documentation.
1 /* zutil.c -- target dependent utility functions for the compression library
2 * Copyright (C) 1995-2003 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
10 #ifndef NO_DUMMY_DECL
11 struct internal_state {int dummy;}; /* for buggy compilers */
12 #endif
13
14 #ifndef STDC
15 extern void exit OF((int));
16 #endif
17
18 const char * const z_errmsg[10] = {
19 "need dictionary", /* Z_NEED_DICT 2 */
20 "stream end", /* Z_STREAM_END 1 */
21 "", /* Z_OK 0 */
22 "file error", /* Z_ERRNO (-1) */
23 "stream error", /* Z_STREAM_ERROR (-2) */
24 "data error", /* Z_DATA_ERROR (-3) */
25 "insufficient memory", /* Z_MEM_ERROR (-4) */
26 "buffer error", /* Z_BUF_ERROR (-5) */
27 "incompatible version",/* Z_VERSION_ERROR (-6) */
28 ""};
29
30
31 const char * ZEXPORT zlibVersion()
32 {
33 return ZLIB_VERSION;
34 }
35
36 uLong ZEXPORT zlibCompileFlags()
37 {
38 uLong flags;
39
40 flags = 0;
41 switch (sizeof(uInt)) {
42 case 2: break;
43 case 4: flags += 1; break;
44 case 8: flags += 2; break;
45 default: flags += 3;
46 }
47 switch (sizeof(uLong)) {
48 case 2: break;
49 case 4: flags += 1 << 2; break;
50 case 8: flags += 2 << 2; break;
51 default: flags += 3 << 2;
52 }
53 switch (sizeof(voidpf)) {
54 case 2: break;
55 case 4: flags += 1 << 4; break;
56 case 8: flags += 2 << 4; break;
57 default: flags += 3 << 4;
58 }
59 switch (sizeof(z_off_t)) {
60 case 2: break;
61 case 4: flags += 1 << 6; break;
62 case 8: flags += 2 << 6; break;
63 default: flags += 3 << 6;
64 }
65 #ifdef DEBUG
66 flags += 1 << 8;
67 #endif
68 #if defined(ASMV) || defined(ASMINF)
69 flags += 1 << 9;
70 #endif
71 #ifdef ZLIB_WINAPI
72 flags += 1 << 10;
73 #endif
74 #ifdef BUILDFIXED
75 flags += 1 << 12;
76 #endif
77 #ifdef DYNAMIC_CRC_TABLE
78 flags += 1 << 13;
79 #endif
80 #ifdef NO_GZCOMPRESS
81 flags += 1 << 16;
82 #endif
83 #ifdef NO_GZIP
84 flags += 1 << 17;
85 #endif
86 #ifdef PKZIP_BUG_WORKAROUND
87 flags += 1 << 20;
88 #endif
89 #ifdef FASTEST
90 flags += 1 << 21;
91 #endif
92 #ifdef STDC
93 # ifdef NO_vsnprintf
94 flags += 1 << 25;
95 # ifdef HAS_vsprintf_void
96 flags += 1 << 26;
97 # endif
98 # else
99 # ifdef HAS_vsnprintf_void
100 flags += 1 << 26;
101 # endif
102 # endif
103 #else
104 flags += 1 << 24;
105 # ifdef NO_snprintf
106 flags += 1 << 25;
107 # ifdef HAS_sprintf_void
108 flags += 1 << 26;
109 # endif
110 # else
111 # ifdef HAS_snprintf_void
112 flags += 1 << 26;
113 # endif
114 # endif
115 #endif
116 return flags;
117 }
118
119 #ifdef DEBUG
120
121 # ifndef verbose
122 # define verbose 0
123 # endif
124 int z_verbose = verbose;
125
126 void z_error (m)
127 char *m;
128 {
129 fprintf(stderr, "%s\n", m);
130 exit(1);
131 }
132 #endif
133
134 /* exported to allow conversion of error code to string for compress() and
135 * uncompress()
136 */
137 const char * ZEXPORT zError(err)
138 int err;
139 {
140 return ERR_MSG(err);
141 }
142
143 #if defined(_WIN32_WCE)
144 /* does not exist on WCE */
145 int errno = 0;
146 #endif
147
148 #ifndef HAVE_MEMCPY
149
150 void zmemcpy(dest, source, len)
151 Bytef* dest;
152 const Bytef* source;
153 uInt len;
154 {
155 if (len == 0) return;
156 do {
157 *dest++ = *source++; /* ??? to be unrolled */
158 } while (--len != 0);
159 }
160
161 int zmemcmp(s1, s2, len)
162 const Bytef* s1;
163 const Bytef* s2;
164 uInt len;
165 {
166 uInt j;
167
168 for (j = 0; j < len; j++) {
169 if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
170 }
171 return 0;
172 }
173
174 void zmemzero(dest, len)
175 Bytef* dest;
176 uInt len;
177 {
178 if (len == 0) return;
179 do {
180 *dest++ = 0; /* ??? to be unrolled */
181 } while (--len != 0);
182 }
183 #endif
184
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 zcalloc (voidpf opaque, unsigned items, unsigned size)
218 {
219 voidpf buf = opaque; /* just to make some compilers happy */
220 ulg bsize = (ulg)items*size;
221
222 /* If we allocate less than 65520 bytes, we assume that farmalloc
223 * will return a usable pointer which doesn't have to be normalized.
224 */
225 if (bsize < 65520L) {
226 buf = farmalloc(bsize);
227 if (*(ush*)&buf != 0) return buf;
228 } else {
229 buf = farmalloc(bsize + 16L);
230 }
231 if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
232 table[next_ptr].org_ptr = buf;
233
234 /* Normalize the pointer to seg:0 */
235 *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
236 *(ush*)&buf = 0;
237 table[next_ptr++].new_ptr = buf;
238 return buf;
239 }
240
241 void zcfree (voidpf opaque, voidpf ptr)
242 {
243 int n;
244 if (*(ush*)&ptr != 0) { /* object < 64K */
245 farfree(ptr);
246 return;
247 }
248 /* Find the original pointer */
249 for (n = 0; n < next_ptr; n++) {
250 if (ptr != table[n].new_ptr) continue;
251
252 farfree(table[n].org_ptr);
253 while (++n < next_ptr) {
254 table[n-1] = table[n];
255 }
256 next_ptr--;
257 return;
258 }
259 ptr = opaque; /* just to make some compilers happy */
260 Assert(0, "zcfree: ptr not found");
261 }
262
263 #endif /* __TURBOC__ */
264
265
266 #ifdef M_I86
267 /* Microsoft C in 16-bit mode */
268
269 # define MY_ZCALLOC
270
271 #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
272 # define _halloc halloc
273 # define _hfree hfree
274 #endif
275
276 voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
277 {
278 if (opaque) opaque = 0; /* to make compiler happy */
279 return _halloc((long)items, size);
280 }
281
282 void zcfree (voidpf opaque, voidpf ptr)
283 {
284 if (opaque) opaque = 0; /* to make compiler happy */
285 _hfree(ptr);
286 }
287
288 #endif /* M_I86 */
289
290 #endif /* SYS16BIT */
291
292
293 #ifndef MY_ZCALLOC /* Any system without a special alloc function */
294
295 #ifndef STDC
296 extern voidp malloc OF((uInt size));
297 extern voidp calloc OF((uInt items, uInt size));
298 extern void free OF((voidpf ptr));
299 #endif
300
301 voidpf zcalloc (opaque, items, size)
302 voidpf opaque;
303 unsigned items;
304 unsigned size;
305 {
306 if (opaque) items += size - size; /* make compiler happy */
307 return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
308 (voidpf)calloc(items, size);
309 }
310
311 void zcfree (opaque, ptr)
312 voidpf opaque;
313 voidpf ptr;
314 {
315 free(ptr);
316 if (opaque) return; /* make compiler happy */
317 }
318
319 #endif /* MY_ZCALLOC */