← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

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