saml/zlib/zutil.c

   1 /* zutil.c -- target dependent utility functions for the compression library\r
   2  * Copyright (C) 1995-2005 Jean-loup Gailly.\r
   3  * For conditions of distribution and use, see copyright notice in zlib.h\r
   4  */\r
   5 \r
   6 /* @(#) $Id$ */\r
   7 \r
   8 #include "zutil.h"\r
   9 \r
  10 #ifndef NO_DUMMY_DECL\r
  11 struct internal_state      {int dummy;}; /* for buggy compilers */\r
  12 #endif\r
  13 \r
  14 const char * const z_errmsg[10] = {\r
  15 "need dictionary",     /* Z_NEED_DICT       2  */\r
  16 "stream end",          /* Z_STREAM_END      1  */\r
  17 "",                    /* Z_OK              0  */\r
  18 "file error",          /* Z_ERRNO         (-1) */\r
  19 "stream error",        /* Z_STREAM_ERROR  (-2) */\r
  20 "data error",          /* Z_DATA_ERROR    (-3) */\r
  21 "insufficient memory", /* Z_MEM_ERROR     (-4) */\r
  22 "buffer error",        /* Z_BUF_ERROR     (-5) */\r
  23 "incompatible version",/* Z_VERSION_ERROR (-6) */\r
  24 ""};\r
  25 \r
  26 \r
  27 const char * ZEXPORT zlibVersion()\r
  28 {\r
  29     return ZLIB_VERSION;\r
  30 }\r
  31 \r
  32 uLong ZEXPORT zlibCompileFlags()\r
  33 {\r
  34     uLong flags;\r
  35 \r
  36     flags = 0;\r
  37     switch (sizeof(uInt)) {\r
  38     case 2:     break;\r
  39     case 4:     flags += 1;     break;\r
  40     case 8:     flags += 2;     break;\r
  41     default:    flags += 3;\r
  42     }\r
  43     switch (sizeof(uLong)) {\r
  44     case 2:     break;\r
  45     case 4:     flags += 1 << 2;        break;\r
  46     case 8:     flags += 2 << 2;        break;\r
  47     default:    flags += 3 << 2;\r
  48     }\r
  49     switch (sizeof(voidpf)) {\r
  50     case 2:     break;\r
  51     case 4:     flags += 1 << 4;        break;\r
  52     case 8:     flags += 2 << 4;        break;\r
  53     default:    flags += 3 << 4;\r
  54     }\r
  55     switch (sizeof(z_off_t)) {\r
  56     case 2:     break;\r
  57     case 4:     flags += 1 << 6;        break;\r
  58     case 8:     flags += 2 << 6;        break;\r
  59     default:    flags += 3 << 6;\r
  60     }\r
  61 #ifdef DEBUG\r
  62     flags += 1 << 8;\r
  63 #endif\r
  64 #if defined(ASMV) || defined(ASMINF)\r
  65     flags += 1 << 9;\r
  66 #endif\r
  67 #ifdef ZLIB_WINAPI\r
  68     flags += 1 << 10;\r
  69 #endif\r
  70 #ifdef BUILDFIXED\r
  71     flags += 1 << 12;\r
  72 #endif\r
  73 #ifdef DYNAMIC_CRC_TABLE\r
  74     flags += 1 << 13;\r
  75 #endif\r
  76 #ifdef NO_GZCOMPRESS\r
  77     flags += 1L << 16;\r
  78 #endif\r
  79 #ifdef NO_GZIP\r
  80     flags += 1L << 17;\r
  81 #endif\r
  82 #ifdef PKZIP_BUG_WORKAROUND\r
  83     flags += 1L << 20;\r
  84 #endif\r
  85 #ifdef FASTEST\r
  86     flags += 1L << 21;\r
  87 #endif\r
  88 #ifdef STDC\r
  89 #  ifdef NO_vsnprintf\r
  90         flags += 1L << 25;\r
  91 #    ifdef HAS_vsprintf_void\r
  92         flags += 1L << 26;\r
  93 #    endif\r
  94 #  else\r
  95 #    ifdef HAS_vsnprintf_void\r
  96         flags += 1L << 26;\r
  97 #    endif\r
  98 #  endif\r
  99 #else\r
 100         flags += 1L << 24;\r
 101 #  ifdef NO_snprintf\r
 102         flags += 1L << 25;\r
 103 #    ifdef HAS_sprintf_void\r
 104         flags += 1L << 26;\r
 105 #    endif\r
 106 #  else\r
 107 #    ifdef HAS_snprintf_void\r
 108         flags += 1L << 26;\r
 109 #    endif\r
 110 #  endif\r
 111 #endif\r
 112     return flags;\r
 113 }\r
 114 \r
 115 #ifdef DEBUG\r
 116 \r
 117 #  ifndef verbose\r
 118 #    define verbose 0\r
 119 #  endif\r
 120 int z_verbose = verbose;\r
 121 \r
 122 void z_error (m)\r
 123     char *m;\r
 124 {\r
 125     fprintf(stderr, "%s\n", m);\r
 126     exit(1);\r
 127 }\r
 128 #endif\r
 129 \r
 130 /* exported to allow conversion of error code to string for compress() and\r
 131  * uncompress()\r
 132  */\r
 133 const char * ZEXPORT zError(err)\r
 134     int err;\r
 135 {\r
 136     return ERR_MSG(err);\r
 137 }\r
 138 \r
 139 #if defined(_WIN32_WCE)\r
 140     /* The Microsoft C Run-Time Library for Windows CE doesn't have\r
 141      * errno.  We define it as a global variable to simplify porting.\r
 142      * Its value is always 0 and should not be used.\r
 143      */\r
 144     int errno = 0;\r
 145 #endif\r
 146 \r
 147 #ifndef HAVE_MEMCPY\r
 148 \r
 149 void zmemcpy(dest, source, len)\r
 150     Bytef* dest;\r
 151     const Bytef* source;\r
 152     uInt  len;\r
 153 {\r
 154     if (len == 0) return;\r
 155     do {\r
 156         *dest++ = *source++; /* ??? to be unrolled */\r
 157     } while (--len != 0);\r
 158 }\r
 159 \r
 160 int zmemcmp(s1, s2, len)\r
 161     const Bytef* s1;\r
 162     const Bytef* s2;\r
 163     uInt  len;\r
 164 {\r
 165     uInt j;\r
 166 \r
 167     for (j = 0; j < len; j++) {\r
 168         if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;\r
 169     }\r
 170     return 0;\r
 171 }\r
 172 \r
 173 void zmemzero(dest, len)\r
 174     Bytef* dest;\r
 175     uInt  len;\r
 176 {\r
 177     if (len == 0) return;\r
 178     do {\r
 179         *dest++ = 0;  /* ??? to be unrolled */\r
 180     } while (--len != 0);\r
 181 }\r
 182 #endif\r
 183 \r
 184 \r
 185 #ifdef SYS16BIT\r
 186 \r
 187 #ifdef __TURBOC__\r
 188 /* Turbo C in 16-bit mode */\r
 189 \r
 190 #  define MY_ZCALLOC\r
 191 \r
 192 /* Turbo C malloc() does not allow dynamic allocation of 64K bytes\r
 193  * and farmalloc(64K) returns a pointer with an offset of 8, so we\r
 194  * must fix the pointer. Warning: the pointer must be put back to its\r
 195  * original form in order to free it, use zcfree().\r
 196  */\r
 197 \r
 198 #define MAX_PTR 10\r
 199 /* 10*64K = 640K */\r
 200 \r
 201 local int next_ptr = 0;\r
 202 \r
 203 typedef struct ptr_table_s {\r
 204     voidpf org_ptr;\r
 205     voidpf new_ptr;\r
 206 } ptr_table;\r
 207 \r
 208 local ptr_table table[MAX_PTR];\r
 209 /* This table is used to remember the original form of pointers\r
 210  * to large buffers (64K). Such pointers are normalized with a zero offset.\r
 211  * Since MSDOS is not a preemptive multitasking OS, this table is not\r
 212  * protected from concurrent access. This hack doesn't work anyway on\r
 213  * a protected system like OS/2. Use Microsoft C instead.\r
 214  */\r
 215 \r
 216 voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)\r
 217 {\r
 218     voidpf buf = opaque; /* just to make some compilers happy */\r
 219     ulg bsize = (ulg)items*size;\r
 220 \r
 221     /* If we allocate less than 65520 bytes, we assume that farmalloc\r
 222      * will return a usable pointer which doesn't have to be normalized.\r
 223      */\r
 224     if (bsize < 65520L) {\r
 225         buf = farmalloc(bsize);\r
 226         if (*(ush*)&buf != 0) return buf;\r
 227     } else {\r
 228         buf = farmalloc(bsize + 16L);\r
 229     }\r
 230     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;\r
 231     table[next_ptr].org_ptr = buf;\r
 232 \r
 233     /* Normalize the pointer to seg:0 */\r
 234     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;\r
 235     *(ush*)&buf = 0;\r
 236     table[next_ptr++].new_ptr = buf;\r
 237     return buf;\r
 238 }\r
 239 \r
 240 void  zcfree (voidpf opaque, voidpf ptr)\r
 241 {\r
 242     int n;\r
 243     if (*(ush*)&ptr != 0) { /* object < 64K */\r
 244         farfree(ptr);\r
 245         return;\r
 246     }\r
 247     /* Find the original pointer */\r
 248     for (n = 0; n < next_ptr; n++) {\r
 249         if (ptr != table[n].new_ptr) continue;\r
 250 \r
 251         farfree(table[n].org_ptr);\r
 252         while (++n < next_ptr) {\r
 253             table[n-1] = table[n];\r
 254         }\r
 255         next_ptr--;\r
 256         return;\r
 257     }\r
 258     ptr = opaque; /* just to make some compilers happy */\r
 259     Assert(0, "zcfree: ptr not found");\r
 260 }\r
 261 \r
 262 #endif /* __TURBOC__ */\r
 263 \r
 264 \r
 265 #ifdef M_I86\r
 266 /* Microsoft C in 16-bit mode */\r
 267 \r
 268 #  define MY_ZCALLOC\r
 269 \r
 270 #if (!defined(_MSC_VER) || (_MSC_VER <= 600))\r
 271 #  define _halloc  halloc\r
 272 #  define _hfree   hfree\r
 273 #endif\r
 274 \r
 275 voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)\r
 276 {\r
 277     if (opaque) opaque = 0; /* to make compiler happy */\r
 278     return _halloc((long)items, size);\r
 279 }\r
 280 \r
 281 void  zcfree (voidpf opaque, voidpf ptr)\r
 282 {\r
 283     if (opaque) opaque = 0; /* to make compiler happy */\r
 284     _hfree(ptr);\r
 285 }\r
 286 \r
 287 #endif /* M_I86 */\r
 288 \r
 289 #endif /* SYS16BIT */\r
 290 \r
 291 \r
 292 #ifndef MY_ZCALLOC /* Any system without a special alloc function */\r
 293 \r
 294 #ifndef STDC\r
 295 extern voidp  malloc OF((uInt size));\r
 296 extern voidp  calloc OF((uInt items, uInt size));\r
 297 extern void   free   OF((voidpf ptr));\r
 298 #endif\r
 299 \r
 300 voidpf zcalloc (opaque, items, size)\r
 301     voidpf opaque;\r
 302     unsigned items;\r
 303     unsigned size;\r
 304 {\r
 305     if (opaque) items += size - size; /* make compiler happy */\r
 306     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :\r
 307                               (voidpf)calloc(items, size);\r
 308 }\r
 309 \r
 310 void  zcfree (opaque, ptr)\r
 311     voidpf opaque;\r
 312     voidpf ptr;\r
 313 {\r
 314     free(ptr);\r
 315     if (opaque) return; /* make compiler happy */\r
 316 }\r
 317 \r
 318 #endif /* MY_ZCALLOC */\r