← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to win32/3rdparty/zlib/zutil.c

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
win32/3rdparty/zlib/zutil.c
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 */