Annotation of embedaddon/sudo/zlib/zutil.c, revision 1.1.1.1
1.1 misho 1: /* zutil.c -- target dependent utility functions for the compression library
2: * Copyright (C) 1995-2005, 2010 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: const char * const z_errmsg[10] = {
15: "need dictionary", /* Z_NEED_DICT 2 */
16: "stream end", /* Z_STREAM_END 1 */
17: "", /* Z_OK 0 */
18: "file error", /* Z_ERRNO (-1) */
19: "stream error", /* Z_STREAM_ERROR (-2) */
20: "data error", /* Z_DATA_ERROR (-3) */
21: "insufficient memory", /* Z_MEM_ERROR (-4) */
22: "buffer error", /* Z_BUF_ERROR (-5) */
23: "incompatible version",/* Z_VERSION_ERROR (-6) */
24: ""};
25:
26:
27: const char * ZEXPORT zlibVersion()
28: {
29: return ZLIB_VERSION;
30: }
31:
32: uLong ZEXPORT zlibCompileFlags()
33: {
34: uLong flags;
35:
36: flags = 0;
37: switch ((int)(sizeof(uInt))) {
38: case 2: break;
39: 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: 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: 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: case 8: flags += 2 << 6; break;
59: default: flags += 3 << 6;
60: }
61: #ifdef 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: 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: #ifdef STDC
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: return flags;
113: }
114:
115: #ifdef DEBUG
116:
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: const char * ZEXPORT zError(err)
134: int err;
135: {
136: 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:
185: #ifdef SYS16BIT
186:
187: #ifdef __TURBOC__
188: /* Turbo C in 16-bit mode */
189:
190: # define MY_ZCALLOC
191:
192: /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
193: * and farmalloc(64K) returns a pointer with an offset of 8, so we
194: * must fix the pointer. Warning: the pointer must be put back to its
195: * original form in order to free it, use zcfree().
196: */
197:
198: #define MAX_PTR 10
199: /* 10*64K = 640K */
200:
201: local int next_ptr = 0;
202:
203: typedef struct ptr_table_s {
204: voidpf org_ptr;
205: voidpf new_ptr;
206: } ptr_table;
207:
208: local ptr_table table[MAX_PTR];
209: /* This table is used to remember the original form of pointers
210: * to large buffers (64K). Such pointers are normalized with a zero offset.
211: * Since MSDOS is not a preemptive multitasking OS, this table is not
212: * protected from concurrent access. This hack doesn't work anyway on
213: * a protected system like OS/2. Use Microsoft C instead.
214: */
215:
216: voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
217: {
218: voidpf buf = opaque; /* just to make some compilers happy */
219: ulg bsize = (ulg)items*size;
220:
221: /* If we allocate less than 65520 bytes, we assume that farmalloc
222: * will return a usable pointer which doesn't have to be normalized.
223: */
224: if (bsize < 65520L) {
225: buf = farmalloc(bsize);
226: if (*(ush*)&buf != 0) return buf;
227: } else {
228: buf = farmalloc(bsize + 16L);
229: }
230: if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
231: table[next_ptr].org_ptr = buf;
232:
233: /* Normalize the pointer to seg:0 */
234: *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
235: *(ush*)&buf = 0;
236: table[next_ptr++].new_ptr = buf;
237: return buf;
238: }
239:
240: void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
241: {
242: int n;
243: if (*(ush*)&ptr != 0) { /* object < 64K */
244: farfree(ptr);
245: return;
246: }
247: /* Find the original pointer */
248: for (n = 0; n < next_ptr; n++) {
249: if (ptr != table[n].new_ptr) continue;
250:
251: farfree(table[n].org_ptr);
252: while (++n < next_ptr) {
253: table[n-1] = table[n];
254: }
255: next_ptr--;
256: return;
257: }
258: ptr = opaque; /* just to make some compilers happy */
259: Assert(0, "zcfree: ptr not found");
260: }
261:
262: #endif /* __TURBOC__ */
263:
264:
265: #ifdef M_I86
266: /* Microsoft C in 16-bit mode */
267:
268: # define MY_ZCALLOC
269:
270: #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
271: # define _halloc halloc
272: # define _hfree hfree
273: #endif
274:
275: voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
276: {
277: if (opaque) opaque = 0; /* to make compiler happy */
278: return _halloc((long)items, size);
279: }
280:
281: void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
282: {
283: if (opaque) opaque = 0; /* to make compiler happy */
284: _hfree(ptr);
285: }
286:
287: #endif /* M_I86 */
288:
289: #endif /* SYS16BIT */
290:
291:
292: #ifndef MY_ZCALLOC /* Any system without a special alloc function */
293:
294: #ifndef STDC
295: extern voidp malloc OF((uInt size));
296: extern voidp calloc OF((uInt items, uInt size));
297: extern void free OF((voidpf ptr));
298: #endif
299:
300: voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
301: voidpf opaque;
302: unsigned items;
303: unsigned size;
304: {
305: if (opaque) items += size - size; /* make compiler happy */
306: return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
307: (voidpf)calloc(items, size);
308: }
309:
310: void ZLIB_INTERNAL zcfree (opaque, ptr)
311: voidpf opaque;
312: voidpf ptr;
313: {
314: free(ptr);
315: if (opaque) return; /* make compiler happy */
316: }
317:
318: #endif /* MY_ZCALLOC */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zutil.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / zlib