stella  6.0.2
About: Stella is a multi-platform Atari 2600 Video Computer System (VCS) emulator.
  Fossies Dox: stella-6.0.2-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

zutil.c
Go to the documentation of this file.
1 /* zutil.c -- target dependent utility functions for the compression library
2  * Copyright (C) 1995-2017 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 z_const char * const z_errmsg[10] = {
14  (z_const char *)"need dictionary", /* Z_NEED_DICT 2 */
15  (z_const char *)"stream end", /* Z_STREAM_END 1 */
16  (z_const char *)"", /* Z_OK 0 */
17  (z_const char *)"file error", /* Z_ERRNO (-1) */
18  (z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */
19  (z_const char *)"data error", /* Z_DATA_ERROR (-3) */
20  (z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */
21  (z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */
22  (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
23  (z_const char *)""
24 };
25 
26 
27 const char * ZEXPORT zlibVersion()
28 {
29  return ZLIB_VERSION;
30 }
31 
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 ZLIB_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 #if defined(STDC) || defined(Z_HAVE_STDARG_H)
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 ZLIB_DEBUG
116 #include <stdlib.h>
117 # ifndef verbose
118 # define verbose 0
119 # endif
120 int ZLIB_INTERNAL z_verbose = verbose;
121 
122 void ZLIB_INTERNAL z_error (
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(
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 
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 
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 
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 #ifndef Z_SOLO
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 ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
218 {
219  voidpf buf;
220  ulg bsize = (ulg)items*size;
221 
222  (void)opaque;
223 
224  /* If we allocate less than 65520 bytes, we assume that farmalloc
225  * will return a usable pointer which doesn't have to be normalized.
226  */
227  if (bsize < 65520L) {
228  buf = farmalloc(bsize);
229  if (*(ush*)&buf != 0) return buf;
230  } else {
231  buf = farmalloc(bsize + 16L);
232  }
233  if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
234  table[next_ptr].org_ptr = buf;
235 
236  /* Normalize the pointer to seg:0 */
237  *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
238  *(ush*)&buf = 0;
239  table[next_ptr++].new_ptr = buf;
240  return buf;
241 }
242 
243 void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
244 {
245  int n;
246 
247  (void)opaque;
248 
249  if (*(ush*)&ptr != 0) { /* object < 64K */
250  farfree(ptr);
251  return;
252  }
253  /* Find the original pointer */
254  for (n = 0; n < next_ptr; n++) {
255  if (ptr != table[n].new_ptr) continue;
256 
257  farfree(table[n].org_ptr);
258  while (++n < next_ptr) {
259  table[n-1] = table[n];
260  }
261  next_ptr--;
262  return;
263  }
264  Assert(0, "zcfree: ptr not found");
265 }
266 
267 #endif /* __TURBOC__ */
268 
269 
270 #ifdef M_I86
271 /* Microsoft C in 16-bit mode */
272 
273 # define MY_ZCALLOC
274 
275 #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
276 # define _halloc halloc
277 # define _hfree hfree
278 #endif
279 
280 voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
281 {
282  (void)opaque;
283  return _halloc((long)items, size);
284 }
285 
286 void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
287 {
288  (void)opaque;
289  _hfree(ptr);
290 }
291 
292 #endif /* M_I86 */
293 
294 #endif /* SYS16BIT */
295 
296 
297 #ifndef MY_ZCALLOC /* Any system without a special alloc function */
298 
299 #ifndef STDC
300 extern voidp malloc OF((uInt size));
301 extern voidp calloc OF((uInt items, uInt size));
302 extern void free OF((voidpf ptr));
303 #endif
304 
306  voidpf opaque,
307  unsigned items,
308  unsigned size)
309 {
310  (void)opaque;
311  return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
312  (voidpf)calloc(items, size);
313 }
314 
316  voidpf opaque,
317  voidpf ptr)
318 {
319  (void)opaque;
320  free(ptr);
321 }
322 
323 #endif /* MY_ZCALLOC */
324 
325 #endif /* !Z_SOLO */
Assert
#define Assert(cond, msg)
Definition: zutil.h:248
uch
unsigned char uch
Definition: zutil.h:43
z_errmsg
char * z_errmsg[10]
Definition: zutil.c:13
uLong
unsigned long uLong
Definition: zconf.h:401
zcfree
void zcfree(voidpf opaque, voidpf ptr)
Definition: zutil.c:315
zlibVersion
char * zlibVersion()
Definition: zutil.c:27
z_off_t
#define z_off_t
Definition: zconf.h:511
zcalloc
voidpf zcalloc(voidpf opaque, unsigned items, unsigned size)
Definition: zutil.c:305
OF
#define OF(args)
Definition: zconf.h:299
ZLIB_VERSION
#define ZLIB_VERSION
Definition: zlib.h:40
z_const
#define z_const
Definition: zconf.h:244
ush
unsigned short ush
Definition: zutil.h:45
gzguts.h
ERR_MSG
#define ERR_MSG(err)
Definition: zutil.h:52
voidp
Byte * voidp
Definition: zconf.h:421
malloc
voidp malloc()
voidpf
Byte * voidpf
Definition: zconf.h:420
local
#define local
Definition: gzguts.h:114
zlibCompileFlags
uLong zlibCompileFlags()
Definition: zutil.c:32
zmemzero
void zmemzero(Bytef *dest, uInt len)
Definition: zutil.c:173
zutil.h
zmemcmp
int zmemcmp(Bytef *s1, Bytef *s2, uInt len)
Definition: zutil.c:160
calloc
voidp calloc()
ZLIB_INTERNAL
#define ZLIB_INTERNAL
Definition: compress.c:8
ZEXPORT
#define ZEXPORT
Definition: zconf.h:387
zError
char * zError(int err)
Definition: zutil.c:133
uInt
unsigned int uInt
Definition: zconf.h:400
free
void free()
Bytef
Byte Bytef
Definition: zconf.h:407
zmemcpy
void zmemcpy(Bytef *dest, Bytef *source, uInt len)
Definition: zutil.c:149
ulg
unsigned long ulg
Definition: zutil.h:47