zutil.c
Go to the documentation of this file.
1 /* zutil.c -- target dependent utility functions for the compression library
2  * Copyright (C) 1995-2005 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 
33 {
34  uLong flags;
35 
36  flags = 0;
37  switch (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 (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 (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 (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 z_verbose = verbose;
121 
122 void 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 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 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 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 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 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 zcalloc (voidpf opaque, unsigned items, unsigned size)
276 {
277  if (opaque) opaque = 0; /* to make compiler happy */
278  return _halloc((long)items, size);
279 }
280 
281 void 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 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 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 */
void zcfree(voidpf opaque, voidpf ptr)
Definition: zutil.c:310
Byte FAR * voidpf
Definition: zconf.h:283
png_voidp s1
Definition: png.h:2110
void zmemcpy(Bytef *dest, const Bytef *source, uInt len)
Definition: zutil.c:149
png_voidp ptr
Definition: png.h:2063
#define z_off_t
Definition: zconf.h:301
#define Assert(cond, msg)
Definition: zutil.h:252
png_uint_32 size
Definition: png.h:1521
char * malloc()
const char *const z_errmsg[10]
Definition: zutil.c:14
voidp malloc OF((uInt size))
unsigned long uLong
Definition: zconf.h:264
const char *ZEXPORT zlibVersion()
Definition: zutil.c:27
int zmemcmp(Bytef *s1, const Bytef *s2, uInt len) const
Definition: zutil.c:160
Byte FAR Bytef
Definition: zconf.h:270
png_uint_32 int flags
Definition: png.h:1656
#define ERR_MSG(err)
Definition: zutil.h:56
voidpf zcalloc(voidpf opaque, unsigned items, unsigned size)
Definition: zutil.c:300
uLong ZEXPORT zlibCompileFlags()
Definition: zutil.c:32
def j(str, encoding="cp932")
unsigned short ush
Definition: zutil.h:49
int free()
png_bytep buf
Definition: png.h:2729
Byte * voidp
Definition: zconf.h:284
#define ZLIB_VERSION
Definition: zlib.h:40
int dummy
Definition: gzio.c:19
png_voidp png_voidp s2
Definition: png.h:2110
typedef int
Definition: png.h:1113
unsigned char uch
Definition: zutil.h:47
unsigned long ulg
Definition: zutil.h:51
#define local
Definition: crc32.c:31
const char *ZEXPORT zError(int err)
Definition: zutil.c:133
#define const
Definition: zconf.h:124
static int verbose
Definition: pngtest.c:90
#define ZEXPORT
Definition: zconf.h:250
void zmemzero(Bytef *dest, uInt len)
Definition: zutil.c:173
unsigned int uInt
Definition: zconf.h:263


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Sat Apr 13 2019 02:14:26