org.handhelds.familiar/packages/zlib/files/visibility.patch

   1 --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/adler32.c        2003-11-17 15:24:27.000000000 -0600
   2 +++ zlib-1.2.2/adler32.c        2005-02-28 19:04:09.000000000 -0600
   3 @@ -44,7 +44,7 @@
   4  #endif
   5
   6  /* ========================================================================= */
   7 -uLong ZEXPORT adler32(adler, buf, len)
   8 +ZEXPORT uLong adler32(adler, buf, len)
   9      uLong adler;
  10      const Bytef *buf;
  11      uInt len;
  12 --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/compress.c       2003-07-07 00:37:56.000000000 -0500
  13 +++ zlib-1.2.2/compress.c       2005-02-28 19:04:09.000000000 -0600
  14 @@ -19,7 +19,7 @@
  15     memory, Z_BUF_ERROR if there was not enough room in the output buffer,
  16     Z_STREAM_ERROR if the level parameter is invalid.
  17  */
  18 -int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
  19 +ZEXPORT int compress2 (dest, destLen, source, sourceLen, level)
  20      Bytef *dest;
  21      uLongf *destLen;
  22      const Bytef *source;
  23 @@ -59,7 +59,7 @@
  24
  25  /* ===========================================================================
  26   */
  27 -int ZEXPORT compress (dest, destLen, source, sourceLen)
  28 +ZEXPORT int compress (dest, destLen, source, sourceLen)
  29      Bytef *dest;
  30      uLongf *destLen;
  31      const Bytef *source;
  32 @@ -72,7 +72,7 @@
  33       If the default memLevel or windowBits for deflateInit() is changed, then
  34     this function needs to be updated.
  35   */
  36 -uLong ZEXPORT compressBound (sourceLen)
  37 +ZEXPORT uLong compressBound (sourceLen)
  38      uLong sourceLen;
  39  {
  40      return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11;
  41 --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/crc32.c  2004-10-03 21:29:30.000000000 -0500
  42 +++ zlib-1.2.2/crc32.c  2005-02-28 19:04:09.000000000 -0600
  43 @@ -198,7 +198,7 @@
  44  /* =========================================================================
  45   * This function can be used by asm versions of crc32()
  46   */
  47 -const unsigned long FAR * ZEXPORT get_crc_table()
  48 +ZEXPORT const unsigned long FAR * get_crc_table()
  49  {
  50  #ifdef DYNAMIC_CRC_TABLE
  51      if (crc_table_empty)
  52 @@ -212,7 +212,7 @@
  53  #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
  54
  55  /* ========================================================================= */
  56 -unsigned long ZEXPORT crc32(crc, buf, len)
  57 +ZEXPORT unsigned long crc32(crc, buf, len)
  58      unsigned long crc;
  59      const unsigned char FAR *buf;
  60      unsigned len;
  61 --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/deflate.c        2004-09-15 09:28:14.000000000 -0500
  62 +++ zlib-1.2.2/deflate.c        2005-02-28 19:04:09.000000000 -0600
  63 @@ -201,7 +201,7 @@
  64      zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
  65
  66  /* ========================================================================= */
  67 -int ZEXPORT deflateInit_(strm, level, version, stream_size)
  68 +ZEXPORT int deflateInit_(strm, level, version, stream_size)
  69      z_streamp strm;
  70      int level;
  71      const char *version;
  72 @@ -213,7 +213,7 @@
  73  }
  74
  75  /* ========================================================================= */
  76 -int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
  77 +ZEXPORT int deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
  78                    version, stream_size)
  79      z_streamp strm;
  80      int  level;
  81 @@ -311,7 +311,7 @@
  82  }
  83
  84  /* ========================================================================= */
  85 -int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
  86 +ZEXPORT int deflateSetDictionary (strm, dictionary, dictLength)
  87      z_streamp strm;
  88      const Bytef *dictionary;
  89      uInt  dictLength;
  90 @@ -355,7 +355,7 @@
  91  }
  92
  93  /* ========================================================================= */
  94 -int ZEXPORT deflateReset (strm)
  95 +ZEXPORT int deflateReset (strm)
  96      z_streamp strm;
  97  {
  98      deflate_state *s;
  99 @@ -391,7 +391,7 @@
 100  }
 101
 102  /* ========================================================================= */
 103 -int ZEXPORT deflatePrime (strm, bits, value)
 104 +ZEXPORT int deflatePrime (strm, bits, value)
 105      z_streamp strm;
 106      int bits;
 107      int value;
 108 @@ -403,7 +403,7 @@
 109  }
 110
 111  /* ========================================================================= */
 112 -int ZEXPORT deflateParams(strm, level, strategy)
 113 +ZEXPORT int deflateParams(strm, level, strategy)
 114      z_streamp strm;
 115      int level;
 116      int strategy;
 117 @@ -457,7 +457,7 @@
 118   * But even the conservative upper bound of about 14% expansion does not
 119   * seem onerous for output buffer allocation.
 120   */
 121 -uLong ZEXPORT deflateBound(strm, sourceLen)
 122 +ZEXPORT uLong deflateBound(strm, sourceLen)
 123      z_streamp strm;
 124      uLong sourceLen;
 125  {
 126 @@ -520,7 +520,7 @@
 127  }
 128
 129  /* ========================================================================= */
 130 -int ZEXPORT deflate (strm, flush)
 131 +ZEXPORT int deflate (strm, flush)
 132      z_streamp strm;
 133      int flush;
 134  {
 135 @@ -696,7 +696,7 @@
 136  }
 137
 138  /* ========================================================================= */
 139 -int ZEXPORT deflateEnd (strm)
 140 +ZEXPORT int deflateEnd (strm)
 141      z_streamp strm;
 142  {
 143      int status;
 144 @@ -726,7 +726,7 @@
 145   * To simplify the source, this is not supported for 16-bit MSDOS (which
 146   * doesn't have enough memory anyway to duplicate compression states).
 147   */
 148 -int ZEXPORT deflateCopy (dest, source)
 149 +ZEXPORT int deflateCopy (dest, source)
 150      z_streamp dest;
 151      z_streamp source;
 152  {
 153 --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/gzio.c   2004-10-03 21:30:37.000000000 -0500
 154 +++ zlib-1.2.2/gzio.c   2005-02-28 19:06:11.000000000 -0600
 155 @@ -205,7 +205,7 @@
 156  /* ===========================================================================
 157       Opens a gzip (.gz) file for reading or writing.
 158  */
 159 -gzFile ZEXPORT gzopen (path, mode)
 160 +ZEXPORT gzFile gzopen (path, mode)
 161      const char *path;
 162      const char *mode;
 163  {
 164 @@ -216,7 +216,7 @@
 165       Associate a gzFile with the file descriptor fd. fd is not dup'ed here
 166     to mimic the behavio(u)r of fdopen.
 167  */
 168 -gzFile ZEXPORT gzdopen (fd, mode)
 169 +ZEXPORT gzFile gzdopen (fd, mode)
 170      int fd;
 171      const char *mode;
 172  {
 173 @@ -231,7 +231,7 @@
 174  /* ===========================================================================
 175   * Update the compression level and strategy
 176   */
 177 -int ZEXPORT gzsetparams (file, level, strategy)
 178 +ZEXPORT int gzsetparams (file, level, strategy)
 179      gzFile file;
 180      int level;
 181      int strategy;
 182 @@ -391,7 +391,7 @@
 183       Reads the given number of uncompressed bytes from the compressed file.
 184     gzread returns the number of bytes actually read (0 for end of file).
 185  */
 186 -int ZEXPORT gzread (file, buf, len)
 187 +ZEXPORT int gzread (file, buf, len)
 188      gzFile file;
 189      voidp buf;
 190      unsigned len;
 191 @@ -500,7 +500,7 @@
 192        Reads one byte from the compressed file. gzgetc returns this byte
 193     or -1 in case of end of file or error.
 194  */
 195 -int ZEXPORT gzgetc(file)
 196 +ZEXPORT int gzgetc(file)
 197      gzFile file;
 198  {
 199      unsigned char c;
 200 @@ -512,7 +512,7 @@
 201  /* ===========================================================================
 202        Push one byte back onto the stream.
 203  */
 204 -int ZEXPORT gzungetc(c, file)
 205 +ZEXPORT int gzungetc(c, file)
 206      int c;
 207      gzFile file;
 208  {
 209 @@ -537,7 +537,7 @@
 210
 211        The current implementation is not optimized at all.
 212  */
 213 -char * ZEXPORT gzgets(file, buf, len)
 214 +ZEXPORT char * gzgets(file, buf, len)
 215      gzFile file;
 216      char *buf;
 217      int len;
 218 @@ -556,7 +556,7 @@
 219       Writes the given number of uncompressed bytes into the compressed file.
 220     gzwrite returns the number of bytes actually written (0 in case of error).
 221  */
 222 -int ZEXPORT gzwrite (file, buf, len)
 223 +ZEXPORT int gzwrite (file, buf, len)
 224      gzFile file;
 225      voidpc buf;
 226      unsigned len;
 227 @@ -600,7 +600,7 @@
 228  #ifdef STDC
 229  #include <stdarg.h>
 230
 231 -int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...)
 232 +ZEXPORTVA int gzprintf (gzFile file, const char *format, /* args */ ...)
 233  {
 234      char buf[Z_PRINTF_BUFSIZE];
 235      va_list va;
 236 @@ -634,7 +634,7 @@
 237  }
 238  #else /* not ANSI C */
 239
 240 -int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
 241 +ZEXPORT intVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
 242                         a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
 243      gzFile file;
 244      const char *format;
 245 @@ -675,7 +675,7 @@
 246        Writes c, converted to an unsigned char, into the compressed file.
 247     gzputc returns the value that was written, or -1 in case of error.
 248  */
 249 -int ZEXPORT gzputc(file, c)
 250 +ZEXPORT int gzputc(file, c)
 251      gzFile file;
 252      int c;
 253  {
 254 @@ -690,7 +690,7 @@
 255     the terminating null character.
 256        gzputs returns the number of characters written, or -1 in case of error.
 257  */
 258 -int ZEXPORT gzputs(file, s)
 259 +ZEXPORT int gzputs(file, s)
 260      gzFile file;
 261      const char *s;
 262  {
 263 @@ -743,7 +743,7 @@
 264      return  s->z_err == Z_STREAM_END ? Z_OK : s->z_err;
 265  }
 266
 267 -int ZEXPORT gzflush (file, flush)
 268 +ZEXPORT int gzflush (file, flush)
 269       gzFile file;
 270       int flush;
 271  {
 272 @@ -764,7 +764,7 @@
 273        SEEK_END is not implemented, returns error.
 274        In this version of the library, gzseek can be extremely slow.
 275  */
 276 -z_off_t ZEXPORT gzseek (file, offset, whence)
 277 +ZEXPORT z_off_t gzseek (file, offset, whence)
 278      gzFile file;
 279      z_off_t offset;
 280      int whence;
 281 @@ -854,7 +854,7 @@
 282  /* ===========================================================================
 283       Rewinds input file.
 284  */
 285 -int ZEXPORT gzrewind (file)
 286 +ZEXPORT int gzrewind (file)
 287      gzFile file;
 288  {
 289      gz_stream *s = (gz_stream*)file;
 290 @@ -878,7 +878,7 @@
 291     given compressed file. This position represents a number of bytes in the
 292     uncompressed data stream.
 293  */
 294 -z_off_t ZEXPORT gztell (file)
 295 +ZEXPORT z_off_t gztell (file)
 296      gzFile file;
 297  {
 298      return gzseek(file, 0L, SEEK_CUR);
 299 @@ -888,7 +888,7 @@
 300       Returns 1 when EOF has previously been detected reading the given
 301     input stream, otherwise zero.
 302  */
 303 -int ZEXPORT gzeof (file)
 304 +ZEXPORT int gzeof (file)
 305      gzFile file;
 306  {
 307      gz_stream *s = (gz_stream*)file;
 308 @@ -938,7 +938,7 @@
 309       Flushes all pending output if necessary, closes the compressed file
 310     and deallocates all the (de)compression state.
 311  */
 312 -int ZEXPORT gzclose (file)
 313 +ZEXPORT int gzclose (file)
 314      gzFile file;
 315  {
 316      int err;
 317 @@ -967,7 +967,7 @@
 318     errnum is set to Z_ERRNO and the application may consult errno
 319     to get the exact error code.
 320  */
 321 -const char * ZEXPORT gzerror (file, errnum)
 322 +ZEXPORT const char * gzerror (file, errnum)
 323      gzFile file;
 324      int *errnum;
 325  {
 326 @@ -997,7 +997,7 @@
 327  /* ===========================================================================
 328       Clear the error and end-of-file flags, and do the same for the real file.
 329  */
 330 -void ZEXPORT gzclearerr (file)
 331 +ZEXPORT void gzclearerr (file)
 332      gzFile file;
 333  {
 334      gz_stream *s = (gz_stream*)file;
 335 --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/infback.c        2004-10-03 21:31:20.000000000 -0500
 336 +++ zlib-1.2.2/infback.c        2005-02-28 19:04:09.000000000 -0600
 337 @@ -25,7 +25,7 @@
 338     windowBits is in the range 8..15, and window is a user-supplied
 339     window and output buffer that is 2**windowBits bytes.
 340   */
 341 -int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
 342 +ZEXPORT int inflateBackInit_(strm, windowBits, window, version, stream_size)
 343  z_stream FAR *strm;
 344  int windowBits;
 345  unsigned char FAR *window;
 346 @@ -237,7 +237,7 @@
 347     inflateBack() can also return Z_STREAM_ERROR if the input parameters
 348     are not correct, i.e. strm is Z_NULL or the state was not initialized.
 349   */
 350 -int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
 351 +ZEXPORT int inflateBack(strm, in, in_desc, out, out_desc)
 352  z_stream FAR *strm;
 353  in_func in;
 354  void FAR *in_desc;
 355 @@ -610,7 +610,7 @@
 356      return ret;
 357  }
 358
 359 -int ZEXPORT inflateBackEnd(strm)
 360 +ZEXPORT int inflateBackEnd(strm)
 361  z_stream FAR *strm;
 362  {
 363      if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
 364 --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/inflate.c        2004-10-03 21:33:51.000000000 -0500
 365 +++ zlib-1.2.2/inflate.c        2005-02-28 19:04:09.000000000 -0600
 366 @@ -100,7 +100,7 @@
 367  local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
 368                                unsigned len));
 369
 370 -int ZEXPORT inflateReset(strm)
 371 +ZEXPORT int inflateReset(strm)
 372  z_streamp strm;
 373  {
 374      struct inflate_state FAR *state;
 375 @@ -122,7 +122,7 @@
 376      return Z_OK;
 377  }
 378
 379 -int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
 380 +ZEXPORT int inflateInit2_(strm, windowBits, version, stream_size)
 381  z_streamp strm;
 382  int windowBits;
 383  const char *version;
 384 @@ -165,7 +165,7 @@
 385      return inflateReset(strm);
 386  }
 387
 388 -int ZEXPORT inflateInit_(strm, version, stream_size)
 389 +ZEXPORT int inflateInit_(strm, version, stream_size)
 390  z_streamp strm;
 391  const char *version;
 392  int stream_size;
 393 @@ -532,7 +532,7 @@
 394     will return Z_BUF_ERROR if it has not reached the end of the stream.
 395   */
 396
 397 -int ZEXPORT inflate(strm, flush)
 398 +ZEXPORT int inflate(strm, flush)
 399  z_streamp strm;
 400  int flush;
 401  {
 402 @@ -1085,7 +1085,7 @@
 403      return ret;
 404  }
 405
 406 -int ZEXPORT inflateEnd(strm)
 407 +ZEXPORT int inflateEnd(strm)
 408  z_streamp strm;
 409  {
 410      struct inflate_state FAR *state;
 411 @@ -1099,7 +1099,7 @@
 412      return Z_OK;
 413  }
 414
 415 -int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
 416 +ZEXPORT int inflateSetDictionary(strm, dictionary, dictLength)
 417  z_streamp strm;
 418  const Bytef *dictionary;
 419  uInt dictLength;
 420 @@ -1171,7 +1171,7 @@
 421      return next;
 422  }
 423
 424 -int ZEXPORT inflateSync(strm)
 425 +ZEXPORT int inflateSync(strm)
 426  z_streamp strm;
 427  {
 428      unsigned len;               /* number of bytes to look at or looked at */
 429 @@ -1222,7 +1222,7 @@
 430     block. When decompressing, PPP checks that at the end of input packet,
 431     inflate is waiting for these length bytes.
 432   */
 433 -int ZEXPORT inflateSyncPoint(strm)
 434 +ZEXPORT int inflateSyncPoint(strm)
 435  z_streamp strm;
 436  {
 437      struct inflate_state FAR *state;
 438 @@ -1232,7 +1232,7 @@
 439      return state->mode == STORED && state->bits == 0;
 440  }
 441
 442 -int ZEXPORT inflateCopy(dest, source)
 443 +ZEXPORT int inflateCopy(dest, source)
 444  z_streamp dest;
 445  z_streamp source;
 446  {
 447 --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/uncompr.c        2003-07-07 00:36:56.000000000 -0500
 448 +++ zlib-1.2.2/uncompr.c        2005-02-28 19:04:09.000000000 -0600
 449 @@ -23,7 +23,7 @@
 450     enough memory, Z_BUF_ERROR if there was not enough room in the output
 451     buffer, or Z_DATA_ERROR if the input data was corrupted.
 452  */
 453 -int ZEXPORT uncompress (dest, destLen, source, sourceLen)
 454 +ZEXPORT int uncompress (dest, destLen, source, sourceLen)
 455      Bytef *dest;
 456      uLongf *destLen;
 457      const Bytef *source;
 458 --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/zconf.in.h       2004-05-30 15:38:00.000000000 -0500
 459 +++ zlib-1.2.2/zconf.in.h       2005-02-28 19:04:09.000000000 -0600
 460 @@ -198,11 +198,9 @@
 461      */
 462  #  ifdef ZLIB_DLL
 463  #    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
 464 -#      ifdef ZLIB_INTERNAL
 465 -#        define ZEXTERN extern __declspec(dllexport)
 466 -#      else
 467 -#        define ZEXTERN extern __declspec(dllimport)
 468 -#      endif
 469 +#      define ZDLLLOCAL __declspec(dllimport)
 470 +#      define ZDLLPUBLIC __declspec(dllexport)
 471 +#      define ZEXTERN extern
 472  #    endif
 473  #  endif  /* ZLIB_DLL */
 474     /* If building or using zlib with the WINAPI/WINAPIV calling convention,
 475 @@ -223,30 +221,45 @@
 476  #      define ZEXPORTVA FAR CDECL
 477  #    endif
 478  #  endif
 479 -#endif
 480 -
 481 -#if defined (__BEOS__)
 482 +#elif defined (__BEOS__)
 483  #  ifdef ZLIB_DLL
 484 -#    ifdef ZLIB_INTERNAL
 485 -#      define ZEXPORT   __declspec(dllexport)
 486 -#      define ZEXPORTVA __declspec(dllexport)
 487 -#    else
 488 -#      define ZEXPORT   __declspec(dllimport)
 489 -#      define ZEXPORTVA __declspec(dllimport)
 490 -#    endif
 491 +#    define ZDLLIMPORT __declspec(dllimport)
 492 +#    define ZDLLPUBLIC __declspec(dllexport)
 493 +#    define ZDLLLOCAL
 494 +#  endif
 495 +#else
 496 +#  define ZDLLIMPORT
 497 +#  ifdef GCC_HASCLASSVISIBILITY
 498 +#    define ZDLLLOCAL __attribute__ ((visibility("hidden")))
 499 +#    define ZDLLPUBLIC __attribute__ ((visibility("default")))
 500 +#  else
 501 +#    define ZDLLLOCAL
 502 +#    define ZDLLPUBLIC
 503  #  endif
 504  #endif
 505
 506  #ifndef ZEXTERN
 507  #  define ZEXTERN extern
 508  #endif
 509 -#ifndef ZEXPORT
 510 -#  define ZEXPORT
 511 -#endif
 512 -#ifndef ZEXPORTVA
 513 -#  define ZEXPORTVA
 514 +#ifdef ZLIB_INTERNAL
 515 +#  ifndef ZLIB_DLL
 516 +#   define ZEXPORT
 517 +#   define ZEXPORTVA
 518 +#  endif
 519 +#  ifndef ZEXPORT
 520 +#    define ZEXPORT ZDLLPUBLIC
 521 +#  endif
 522 +#  ifndef ZEXPORTVA
 523 +#    define ZEXPORTVA ZDLLPUBLIC
 524 +#  endif
 525 +#else
 526 +#  ifndef ZEXPORT
 527 +#    define ZEXPORT ZDLLIMPORT
 528 +#  endif
 529 +#  ifndef ZEXPORTVA
 530 +#    define ZEXPORTVA ZDLLIMPORT
 531 +#  endif
 532  #endif
 533 -
 534  #ifndef FAR
 535  #  define FAR
 536  #endif
 537 --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/zlib.h   2004-10-03 21:57:26.000000000 -0500
 538 +++ zlib-1.2.2/zlib.h   2005-02-28 19:04:09.000000000 -0600
 539 @@ -184,7 +184,7 @@
 540
 541                          /* basic functions */
 542
 543 -ZEXTERN const char * ZEXPORT zlibVersion OF((void));
 544 +ZEXTERN ZEXPORT const char * zlibVersion OF((void));
 545  /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
 546     If the first character differs, the library code actually used is
 547     not compatible with the zlib.h header file used by the application.
 548 @@ -192,7 +192,7 @@
 549   */
 550
 551  /*
 552 -ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
 553 +ZEXTERN ZEXPORT int deflateInit OF((z_streamp strm, int level));
 554
 555       Initializes the internal stream state for compression. The fields
 556     zalloc, zfree and opaque must be initialized before by the caller.
 557 @@ -214,7 +214,7 @@
 558  */
 559
 560
 561 -ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
 562 +ZEXTERN ZEXPORT int deflate OF((z_streamp strm, int flush));
 563  /*
 564      deflate compresses as much data as possible, and stops when the input
 565    buffer becomes empty or the output buffer becomes full. It may introduce some
 566 @@ -296,7 +296,7 @@
 567  */
 568
 569
 570 -ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
 571 +ZEXTERN ZEXPORT int deflateEnd OF((z_streamp strm));
 572  /*
 573       All dynamically allocated data structures for this stream are freed.
 574     This function discards any unprocessed input and does not flush any
 575 @@ -311,7 +311,7 @@
 576
 577
 578  /*
 579 -ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
 580 +ZEXTERN ZEXPORT int inflateInit OF((z_streamp strm));
 581
 582       Initializes the internal stream state for decompression. The fields
 583     next_in, avail_in, zalloc, zfree and opaque must be initialized before by
 584 @@ -331,7 +331,7 @@
 585  */
 586
 587
 588 -ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
 589 +ZEXTERN ZEXPORT int inflate OF((z_streamp strm, int flush));
 590  /*
 591      inflate decompresses as much data as possible, and stops when the input
 592    buffer becomes empty or the output buffer becomes full. It may introduce
 593 @@ -430,7 +430,7 @@
 594  */
 595
 596
 597 -ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
 598 +ZEXTERN ZEXPORT int inflateEnd OF((z_streamp strm));
 599  /*
 600       All dynamically allocated data structures for this stream are freed.
 601     This function discards any unprocessed input and does not flush any
 602 @@ -448,7 +448,7 @@
 603  */
 604
 605  /*
 606 -ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
 607 +ZEXTERN ZEXPORT int deflateInit2 OF((z_streamp strm,
 608                                       int  level,
 609                                       int  method,
 610                                       int  windowBits,
 611 @@ -504,7 +504,7 @@
 612     not perform any compression: this will be done by deflate().
 613  */
 614
 615 -ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
 616 +ZEXTERN ZEXPORT int deflateSetDictionary OF((z_streamp strm,
 617                                               const Bytef *dictionary,
 618                                               uInt  dictLength));
 619  /*
 620 @@ -541,7 +541,7 @@
 621     perform any compression: this will be done by deflate().
 622  */
 623
 624 -ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
 625 +ZEXTERN ZEXPORT int deflateCopy OF((z_streamp dest,
 626                                      z_streamp source));
 627  /*
 628       Sets the destination stream as a complete copy of the source stream.
 629 @@ -559,7 +559,7 @@
 630     destination.
 631  */
 632
 633 -ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
 634 +ZEXTERN ZEXPORT int deflateReset OF((z_streamp strm));
 635  /*
 636       This function is equivalent to deflateEnd followed by deflateInit,
 637     but does not free and reallocate all the internal compression state.
 638 @@ -570,7 +570,7 @@
 639     stream state was inconsistent (such as zalloc or state being NULL).
 640  */
 641
 642 -ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
 643 +ZEXTERN ZEXPORT int deflateParams OF((z_streamp strm,
 644                                        int level,
 645                                        int strategy));
 646  /*
 647 @@ -591,7 +591,7 @@
 648     if strm->avail_out was zero.
 649  */
 650
 651 -ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
 652 +ZEXTERN ZEXPORT uLong deflateBound OF((z_streamp strm,
 653                                         uLong sourceLen));
 654  /*
 655       deflateBound() returns an upper bound on the compressed size after
 656 @@ -600,7 +600,7 @@
 657     for deflation in a single pass, and so would be called before deflate().
 658  */
 659
 660 -ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
 661 +ZEXTERN ZEXPORT int deflatePrime OF((z_streamp strm,
 662                                       int bits,
 663                                       int value));
 664  /*
 665 @@ -617,7 +617,7 @@
 666  */
 667
 668  /*
 669 -ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
 670 +ZEXTERN ZEXPORT int inflateInit2 OF((z_streamp strm,
 671                                       int  windowBits));
 672
 673       This is another version of inflateInit with an extra parameter. The
 674 @@ -659,7 +659,7 @@
 675     modified, but next_out and avail_out are unchanged.)
 676  */
 677
 678 -ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
 679 +ZEXTERN ZEXPORT int inflateSetDictionary OF((z_streamp strm,
 680                                               const Bytef *dictionary,
 681                                               uInt  dictLength));
 682  /*
 683 @@ -678,7 +678,7 @@
 684     inflate().
 685  */
 686
 687 -ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
 688 +ZEXTERN ZEXPORT int inflateSync OF((z_streamp strm));
 689  /*
 690      Skips invalid compressed data until a full flush point (see above the
 691    description of deflate with Z_FULL_FLUSH) can be found, or until all
 692 @@ -693,7 +693,7 @@
 693    until success or end of the input data.
 694  */
 695
 696 -ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
 697 +ZEXTERN ZEXPORT int inflateCopy OF((z_streamp dest,
 698                                      z_streamp source));
 699  /*
 700       Sets the destination stream as a complete copy of the source stream.
 701 @@ -709,7 +709,7 @@
 702     destination.
 703  */
 704
 705 -ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
 706 +ZEXTERN ZEXPORT int inflateReset OF((z_streamp strm));
 707  /*
 708       This function is equivalent to inflateEnd followed by inflateInit,
 709     but does not free and reallocate all the internal decompression state.
 710 @@ -720,7 +720,7 @@
 711  */
 712
 713  /*
 714 -ZEXTERN int ZEXPORT inflateBackInit OF((z_stream FAR *strm, int windowBits,
 715 +ZEXTERN ZEXPORT int inflateBackInit OF((z_stream FAR *strm, int windowBits,
 716                                          unsigned char FAR *window));
 717
 718       Initialize the internal stream state for decompression using inflateBack()
 719 @@ -744,7 +744,7 @@
 720  typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));
 721  typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
 722
 723 -ZEXTERN int ZEXPORT inflateBack OF((z_stream FAR *strm,
 724 +ZEXTERN ZEXPORT int inflateBack OF((z_stream FAR *strm,
 725                                      in_func in, void FAR *in_desc,
 726                                      out_func out, void FAR *out_desc));
 727  /*
 728 @@ -813,7 +813,7 @@
 729     that inflateBack() cannot return Z_OK.
 730  */
 731
 732 -ZEXTERN int ZEXPORT inflateBackEnd OF((z_stream FAR *strm));
 733 +ZEXTERN ZEXPORT int inflateBackEnd OF((z_stream FAR *strm));
 734  /*
 735       All memory allocated by inflateBackInit() is freed.
 736
 737 @@ -821,7 +821,7 @@
 738     state was inconsistent.
 739  */
 740
 741 -ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
 742 +ZEXTERN ZEXPORT uLong zlibCompileFlags OF((void));
 743  /* Return flags indicating compile-time options.
 744
 745      Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
 746 @@ -873,7 +873,7 @@
 747     utility functions can easily be modified if you need special options.
 748  */
 749
 750 -ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
 751 +ZEXTERN ZEXPORT int compress OF((Bytef *dest,   uLongf *destLen,
 752                                   const Bytef *source, uLong sourceLen));
 753  /*
 754       Compresses the source buffer into the destination buffer.  sourceLen is
 755 @@ -888,7 +888,7 @@
 756     buffer.
 757  */
 758
 759 -ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
 760 +ZEXTERN ZEXPORT int compress2 OF((Bytef *dest,   uLongf *destLen,
 761                                    const Bytef *source, uLong sourceLen,
 762                                    int level));
 763  /*
 764 @@ -904,14 +904,14 @@
 765     Z_STREAM_ERROR if the level parameter is invalid.
 766  */
 767
 768 -ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
 769 +ZEXTERN ZEXPORT uLong compressBound OF((uLong sourceLen));
 770  /*
 771       compressBound() returns an upper bound on the compressed size after
 772     compress() or compress2() on sourceLen bytes.  It would be used before
 773     a compress() or compress2() call to allocate the destination buffer.
 774  */
 775
 776 -ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
 777 +ZEXTERN ZEXPORT int uncompress OF((Bytef *dest,   uLongf *destLen,
 778                                     const Bytef *source, uLong sourceLen));
 779  /*
 780       Decompresses the source buffer into the destination buffer.  sourceLen is
 781 @@ -932,7 +932,7 @@
 782
 783  typedef voidp gzFile;
 784
 785 -ZEXTERN gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
 786 +ZEXTERN ZEXPORT gzFile gzopen  OF((const char *path, const char *mode));
 787  /*
 788       Opens a gzip (.gz) file for reading or writing. The mode parameter
 789     is as in fopen ("rb" or "wb") but can also include a compression level
 790 @@ -949,7 +949,7 @@
 791     can be checked to distinguish the two cases (if errno is zero, the
 792     zlib error is Z_MEM_ERROR).  */
 793
 794 -ZEXTERN gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
 795 +ZEXTERN ZEXPORT gzFile gzdopen  OF((int fd, const char *mode));
 796  /*
 797       gzdopen() associates a gzFile with the file descriptor fd.  File
 798     descriptors are obtained from calls like open, dup, creat, pipe or
 799 @@ -962,7 +962,7 @@
 800     the (de)compression state.
 801  */
 802
 803 -ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
 804 +ZEXTERN ZEXPORT int gzsetparams OF((gzFile file, int level, int strategy));
 805  /*
 806       Dynamically update the compression level or strategy. See the description
 807     of deflateInit2 for the meaning of these parameters.
 808 @@ -970,7 +970,7 @@
 809     opened for writing.
 810  */
 811
 812 -ZEXTERN int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
 813 +ZEXTERN ZEXPORT int    gzread  OF((gzFile file, voidp buf, unsigned len));
 814  /*
 815       Reads the given number of uncompressed bytes from the compressed file.
 816     If the input file was not in gzip format, gzread copies the given number
 817 @@ -978,7 +978,7 @@
 818       gzread returns the number of uncompressed bytes actually read (0 for
 819     end of file, -1 for error). */
 820
 821 -ZEXTERN int ZEXPORT    gzwrite OF((gzFile file,
 822 +ZEXTERN ZEXPORT int    gzwrite OF((gzFile file,
 823                                     voidpc buf, unsigned len));
 824  /*
 825       Writes the given number of uncompressed bytes into the compressed file.
 826 @@ -986,7 +986,7 @@
 827     (0 in case of error).
 828  */
 829
 830 -ZEXTERN int ZEXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
 831 +ZEXTERN ZEXPORTVA int   gzprintf OF((gzFile file, const char *format, ...));
 832  /*
 833       Converts, formats, and writes the args to the compressed file under
 834     control of the format string, as in fprintf. gzprintf returns the number of
 835 @@ -999,14 +999,14 @@
 836     because the secure snprintf() or vsnprintf() functions were not available.
 837  */
 838
 839 -ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
 840 +ZEXTERN ZEXPORT int gzputs OF((gzFile file, const char *s));
 841  /*
 842        Writes the given null-terminated string to the compressed file, excluding
 843     the terminating null character.
 844        gzputs returns the number of characters written, or -1 in case of error.
 845  */
 846
 847 -ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
 848 +ZEXTERN ZEXPORT char *  gzgets OF((gzFile file, char *buf, int len));
 849  /*
 850        Reads bytes from the compressed file until len-1 characters are read, or
 851     a newline character is read and transferred to buf, or an end-of-file
 852 @@ -1015,19 +1015,19 @@
 853        gzgets returns buf, or Z_NULL in case of error.
 854  */
 855
 856 -ZEXTERN int ZEXPORT    gzputc OF((gzFile file, int c));
 857 +ZEXTERN ZEXPORT int    gzputc OF((gzFile file, int c));
 858  /*
 859        Writes c, converted to an unsigned char, into the compressed file.
 860     gzputc returns the value that was written, or -1 in case of error.
 861  */
 862
 863 -ZEXTERN int ZEXPORT    gzgetc OF((gzFile file));
 864 +ZEXTERN ZEXPORT int    gzgetc OF((gzFile file));
 865  /*
 866        Reads one byte from the compressed file. gzgetc returns this byte
 867     or -1 in case of end of file or error.
 868  */
 869
 870 -ZEXTERN int ZEXPORT    gzungetc OF((int c, gzFile file));
 871 +ZEXTERN ZEXPORT int    gzungetc OF((int c, gzFile file));
 872  /*
 873        Push one character back onto the stream to be read again later.
 874     Only one character of push-back is allowed.  gzungetc() returns the
 875 @@ -1037,7 +1037,7 @@
 876     or gzrewind().
 877  */
 878
 879 -ZEXTERN int ZEXPORT    gzflush OF((gzFile file, int flush));
 880 +ZEXTERN ZEXPORT int    gzflush OF((gzFile file, int flush));
 881  /*
 882       Flushes all pending output into the compressed file. The parameter
 883     flush is as in the deflate() function. The return value is the zlib
 884 @@ -1047,7 +1047,7 @@
 885     degrade compression.
 886  */
 887
 888 -ZEXTERN z_off_t ZEXPORT    gzseek OF((gzFile file,
 889 +ZEXTERN ZEXPORT z_off_t    gzseek OF((gzFile file,
 890                                        z_off_t offset, int whence));
 891  /*
 892        Sets the starting position for the next gzread or gzwrite on the
 893 @@ -1065,14 +1065,14 @@
 894     would be before the current position.
 895  */
 896
 897 -ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
 898 +ZEXTERN ZEXPORT int    gzrewind OF((gzFile file));
 899  /*
 900       Rewinds the given file. This function is supported only for reading.
 901
 902     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
 903  */
 904
 905 -ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
 906 +ZEXTERN ZEXPORT z_off_t    gztell OF((gzFile file));
 907  /*
 908       Returns the starting position for the next gzread or gzwrite on the
 909     given compressed file. This position represents a number of bytes in the
 910 @@ -1081,20 +1081,20 @@
 911     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
 912  */
 913
 914 -ZEXTERN int ZEXPORT gzeof OF((gzFile file));
 915 +ZEXTERN ZEXPORT int gzeof OF((gzFile file));
 916  /*
 917       Returns 1 when EOF has previously been detected reading the given
 918     input stream, otherwise zero.
 919  */
 920
 921 -ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
 922 +ZEXTERN ZEXPORT int    gzclose OF((gzFile file));
 923  /*
 924       Flushes all pending output if necessary, closes the compressed file
 925     and deallocates all the (de)compression state. The return value is the zlib
 926     error number (see function gzerror below).
 927  */
 928
 929 -ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
 930 +ZEXTERN ZEXPORT const char *  gzerror OF((gzFile file, int *errnum));
 931  /*
 932       Returns the error message for the last error which occurred on the
 933     given compressed file. errnum is set to zlib error number. If an
 934 @@ -1103,7 +1103,7 @@
 935     to get the exact error code.
 936  */
 937
 938 -ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
 939 +ZEXTERN ZEXPORT void gzclearerr OF((gzFile file));
 940  /*
 941       Clears the error and end-of-file flags for file. This is analogous to the
 942     clearerr() function in stdio. This is useful for continuing to read a gzip
 943 @@ -1118,7 +1118,7 @@
 944     compression library.
 945  */
 946
 947 -ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
 948 +ZEXTERN ZEXPORT uLong adler32 OF((uLong adler, const Bytef *buf, uInt len));
 949
 950  /*
 951       Update a running Adler-32 checksum with the bytes buf[0..len-1] and
 952 @@ -1135,7 +1135,7 @@
 953       if (adler != original_adler) error();
 954  */
 955
 956 -ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
 957 +ZEXTERN ZEXPORT uLong crc32   OF((uLong crc, const Bytef *buf, uInt len));
 958  /*
 959       Update a running crc with the bytes buf[0..len-1] and return the updated
 960     crc. If buf is NULL, this function returns the required initial value
 961 @@ -1157,17 +1157,17 @@
 962  /* deflateInit and inflateInit are macros to allow checking the zlib version
 963   * and the compiler's view of z_stream:
 964   */
 965 -ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
 966 +ZEXTERN ZEXPORT int deflateInit_ OF((z_streamp strm, int level,
 967                                       const char *version, int stream_size));
 968 -ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
 969 +ZEXTERN ZEXPORT int inflateInit_ OF((z_streamp strm,
 970                                       const char *version, int stream_size));
 971 -ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
 972 +ZEXTERN ZEXPORT int deflateInit2_ OF((z_streamp strm, int  level, int  method,
 973                                        int windowBits, int memLevel,
 974                                        int strategy, const char *version,
 975                                        int stream_size));
 976 -ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
 977 +ZEXTERN ZEXPORT int inflateInit2_ OF((z_streamp strm, int  windowBits,
 978                                        const char *version, int stream_size));
 979 -ZEXTERN int ZEXPORT inflateBackInit_ OF((z_stream FAR *strm, int windowBits,
 980 +ZEXTERN ZEXPORT int inflateBackInit_ OF((z_stream FAR *strm, int windowBits,
 981                                           unsigned char FAR *window,
 982                                           const char *version,
 983                                           int stream_size));
 984 @@ -1189,9 +1189,9 @@
 985      struct internal_state {int dummy;}; /* hack for buggy compilers */
 986  #endif
 987
 988 -ZEXTERN const char   * ZEXPORT zError           OF((int));
 989 -ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp z));
 990 -ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
 991 +ZEXTERN ZEXPORT const char   *  zError           OF((int));
 992 +ZEXTERN ZEXPORT int            inflateSyncPoint OF((z_streamp z));
 993 +ZEXTERN ZEXPORT const uLongf *  get_crc_table    OF((void));
 994
 995  #ifdef __cplusplus
 996  }
 997 --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/zutil.c  2003-08-27 21:34:34.000000000 -0500
 998 +++ zlib-1.2.2/zutil.c  2005-02-28 19:04:09.000000000 -0600
 999 @@ -28,12 +28,12 @@
1000  ""};
1001
1002
1003 -const char * ZEXPORT zlibVersion()
1004 +ZEXPORT const char * zlibVersion()
1005  {
1006      return ZLIB_VERSION;
1007  }
1008
1009 -uLong ZEXPORT zlibCompileFlags()
1010 +ZEXPORT uLong zlibCompileFlags()
1011  {
1012      uLong flags;
1013
1014 @@ -134,7 +134,7 @@
1015  /* exported to allow conversion of error code to string for compress() and
1016   * uncompress()
1017   */
1018 -const char * ZEXPORT zError(err)
1019 +ZEXPORT const char * zError(err)
1020      int err;
1021  {
1022      return ERR_MSG(err);