rename include/zlib.h to include/u-boot/zlib.h

Some systems have zlib.h installed in /usr/include/. This isn't the desired file for u-boot code - we want the one in include/zlib.h. This rename will avoid the conflict. Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com> Signed-off-by: Mike Frysinger <vapier@gentoo.org>

rename include/zlib.h to include/u-boot/zlib.h
Some systems have zlib.h installed in /usr/include/. This isn't the desired file for u-boot code - we want the one in include/zlib.h. This rename will avoid the conflict. Signed-off-by: Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com> Signed-off-by: Mike Frysinger <vapier@gentoo.org>
Jean-Christophe PLAGNIOL-VILLARD · Wolfgang Denk
1 parent ae644c178f
Showing 14 changed files with 446 additions and 446 deletions Side-by-side Diff
common/cmd_bootm.c
fs/cramfs/uncompress.c
include/u-boot/zlib.h
include/zlib.h
lib_arm/bootm.c
lib_avr32/bootm.c
lib_generic/crc32.c
lib_generic/gunzip.c
lib_generic/zlib.c
lib_i386/bootm.c
lib_m68k/bootm.c
lib_microblaze/bootm.c
lib_mips/bootm.c
lib_ppc/bootm.c
@@ -30,7 +30,7 @@
 #include <command.h>
 #include <image.h>
 #include <malloc.h>
-#include <zlib.h>
+#include <u-boot/zlib.h>
 #include <bzlib.h>
 #include <environment.h>
 #include <lmb.h>
@@ -23,7 +23,7 @@
 #include <common.h>
 #include <malloc.h>
 #include <watchdog.h>
-#include <zlib.h>
+#include <u-boot/zlib.h>
  
 static z_stream stream;
  
+/*
+ * This file is derived from zlib.h and zconf.h from the zlib-0.95
+ * distribution by Jean-loup Gailly and Mark Adler, with some additions
+ * by Paul Mackerras to aid in implementing Deflate compression and
+ * decompression for PPP packets.
+ */
+
+/*
+ *  ==FILEVERSION 960122==
+ *
+ * This marker is used by the Linux installation script to determine
+ * whether an up-to-date version of this file is already installed.
+ */
+
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 0.95, Aug 16th, 1995.
+
+  Copyright (C) 1995 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  gzip@prep.ai.mit.edu    madler@alumni.caltech.edu
+ */
+
+#ifndef _ZLIB_H
+#define _ZLIB_H
+
+/* #include "zconf.h" */	/* included directly here */
+
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* From: zconf.h,v 1.12 1995/05/03 17:27:12 jloup Exp */
+
+/*
+     The library does not install any signal handler. It is recommended to
+  add at least a handler for SIGSEGV when decompressing; the library checks
+  the consistency of the input data whenever possible but may go nuts
+  for some forms of corrupted input.
+ */
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ * Compile with -DUNALIGNED_OK if it is OK to access shorts or ints
+ * at addresses which are not a multiple of their size.
+ * Under DOS, -DFAR=far or -DFAR=__far may be needed.
+ */
+
+#ifndef STDC
+#  if defined(MSDOS) || defined(__STDC__) || defined(__cplusplus)
+#    define STDC
+#  endif
+#endif
+
+#ifdef	__MWERKS__ /* Metrowerks CodeWarrior declares fileno() in unix.h */
+#  include <unix.h>
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2 */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+	    1 << (windowBits+2)   +  1 << (memLevel+9)
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+			/* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+typedef unsigned char  Byte;  /* 8 bits */
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+typedef Byte FAR Bytef;
+typedef char FAR charf;
+typedef int FAR intf;
+typedef uInt FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void FAR *voidpf;
+   typedef void     *voidp;
+#else
+   typedef Byte FAR *voidpf;
+   typedef Byte     *voidp;
+#endif
+
+/* end of original zconf.h */
+
+#define ZLIB_VERSION "0.95P"
+
+/*
+     The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed
+  data.  This version of the library supports only one compression method
+  (deflation) but other algorithms may be added later and will have the same
+  stream interface.
+
+     For compression the application must provide the output buffer and
+  may optionally provide the input buffer for optimization. For decompression,
+  the application must provide the input buffer and may optionally provide
+  the output buffer for optimization.
+
+     Compression can be done in a single step if the buffers are large
+  enough (for example if an input file is mmap'ed), or can be done by
+  repeated calls of the compression function.  In the latter case, the
+  application must provide more input and/or consume the output
+  (providing more output space) before each call.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address, uInt nbytes));
+
+typedef void   (*cb_func)    OF((Bytef *buf, uInt len));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidp      opaque;  /* private data object passed to zalloc and zfree */
+
+    Byte     data_type; /* best guess about the data type: ascii or binary */
+
+    cb_func  outcb;	/* called regularly just before blocks of output */
+
+} z_stream;
+
+/*
+   The application must update next_in and avail_in when avail_in has
+   dropped to zero. It must update next_out and avail_out when avail_out
+   has dropped to zero. The application must initialize zalloc, zfree and
+   opaque before calling the init function. All other fields are set by the
+   compression library and must not be updated by the application.
+
+   The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree. This can be useful for custom
+   memory management. The compression library attaches no meaning to the
+   opaque value.
+
+   zalloc must return Z_NULL if there is not enough memory for the object.
+   On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this
+   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
+   pointers returned by zalloc for objects of exactly 65536 bytes *must*
+   have their offset normalized to zero. The default allocation function
+   provided by this library ensures this (see zutil.c). To reduce memory
+   requirements and avoid any allocation of 64K objects, at the expense of
+   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
+
+   The fields total_in and total_out can be used for statistics or
+   progress reports. After compression, total_in holds the total size of
+   the uncompressed data and may be saved for use in the decompressor
+   (particularly if the decompressor wants to decompress everything in
+   a single step).
+*/
+
+			/* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1
+#define Z_FULL_FLUSH    2
+#define Z_SYNC_FLUSH    3 /* experimental: partial_flush + byte align */
+#define Z_FINISH        4
+#define Z_PACKET_FLUSH	5
+/* See deflate() below for the usage of these constants */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+/* error codes for the compression/decompression functions */
+
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_DEFAULT_STRATEGY    0
+
+#define Z_BINARY   0
+#define Z_ASCII    1
+#define Z_UNKNOWN  2
+/* Used to set the data_type field */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+extern char *zlib_version;
+/* The application can compare zlib_version and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is
+   not compatible with the zlib.h header file used by the application.
+ */
+
+			/* basic functions */
+
+extern int inflateInit OF((z_stream *strm));
+/*
+     Initializes the internal stream state for decompression. The fields
+   zalloc and zfree must be initialized before by the caller.  If zalloc and
+   zfree are set to Z_NULL, inflateInit updates them to use default allocation
+   functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory.  msg is set to null if there is no error message.
+   inflateInit does not perform any decompression: this will be done by
+   inflate().
+*/
+
+
+extern int inflate OF((z_stream *strm, int flush));
+/*
+  Performs one or both of the following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly. If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing
+    will resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() always provides as much output as possible
+    (until there is no more input data or no more space in the output buffer).
+
+  Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming
+  more output, and updating the next_* and avail_* values accordingly.
+  The application can consume the uncompressed output when it wants, for
+  example when the output buffer is full (avail_out == 0), or after each
+  call of inflate().
+
+    If the parameter flush is set to Z_PARTIAL_FLUSH or Z_PACKET_FLUSH,
+  inflate flushes as much output as possible to the output buffer. The
+  flushing behavior of inflate is not specified for values of the flush
+  parameter other than Z_PARTIAL_FLUSH, Z_PACKET_FLUSH or Z_FINISH, but the
+  current implementation actually flushes as much output as possible
+  anyway.  For Z_PACKET_FLUSH, inflate checks that once all the input data
+  has been consumed, it is expecting to see the length field of a stored
+  block; if not, it returns Z_DATA_ERROR.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error. However if all decompression is to be performed in a single step
+  (a single call of inflate), the parameter flush should be set to
+  Z_FINISH. In this case all pending input is processed and all pending
+  output is flushed; avail_out must be large enough to hold all the
+  uncompressed data. (The size of the uncompressed data may have been saved
+  by the compressor for this purpose.) The next operation on this stream must
+  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
+  is never required, but can be used to inform inflate that a faster routine
+  may be used for the single inflate() call.
+
+    inflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if the end of the
+  compressed data has been reached and all uncompressed output has been
+  produced, Z_DATA_ERROR if the input data was corrupted, Z_STREAM_ERROR if
+  the stream structure was inconsistent (for example if next_in or next_out
+  was NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no
+  progress is possible or if there was not enough room in the output buffer
+  when Z_FINISH is used. In the Z_DATA_ERROR case, the application may then
+  call inflateSync to look for a good compression block.  */
+
+
+extern int inflateEnd OF((z_stream *strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any
+   pending output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent. In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+			/* advanced functions */
+
+extern int inflateInit2 OF((z_stream *strm,
+			    int  windowBits));
+/*
+     This is another version of inflateInit with more compression options. The
+   fields next_out, zalloc and zfree must be initialized before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library (the value 16 will be allowed soon). The
+   default value is 15 if inflateInit is used instead. If a compressed stream
+   with a larger window size is given as input, inflate() will return with
+   the error code Z_DATA_ERROR instead of trying to allocate a larger window.
+
+     If next_out is not null, the library will use this buffer for the history
+   buffer; the buffer must either be large enough to hold the entire output
+   data, or have at least 1<<windowBits bytes.  If next_out is null, the
+   library will allocate its own buffer (and leave next_out null). next_in
+   need not be provided here but must be provided by the application for the
+   next call of inflate().
+
+     If the history buffer is provided by the application, next_out must
+   never be changed by the application since the decompressor maintains
+   history information inside this buffer from call to call; the application
+   can only reset next_out to the beginning of the history buffer when
+   avail_out is zero and all output has been consumed.
+
+      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
+   not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
+   windowBits < 8). msg is set to null if there is no error message.
+   inflateInit2 does not perform any decompression: this will be done by
+   inflate().
+*/
+
+extern int inflateSync OF((z_stream *strm));
+/*
+    Skips invalid compressed data until the special marker (see deflate()
+  above) can be found, or until all available input is skipped. No output
+  is provided.
+
+    inflateSync returns Z_OK if the special marker has been found, Z_BUF_ERROR
+  if no more input was provided, Z_DATA_ERROR if no marker has been found,
+  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
+  case, the application may save the current current value of total_in which
+  indicates where valid compressed data was found. In the error case, the
+  application may repeatedly call inflateSync, providing more input each time,
+  until success or end of the input data.
+*/
+
+extern int inflateReset OF((z_stream *strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.
+   The stream will keep attributes that may have been set by inflateInit2.
+
+      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being NULL).
+*/
+
+extern int inflateIncomp OF((z_stream *strm));
+/*
+     This function adds the data at next_in (avail_in bytes) to the output
+   history without performing any output.  There must be no pending output,
+   and the decompressor must be expecting to see the start of a block.
+   Calling this function is equivalent to decompressing a stored block
+   containing the data at next_in (except that the data is not output).
+*/
+
+			/* checksum functions */
+
+/*
+     This function is not related to compression but is exported
+   anyway because it might be useful in applications using the
+   compression library.
+*/
+
+extern uLong adler32 OF((uLong adler, Bytef *buf, uInt len));
+
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum. If buf is NULL, this function returns
+   the required initial value for the checksum.
+   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster. Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+#ifndef _Z_UTIL_H
+    struct internal_state {int dummy;}; /* hack for buggy compilers */
+#endif
+
+#endif /* _ZLIB_H */
-/*
- * This file is derived from zlib.h and zconf.h from the zlib-0.95
- * distribution by Jean-loup Gailly and Mark Adler, with some additions
- * by Paul Mackerras to aid in implementing Deflate compression and
- * decompression for PPP packets.
- */
-
-/*
- *  ==FILEVERSION 960122==
- *
- * This marker is used by the Linux installation script to determine
- * whether an up-to-date version of this file is already installed.
- */
-
-/* zlib.h -- interface of the 'zlib' general purpose compression library
-  version 0.95, Aug 16th, 1995.
-
-  Copyright (C) 1995 Jean-loup Gailly and Mark Adler
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  Jean-loup Gailly        Mark Adler
-  gzip@prep.ai.mit.edu    madler@alumni.caltech.edu
- */
-
-#ifndef _ZLIB_H
-#define _ZLIB_H
-
-/* #include "zconf.h" */	/* included directly here */
-
-/* zconf.h -- configuration of the zlib compression library
- * Copyright (C) 1995 Jean-loup Gailly.
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-/* From: zconf.h,v 1.12 1995/05/03 17:27:12 jloup Exp */
-
-/*
-     The library does not install any signal handler. It is recommended to
-  add at least a handler for SIGSEGV when decompressing; the library checks
-  the consistency of the input data whenever possible but may go nuts
-  for some forms of corrupted input.
- */
-
-/*
- * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
- * than 64k bytes at a time (needed on systems with 16-bit int).
- * Compile with -DUNALIGNED_OK if it is OK to access shorts or ints
- * at addresses which are not a multiple of their size.
- * Under DOS, -DFAR=far or -DFAR=__far may be needed.
- */
-
-#ifndef STDC
-#  if defined(MSDOS) || defined(__STDC__) || defined(__cplusplus)
-#    define STDC
-#  endif
-#endif
-
-#ifdef	__MWERKS__ /* Metrowerks CodeWarrior declares fileno() in unix.h */
-#  include <unix.h>
-#endif
-
-/* Maximum value for memLevel in deflateInit2 */
-#ifndef MAX_MEM_LEVEL
-#  ifdef MAXSEG_64K
-#    define MAX_MEM_LEVEL 8
-#  else
-#    define MAX_MEM_LEVEL 9
-#  endif
-#endif
-
-#ifndef FAR
-#  define FAR
-#endif
-
-/* Maximum value for windowBits in deflateInit2 and inflateInit2 */
-#ifndef MAX_WBITS
-#  define MAX_WBITS   15 /* 32K LZ77 window */
-#endif
-
-/* The memory requirements for deflate are (in bytes):
-	    1 << (windowBits+2)   +  1 << (memLevel+9)
- that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
- plus a few kilobytes for small objects. For example, if you want to reduce
- the default memory requirements from 256K to 128K, compile with
-     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
- Of course this will generally degrade compression (there's no free lunch).
-
-   The memory requirements for inflate are (in bytes) 1 << windowBits
- that is, 32K for windowBits=15 (default value) plus a few kilobytes
- for small objects.
-*/
-
-			/* Type declarations */
-
-#ifndef OF /* function prototypes */
-#  ifdef STDC
-#    define OF(args)  args
-#  else
-#    define OF(args)  ()
-#  endif
-#endif
-
-typedef unsigned char  Byte;  /* 8 bits */
-typedef unsigned int   uInt;  /* 16 bits or more */
-typedef unsigned long  uLong; /* 32 bits or more */
-
-typedef Byte FAR Bytef;
-typedef char FAR charf;
-typedef int FAR intf;
-typedef uInt FAR uIntf;
-typedef uLong FAR uLongf;
-
-#ifdef STDC
-   typedef void FAR *voidpf;
-   typedef void     *voidp;
-#else
-   typedef Byte FAR *voidpf;
-   typedef Byte     *voidp;
-#endif
-
-/* end of original zconf.h */
-
-#define ZLIB_VERSION "0.95P"
-
-/*
-     The 'zlib' compression library provides in-memory compression and
-  decompression functions, including integrity checks of the uncompressed
-  data.  This version of the library supports only one compression method
-  (deflation) but other algorithms may be added later and will have the same
-  stream interface.
-
-     For compression the application must provide the output buffer and
-  may optionally provide the input buffer for optimization. For decompression,
-  the application must provide the input buffer and may optionally provide
-  the output buffer for optimization.
-
-     Compression can be done in a single step if the buffers are large
-  enough (for example if an input file is mmap'ed), or can be done by
-  repeated calls of the compression function.  In the latter case, the
-  application must provide more input and/or consume the output
-  (providing more output space) before each call.
-*/
-
-typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
-typedef void   (*free_func)  OF((voidpf opaque, voidpf address, uInt nbytes));
-
-typedef void   (*cb_func)    OF((Bytef *buf, uInt len));
-
-struct internal_state;
-
-typedef struct z_stream_s {
-    Bytef    *next_in;  /* next input byte */
-    uInt     avail_in;  /* number of bytes available at next_in */
-    uLong    total_in;  /* total nb of input bytes read so far */
-
-    Bytef    *next_out; /* next output byte should be put there */
-    uInt     avail_out; /* remaining free space at next_out */
-    uLong    total_out; /* total nb of bytes output so far */
-
-    char     *msg;      /* last error message, NULL if no error */
-    struct internal_state FAR *state; /* not visible by applications */
-
-    alloc_func zalloc;  /* used to allocate the internal state */
-    free_func  zfree;   /* used to free the internal state */
-    voidp      opaque;  /* private data object passed to zalloc and zfree */
-
-    Byte     data_type; /* best guess about the data type: ascii or binary */
-
-    cb_func  outcb;	/* called regularly just before blocks of output */
-
-} z_stream;
-
-/*
-   The application must update next_in and avail_in when avail_in has
-   dropped to zero. It must update next_out and avail_out when avail_out
-   has dropped to zero. The application must initialize zalloc, zfree and
-   opaque before calling the init function. All other fields are set by the
-   compression library and must not be updated by the application.
-
-   The opaque value provided by the application will be passed as the first
-   parameter for calls of zalloc and zfree. This can be useful for custom
-   memory management. The compression library attaches no meaning to the
-   opaque value.
-
-   zalloc must return Z_NULL if there is not enough memory for the object.
-   On 16-bit systems, the functions zalloc and zfree must be able to allocate
-   exactly 65536 bytes, but will not be required to allocate more than this
-   if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
-   pointers returned by zalloc for objects of exactly 65536 bytes *must*
-   have their offset normalized to zero. The default allocation function
-   provided by this library ensures this (see zutil.c). To reduce memory
-   requirements and avoid any allocation of 64K objects, at the expense of
-   compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
-
-   The fields total_in and total_out can be used for statistics or
-   progress reports. After compression, total_in holds the total size of
-   the uncompressed data and may be saved for use in the decompressor
-   (particularly if the decompressor wants to decompress everything in
-   a single step).
-*/
-
-			/* constants */
-
-#define Z_NO_FLUSH      0
-#define Z_PARTIAL_FLUSH 1
-#define Z_FULL_FLUSH    2
-#define Z_SYNC_FLUSH    3 /* experimental: partial_flush + byte align */
-#define Z_FINISH        4
-#define Z_PACKET_FLUSH	5
-/* See deflate() below for the usage of these constants */
-
-#define Z_OK            0
-#define Z_STREAM_END    1
-#define Z_ERRNO        (-1)
-#define Z_STREAM_ERROR (-2)
-#define Z_DATA_ERROR   (-3)
-#define Z_MEM_ERROR    (-4)
-#define Z_BUF_ERROR    (-5)
-/* error codes for the compression/decompression functions */
-
-#define Z_BEST_SPEED             1
-#define Z_BEST_COMPRESSION       9
-#define Z_DEFAULT_COMPRESSION  (-1)
-/* compression levels */
-
-#define Z_FILTERED            1
-#define Z_HUFFMAN_ONLY        2
-#define Z_DEFAULT_STRATEGY    0
-
-#define Z_BINARY   0
-#define Z_ASCII    1
-#define Z_UNKNOWN  2
-/* Used to set the data_type field */
-
-#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
-
-extern char *zlib_version;
-/* The application can compare zlib_version and ZLIB_VERSION for consistency.
-   If the first character differs, the library code actually used is
-   not compatible with the zlib.h header file used by the application.
- */
-
-			/* basic functions */
-
-extern int inflateInit OF((z_stream *strm));
-/*
-     Initializes the internal stream state for decompression. The fields
-   zalloc and zfree must be initialized before by the caller.  If zalloc and
-   zfree are set to Z_NULL, inflateInit updates them to use default allocation
-   functions.
-
-     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory.  msg is set to null if there is no error message.
-   inflateInit does not perform any decompression: this will be done by
-   inflate().
-*/
-
-
-extern int inflate OF((z_stream *strm, int flush));
-/*
-  Performs one or both of the following actions:
-
-  - Decompress more input starting at next_in and update next_in and avail_in
-    accordingly. If not all input can be processed (because there is not
-    enough room in the output buffer), next_in is updated and processing
-    will resume at this point for the next call of inflate().
-
-  - Provide more output starting at next_out and update next_out and avail_out
-    accordingly.  inflate() always provides as much output as possible
-    (until there is no more input data or no more space in the output buffer).
-
-  Before the call of inflate(), the application should ensure that at least
-  one of the actions is possible, by providing more input and/or consuming
-  more output, and updating the next_* and avail_* values accordingly.
-  The application can consume the uncompressed output when it wants, for
-  example when the output buffer is full (avail_out == 0), or after each
-  call of inflate().
-
-    If the parameter flush is set to Z_PARTIAL_FLUSH or Z_PACKET_FLUSH,
-  inflate flushes as much output as possible to the output buffer. The
-  flushing behavior of inflate is not specified for values of the flush
-  parameter other than Z_PARTIAL_FLUSH, Z_PACKET_FLUSH or Z_FINISH, but the
-  current implementation actually flushes as much output as possible
-  anyway.  For Z_PACKET_FLUSH, inflate checks that once all the input data
-  has been consumed, it is expecting to see the length field of a stored
-  block; if not, it returns Z_DATA_ERROR.
-
-    inflate() should normally be called until it returns Z_STREAM_END or an
-  error. However if all decompression is to be performed in a single step
-  (a single call of inflate), the parameter flush should be set to
-  Z_FINISH. In this case all pending input is processed and all pending
-  output is flushed; avail_out must be large enough to hold all the
-  uncompressed data. (The size of the uncompressed data may have been saved
-  by the compressor for this purpose.) The next operation on this stream must
-  be inflateEnd to deallocate the decompression state. The use of Z_FINISH
-  is never required, but can be used to inform inflate that a faster routine
-  may be used for the single inflate() call.
-
-    inflate() returns Z_OK if some progress has been made (more input
-  processed or more output produced), Z_STREAM_END if the end of the
-  compressed data has been reached and all uncompressed output has been
-  produced, Z_DATA_ERROR if the input data was corrupted, Z_STREAM_ERROR if
-  the stream structure was inconsistent (for example if next_in or next_out
-  was NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no
-  progress is possible or if there was not enough room in the output buffer
-  when Z_FINISH is used. In the Z_DATA_ERROR case, the application may then
-  call inflateSync to look for a good compression block.  */
-
-
-extern int inflateEnd OF((z_stream *strm));
-/*
-     All dynamically allocated data structures for this stream are freed.
-   This function discards any unprocessed input and does not flush any
-   pending output.
-
-     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
-   was inconsistent. In the error case, msg may be set but then points to a
-   static string (which must not be deallocated).
-*/
-
-			/* advanced functions */
-
-extern int inflateInit2 OF((z_stream *strm,
-			    int  windowBits));
-/*
-     This is another version of inflateInit with more compression options. The
-   fields next_out, zalloc and zfree must be initialized before by the caller.
-
-     The windowBits parameter is the base two logarithm of the maximum window
-   size (the size of the history buffer).  It should be in the range 8..15 for
-   this version of the library (the value 16 will be allowed soon). The
-   default value is 15 if inflateInit is used instead. If a compressed stream
-   with a larger window size is given as input, inflate() will return with
-   the error code Z_DATA_ERROR instead of trying to allocate a larger window.
-
-     If next_out is not null, the library will use this buffer for the history
-   buffer; the buffer must either be large enough to hold the entire output
-   data, or have at least 1<<windowBits bytes.  If next_out is null, the
-   library will allocate its own buffer (and leave next_out null). next_in
-   need not be provided here but must be provided by the application for the
-   next call of inflate().
-
-     If the history buffer is provided by the application, next_out must
-   never be changed by the application since the decompressor maintains
-   history information inside this buffer from call to call; the application
-   can only reset next_out to the beginning of the history buffer when
-   avail_out is zero and all output has been consumed.
-
-      inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
-   not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
-   windowBits < 8). msg is set to null if there is no error message.
-   inflateInit2 does not perform any decompression: this will be done by
-   inflate().
-*/
-
-extern int inflateSync OF((z_stream *strm));
-/*
-    Skips invalid compressed data until the special marker (see deflate()
-  above) can be found, or until all available input is skipped. No output
-  is provided.
-
-    inflateSync returns Z_OK if the special marker has been found, Z_BUF_ERROR
-  if no more input was provided, Z_DATA_ERROR if no marker has been found,
-  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
-  case, the application may save the current current value of total_in which
-  indicates where valid compressed data was found. In the error case, the
-  application may repeatedly call inflateSync, providing more input each time,
-  until success or end of the input data.
-*/
-
-extern int inflateReset OF((z_stream *strm));
-/*
-     This function is equivalent to inflateEnd followed by inflateInit,
-   but does not free and reallocate all the internal decompression state.
-   The stream will keep attributes that may have been set by inflateInit2.
-
-      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
-   stream state was inconsistent (such as zalloc or state being NULL).
-*/
-
-extern int inflateIncomp OF((z_stream *strm));
-/*
-     This function adds the data at next_in (avail_in bytes) to the output
-   history without performing any output.  There must be no pending output,
-   and the decompressor must be expecting to see the start of a block.
-   Calling this function is equivalent to decompressing a stored block
-   containing the data at next_in (except that the data is not output).
-*/
-
-			/* checksum functions */
-
-/*
-     This function is not related to compression but is exported
-   anyway because it might be useful in applications using the
-   compression library.
-*/
-
-extern uLong adler32 OF((uLong adler, Bytef *buf, uInt len));
-
-/*
-     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
-   return the updated checksum. If buf is NULL, this function returns
-   the required initial value for the checksum.
-   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
-   much faster. Usage example:
-
-     uLong adler = adler32(0L, Z_NULL, 0);
-
-     while (read_buffer(buffer, length) != EOF) {
-       adler = adler32(adler, buffer, length);
-     }
-     if (adler != original_adler) error();
-*/
-
-#ifndef _Z_UTIL_H
-    struct internal_state {int dummy;}; /* hack for buggy compilers */
-#endif
-
-#endif /* _ZLIB_H */
@@ -24,7 +24,7 @@
 #include <common.h>
 #include <command.h>
 #include <image.h>
-#include <zlib.h>
+#include <u-boot/zlib.h>
 #include <asm/byteorder.h>
  
 DECLARE_GLOBAL_DATA_PTR;
@@ -22,7 +22,7 @@
 #include <common.h>
 #include <command.h>
 #include <image.h>
-#include <zlib.h>
+#include <u-boot/zlib.h>
 #include <asm/byteorder.h>
 #include <asm/arch/addrspace.h>
 #include <asm/io.h>
@@ -17,7 +17,7 @@
 #if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
 #include <watchdog.h>
 #endif
-#include "zlib.h"
+#include "u-boot/zlib.h"
  
 #define local static
 #define ZEXPORT	/* empty */
@@ -26,7 +26,7 @@
 #include <command.h>
 #include <image.h>
 #include <malloc.h>
-#include <zlib.h>
+#include <u-boot/zlib.h>
  
 #define	ZALLOC_ALIGNMENT	16
 #define HEAD_CRC		2
@@ -27,7 +27,7 @@
  
 #define _Z_UTIL_H
  
-#include "zlib.h"
+#include "u-boot/zlib.h"
  
 #ifndef local
 #  define local static
@@ -24,7 +24,7 @@
 #include <common.h>
 #include <command.h>
 #include <image.h>
-#include <zlib.h>
+#include <u-boot/zlib.h>
 #include <asm/byteorder.h>
 #include <asm/zimage.h>
  
@@ -24,7 +24,7 @@
 #include <common.h>
 #include <command.h>
 #include <image.h>
-#include <zlib.h>
+#include <u-boot/zlib.h>
 #include <bzlib.h>
 #include <watchdog.h>
 #include <environment.h>
@@ -27,7 +27,7 @@
 #include <common.h>
 #include <command.h>
 #include <image.h>
-#include <zlib.h>
+#include <u-boot/zlib.h>
 #include <asm/byteorder.h>
  
 DECLARE_GLOBAL_DATA_PTR;
@@ -24,7 +24,7 @@
 #include <common.h>
 #include <command.h>
 #include <image.h>
-#include <zlib.h>
+#include <u-boot/zlib.h>
 #include <asm/byteorder.h>
 #include <asm/addrspace.h>
  
@@ -29,7 +29,7 @@
 #include <command.h>
 #include <image.h>
 #include <malloc.h>
-#include <zlib.h>
+#include <u-boot/zlib.h>
 #include <bzlib.h>
 #include <environment.h>
 #include <asm/byteorder.h>
...	...	@@ -30,7 +30,7 @@
30	30	#include <command.h>
31	31	#include <image.h>
32	32	#include <malloc.h>
33		-#include <zlib.h>
	33	+#include <u-boot/zlib.h>
34	34	#include <bzlib.h>
35	35	#include <environment.h>
36	36	#include <lmb.h>
...	...	@@ -23,7 +23,7 @@
23	23	#include <common.h>
24	24	#include <malloc.h>
25	25	#include <watchdog.h>
26		-#include <zlib.h>
	26	+#include <u-boot/zlib.h>
27	27
28	28	static z_stream stream;
29	29
	1	+/*
	2	+ * This file is derived from zlib.h and zconf.h from the zlib-0.95
	3	+ * distribution by Jean-loup Gailly and Mark Adler, with some additions
	4	+ * by Paul Mackerras to aid in implementing Deflate compression and
	5	+ * decompression for PPP packets.
	6	+ */
	7	+
	8	+/*
	9	+ * ==FILEVERSION 960122==
	10	+ *
	11	+ * This marker is used by the Linux installation script to determine
	12	+ * whether an up-to-date version of this file is already installed.
	13	+ */
	14	+
	15	+/* zlib.h -- interface of the 'zlib' general purpose compression library
	16	+ version 0.95, Aug 16th, 1995.
	17	+
	18	+ Copyright (C) 1995 Jean-loup Gailly and Mark Adler
	19	+
	20	+ This software is provided 'as-is', without any express or implied
	21	+ warranty. In no event will the authors be held liable for any damages
	22	+ arising from the use of this software.
	23	+
	24	+ Permission is granted to anyone to use this software for any purpose,
	25	+ including commercial applications, and to alter it and redistribute it
	26	+ freely, subject to the following restrictions:
	27	+
	28	+ 1. The origin of this software must not be misrepresented; you must not
	29	+ claim that you wrote the original software. If you use this software
	30	+ in a product, an acknowledgment in the product documentation would be
	31	+ appreciated but is not required.
	32	+ 2. Altered source versions must be plainly marked as such, and must not be
	33	+ misrepresented as being the original software.
	34	+ 3. This notice may not be removed or altered from any source distribution.
	35	+
	36	+ Jean-loup Gailly Mark Adler
	37	+ gzip@prep.ai.mit.edu madler@alumni.caltech.edu
	38	+ */
	39	+
	40	+#ifndef _ZLIB_H
	41	+#define _ZLIB_H
	42	+
	43	+/* #include "zconf.h" / / included directly here */
	44	+
	45	+/* zconf.h -- configuration of the zlib compression library
	46	+ * Copyright (C) 1995 Jean-loup Gailly.
	47	+ * For conditions of distribution and use, see copyright notice in zlib.h
	48	+ */
	49	+
	50	+/* From: zconf.h,v 1.12 1995/05/03 17:27:12 jloup Exp */
	51	+
	52	+/*
	53	+ The library does not install any signal handler. It is recommended to
	54	+ add at least a handler for SIGSEGV when decompressing; the library checks
	55	+ the consistency of the input data whenever possible but may go nuts
	56	+ for some forms of corrupted input.
	57	+ */
	58	+
	59	+/*
	60	+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
	61	+ * than 64k bytes at a time (needed on systems with 16-bit int).
	62	+ * Compile with -DUNALIGNED_OK if it is OK to access shorts or ints
	63	+ * at addresses which are not a multiple of their size.
	64	+ * Under DOS, -DFAR=far or -DFAR=__far may be needed.
	65	+ */
	66	+
	67	+#ifndef STDC
	68	+# if defined(MSDOS) \|\| defined(__STDC__) \|\| defined(__cplusplus)
	69	+# define STDC
	70	+# endif
	71	+#endif
	72	+
	73	+#ifdef __MWERKS__ /* Metrowerks CodeWarrior declares fileno() in unix.h */
	74	+# include <unix.h>
	75	+#endif
	76	+
	77	+/* Maximum value for memLevel in deflateInit2 */
	78	+#ifndef MAX_MEM_LEVEL
	79	+# ifdef MAXSEG_64K
	80	+# define MAX_MEM_LEVEL 8
	81	+# else
	82	+# define MAX_MEM_LEVEL 9
	83	+# endif
	84	+#endif
	85	+
	86	+#ifndef FAR
	87	+# define FAR
	88	+#endif
	89	+
	90	+/* Maximum value for windowBits in deflateInit2 and inflateInit2 */
	91	+#ifndef MAX_WBITS
	92	+# define MAX_WBITS 15 /* 32K LZ77 window */
	93	+#endif
	94	+
	95	+/* The memory requirements for deflate are (in bytes):
	96	+ 1 << (windowBits+2) + 1 << (memLevel+9)
	97	+ that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
	98	+ plus a few kilobytes for small objects. For example, if you want to reduce
	99	+ the default memory requirements from 256K to 128K, compile with
	100	+ make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
	101	+ Of course this will generally degrade compression (there's no free lunch).
	102	+
	103	+ The memory requirements for inflate are (in bytes) 1 << windowBits
	104	+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
	105	+ for small objects.
	106	+*/
	107	+
	108	+ /* Type declarations */
	109	+
	110	+#ifndef OF /* function prototypes */
	111	+# ifdef STDC
	112	+# define OF(args) args
	113	+# else
	114	+# define OF(args) ()
	115	+# endif
	116	+#endif
	117	+
	118	+typedef unsigned char Byte; /* 8 bits */
	119	+typedef unsigned int uInt; /* 16 bits or more */
	120	+typedef unsigned long uLong; /* 32 bits or more */
	121	+
	122	+typedef Byte FAR Bytef;
	123	+typedef char FAR charf;
	124	+typedef int FAR intf;
	125	+typedef uInt FAR uIntf;
	126	+typedef uLong FAR uLongf;
	127	+
	128	+#ifdef STDC
	129	+ typedef void FAR *voidpf;
	130	+ typedef void *voidp;
	131	+#else
	132	+ typedef Byte FAR *voidpf;
	133	+ typedef Byte *voidp;
	134	+#endif
	135	+
	136	+/* end of original zconf.h */
	137	+
	138	+#define ZLIB_VERSION "0.95P"
	139	+
	140	+/*
	141	+ The 'zlib' compression library provides in-memory compression and
	142	+ decompression functions, including integrity checks of the uncompressed
	143	+ data. This version of the library supports only one compression method
	144	+ (deflation) but other algorithms may be added later and will have the same
	145	+ stream interface.
	146	+
	147	+ For compression the application must provide the output buffer and
	148	+ may optionally provide the input buffer for optimization. For decompression,
	149	+ the application must provide the input buffer and may optionally provide
	150	+ the output buffer for optimization.
	151	+
	152	+ Compression can be done in a single step if the buffers are large
	153	+ enough (for example if an input file is mmap'ed), or can be done by
	154	+ repeated calls of the compression function. In the latter case, the
	155	+ application must provide more input and/or consume the output
	156	+ (providing more output space) before each call.
	157	+*/
	158	+
	159	+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
	160	+typedef void (*free_func) OF((voidpf opaque, voidpf address, uInt nbytes));
	161	+
	162	+typedef void (cb_func) OF((Bytef buf, uInt len));
	163	+
	164	+struct internal_state;
	165	+
	166	+typedef struct z_stream_s {
	167	+ Bytef next_in; / next input byte */
	168	+ uInt avail_in; /* number of bytes available at next_in */
	169	+ uLong total_in; /* total nb of input bytes read so far */
	170	+
	171	+ Bytef next_out; / next output byte should be put there */
	172	+ uInt avail_out; /* remaining free space at next_out */
	173	+ uLong total_out; /* total nb of bytes output so far */
	174	+
	175	+ char msg; / last error message, NULL if no error */
	176	+ struct internal_state FAR state; / not visible by applications */
	177	+
	178	+ alloc_func zalloc; /* used to allocate the internal state */
	179	+ free_func zfree; /* used to free the internal state */
	180	+ voidp opaque; /* private data object passed to zalloc and zfree */
	181	+
	182	+ Byte data_type; /* best guess about the data type: ascii or binary */
	183	+
	184	+ cb_func outcb; /* called regularly just before blocks of output */
	185	+
	186	+} z_stream;
	187	+
	188	+/*
	189	+ The application must update next_in and avail_in when avail_in has
	190	+ dropped to zero. It must update next_out and avail_out when avail_out
	191	+ has dropped to zero. The application must initialize zalloc, zfree and
	192	+ opaque before calling the init function. All other fields are set by the
	193	+ compression library and must not be updated by the application.
	194	+
	195	+ The opaque value provided by the application will be passed as the first
	196	+ parameter for calls of zalloc and zfree. This can be useful for custom
	197	+ memory management. The compression library attaches no meaning to the
	198	+ opaque value.
	199	+
	200	+ zalloc must return Z_NULL if there is not enough memory for the object.
	201	+ On 16-bit systems, the functions zalloc and zfree must be able to allocate
	202	+ exactly 65536 bytes, but will not be required to allocate more than this
	203	+ if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
	204	+ pointers returned by zalloc for objects of exactly 65536 bytes must
	205	+ have their offset normalized to zero. The default allocation function
	206	+ provided by this library ensures this (see zutil.c). To reduce memory
	207	+ requirements and avoid any allocation of 64K objects, at the expense of
	208	+ compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
	209	+
	210	+ The fields total_in and total_out can be used for statistics or
	211	+ progress reports. After compression, total_in holds the total size of
	212	+ the uncompressed data and may be saved for use in the decompressor
	213	+ (particularly if the decompressor wants to decompress everything in
	214	+ a single step).
	215	+*/
	216	+
	217	+ /* constants */
	218	+
	219	+#define Z_NO_FLUSH 0
	220	+#define Z_PARTIAL_FLUSH 1
	221	+#define Z_FULL_FLUSH 2
	222	+#define Z_SYNC_FLUSH 3 /* experimental: partial_flush + byte align */
	223	+#define Z_FINISH 4
	224	+#define Z_PACKET_FLUSH 5
	225	+/* See deflate() below for the usage of these constants */
	226	+
	227	+#define Z_OK 0
	228	+#define Z_STREAM_END 1
	229	+#define Z_ERRNO (-1)
	230	+#define Z_STREAM_ERROR (-2)
	231	+#define Z_DATA_ERROR (-3)
	232	+#define Z_MEM_ERROR (-4)
	233	+#define Z_BUF_ERROR (-5)
	234	+/* error codes for the compression/decompression functions */
	235	+
	236	+#define Z_BEST_SPEED 1
	237	+#define Z_BEST_COMPRESSION 9
	238	+#define Z_DEFAULT_COMPRESSION (-1)
	239	+/* compression levels */
	240	+
	241	+#define Z_FILTERED 1
	242	+#define Z_HUFFMAN_ONLY 2
	243	+#define Z_DEFAULT_STRATEGY 0
	244	+
	245	+#define Z_BINARY 0
	246	+#define Z_ASCII 1
	247	+#define Z_UNKNOWN 2
	248	+/* Used to set the data_type field */
	249	+
	250	+#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
	251	+
	252	+extern char *zlib_version;
	253	+/* The application can compare zlib_version and ZLIB_VERSION for consistency.
	254	+ If the first character differs, the library code actually used is
	255	+ not compatible with the zlib.h header file used by the application.
	256	+ */
	257	+
	258	+ /* basic functions */
	259	+
	260	+extern int inflateInit OF((z_stream *strm));
	261	+/*
	262	+ Initializes the internal stream state for decompression. The fields
	263	+ zalloc and zfree must be initialized before by the caller. If zalloc and
	264	+ zfree are set to Z_NULL, inflateInit updates them to use default allocation
	265	+ functions.
	266	+
	267	+ inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
	268	+ enough memory. msg is set to null if there is no error message.
	269	+ inflateInit does not perform any decompression: this will be done by
	270	+ inflate().
	271	+*/
	272	+
	273	+
	274	+extern int inflate OF((z_stream *strm, int flush));
	275	+/*
	276	+ Performs one or both of the following actions:
	277	+
	278	+ - Decompress more input starting at next_in and update next_in and avail_in
	279	+ accordingly. If not all input can be processed (because there is not
	280	+ enough room in the output buffer), next_in is updated and processing
	281	+ will resume at this point for the next call of inflate().
	282	+
	283	+ - Provide more output starting at next_out and update next_out and avail_out
	284	+ accordingly. inflate() always provides as much output as possible
	285	+ (until there is no more input data or no more space in the output buffer).
	286	+
	287	+ Before the call of inflate(), the application should ensure that at least
	288	+ one of the actions is possible, by providing more input and/or consuming
	289	+ more output, and updating the next_* and avail_* values accordingly.
	290	+ The application can consume the uncompressed output when it wants, for
	291	+ example when the output buffer is full (avail_out == 0), or after each
	292	+ call of inflate().
	293	+
	294	+ If the parameter flush is set to Z_PARTIAL_FLUSH or Z_PACKET_FLUSH,
	295	+ inflate flushes as much output as possible to the output buffer. The
	296	+ flushing behavior of inflate is not specified for values of the flush
	297	+ parameter other than Z_PARTIAL_FLUSH, Z_PACKET_FLUSH or Z_FINISH, but the
	298	+ current implementation actually flushes as much output as possible
	299	+ anyway. For Z_PACKET_FLUSH, inflate checks that once all the input data
	300	+ has been consumed, it is expecting to see the length field of a stored
	301	+ block; if not, it returns Z_DATA_ERROR.
	302	+
	303	+ inflate() should normally be called until it returns Z_STREAM_END or an
	304	+ error. However if all decompression is to be performed in a single step
	305	+ (a single call of inflate), the parameter flush should be set to
	306	+ Z_FINISH. In this case all pending input is processed and all pending
	307	+ output is flushed; avail_out must be large enough to hold all the
	308	+ uncompressed data. (The size of the uncompressed data may have been saved
	309	+ by the compressor for this purpose.) The next operation on this stream must
	310	+ be inflateEnd to deallocate the decompression state. The use of Z_FINISH
	311	+ is never required, but can be used to inform inflate that a faster routine
	312	+ may be used for the single inflate() call.
	313	+
	314	+ inflate() returns Z_OK if some progress has been made (more input
	315	+ processed or more output produced), Z_STREAM_END if the end of the
	316	+ compressed data has been reached and all uncompressed output has been
	317	+ produced, Z_DATA_ERROR if the input data was corrupted, Z_STREAM_ERROR if
	318	+ the stream structure was inconsistent (for example if next_in or next_out
	319	+ was NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no
	320	+ progress is possible or if there was not enough room in the output buffer
	321	+ when Z_FINISH is used. In the Z_DATA_ERROR case, the application may then
	322	+ call inflateSync to look for a good compression block. */
	323	+
	324	+
	325	+extern int inflateEnd OF((z_stream *strm));
	326	+/*
	327	+ All dynamically allocated data structures for this stream are freed.
	328	+ This function discards any unprocessed input and does not flush any
	329	+ pending output.
	330	+
	331	+ inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
	332	+ was inconsistent. In the error case, msg may be set but then points to a
	333	+ static string (which must not be deallocated).
	334	+*/
	335	+
	336	+ /* advanced functions */
	337	+
	338	+extern int inflateInit2 OF((z_stream *strm,
	339	+ int windowBits));
	340	+/*
	341	+ This is another version of inflateInit with more compression options. The
	342	+ fields next_out, zalloc and zfree must be initialized before by the caller.
	343	+
	344	+ The windowBits parameter is the base two logarithm of the maximum window
	345	+ size (the size of the history buffer). It should be in the range 8..15 for
	346	+ this version of the library (the value 16 will be allowed soon). The
	347	+ default value is 15 if inflateInit is used instead. If a compressed stream
	348	+ with a larger window size is given as input, inflate() will return with
	349	+ the error code Z_DATA_ERROR instead of trying to allocate a larger window.
	350	+
	351	+ If next_out is not null, the library will use this buffer for the history
	352	+ buffer; the buffer must either be large enough to hold the entire output
	353	+ data, or have at least 1<<windowBits bytes. If next_out is null, the
	354	+ library will allocate its own buffer (and leave next_out null). next_in
	355	+ need not be provided here but must be provided by the application for the
	356	+ next call of inflate().
	357	+
	358	+ If the history buffer is provided by the application, next_out must
	359	+ never be changed by the application since the decompressor maintains
	360	+ history information inside this buffer from call to call; the application
	361	+ can only reset next_out to the beginning of the history buffer when
	362	+ avail_out is zero and all output has been consumed.
	363	+
	364	+ inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
	365	+ not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
	366	+ windowBits < 8). msg is set to null if there is no error message.
	367	+ inflateInit2 does not perform any decompression: this will be done by
	368	+ inflate().
	369	+*/
	370	+
	371	+extern int inflateSync OF((z_stream *strm));
	372	+/*
	373	+ Skips invalid compressed data until the special marker (see deflate()
	374	+ above) can be found, or until all available input is skipped. No output
	375	+ is provided.
	376	+
	377	+ inflateSync returns Z_OK if the special marker has been found, Z_BUF_ERROR
	378	+ if no more input was provided, Z_DATA_ERROR if no marker has been found,
	379	+ or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
	380	+ case, the application may save the current current value of total_in which
	381	+ indicates where valid compressed data was found. In the error case, the
	382	+ application may repeatedly call inflateSync, providing more input each time,
	383	+ until success or end of the input data.
	384	+*/
	385	+
	386	+extern int inflateReset OF((z_stream *strm));
	387	+/*
	388	+ This function is equivalent to inflateEnd followed by inflateInit,
	389	+ but does not free and reallocate all the internal decompression state.
	390	+ The stream will keep attributes that may have been set by inflateInit2.
	391	+
	392	+ inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
	393	+ stream state was inconsistent (such as zalloc or state being NULL).
	394	+*/
	395	+
	396	+extern int inflateIncomp OF((z_stream *strm));
	397	+/*
	398	+ This function adds the data at next_in (avail_in bytes) to the output
	399	+ history without performing any output. There must be no pending output,
	400	+ and the decompressor must be expecting to see the start of a block.
	401	+ Calling this function is equivalent to decompressing a stored block
	402	+ containing the data at next_in (except that the data is not output).
	403	+*/
	404	+
	405	+ /* checksum functions */
	406	+
	407	+/*
	408	+ This function is not related to compression but is exported
	409	+ anyway because it might be useful in applications using the
	410	+ compression library.
	411	+*/
	412	+
	413	+extern uLong adler32 OF((uLong adler, Bytef *buf, uInt len));
	414	+
	415	+/*
	416	+ Update a running Adler-32 checksum with the bytes buf[0..len-1] and
	417	+ return the updated checksum. If buf is NULL, this function returns
	418	+ the required initial value for the checksum.
	419	+ An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
	420	+ much faster. Usage example:
	421	+
	422	+ uLong adler = adler32(0L, Z_NULL, 0);
	423	+
	424	+ while (read_buffer(buffer, length) != EOF) {
	425	+ adler = adler32(adler, buffer, length);
	426	+ }
	427	+ if (adler != original_adler) error();
	428	+*/
	429	+
	430	+#ifndef _Z_UTIL_H
	431	+ struct internal_state {int dummy;}; /* hack for buggy compilers */
	432	+#endif
	433	+
	434	+#endif /* _ZLIB_H */
1		-/*
2		- * This file is derived from zlib.h and zconf.h from the zlib-0.95
3		- * distribution by Jean-loup Gailly and Mark Adler, with some additions
4		- * by Paul Mackerras to aid in implementing Deflate compression and
5		- * decompression for PPP packets.
6		- */
7		-
8		-/*
9		- * ==FILEVERSION 960122==
10		- *
11		- * This marker is used by the Linux installation script to determine
12		- * whether an up-to-date version of this file is already installed.
13		- */
14		-
15		-/* zlib.h -- interface of the 'zlib' general purpose compression library
16		- version 0.95, Aug 16th, 1995.
17		-
18		- Copyright (C) 1995 Jean-loup Gailly and Mark Adler
19		-
20		- This software is provided 'as-is', without any express or implied
21		- warranty. In no event will the authors be held liable for any damages
22		- arising from the use of this software.
23		-
24		- Permission is granted to anyone to use this software for any purpose,
25		- including commercial applications, and to alter it and redistribute it
26		- freely, subject to the following restrictions:
27		-
28		- 1. The origin of this software must not be misrepresented; you must not
29		- claim that you wrote the original software. If you use this software
30		- in a product, an acknowledgment in the product documentation would be
31		- appreciated but is not required.
32		- 2. Altered source versions must be plainly marked as such, and must not be
33		- misrepresented as being the original software.
34		- 3. This notice may not be removed or altered from any source distribution.
35		-
36		- Jean-loup Gailly Mark Adler
37		- gzip@prep.ai.mit.edu madler@alumni.caltech.edu
38		- */
39		-
40		-#ifndef _ZLIB_H
41		-#define _ZLIB_H
42		-
43		-/* #include "zconf.h" / / included directly here */
44		-
45		-/* zconf.h -- configuration of the zlib compression library
46		- * Copyright (C) 1995 Jean-loup Gailly.
47		- * For conditions of distribution and use, see copyright notice in zlib.h
48		- */
49		-
50		-/* From: zconf.h,v 1.12 1995/05/03 17:27:12 jloup Exp */
51		-
52		-/*
53		- The library does not install any signal handler. It is recommended to
54		- add at least a handler for SIGSEGV when decompressing; the library checks
55		- the consistency of the input data whenever possible but may go nuts
56		- for some forms of corrupted input.
57		- */
58		-
59		-/*
60		- * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
61		- * than 64k bytes at a time (needed on systems with 16-bit int).
62		- * Compile with -DUNALIGNED_OK if it is OK to access shorts or ints
63		- * at addresses which are not a multiple of their size.
64		- * Under DOS, -DFAR=far or -DFAR=__far may be needed.
65		- */
66		-
67		-#ifndef STDC
68		-# if defined(MSDOS) \|\| defined(__STDC__) \|\| defined(__cplusplus)
69		-# define STDC
70		-# endif
71		-#endif
72		-
73		-#ifdef __MWERKS__ /* Metrowerks CodeWarrior declares fileno() in unix.h */
74		-# include <unix.h>
75		-#endif
76		-
77		-/* Maximum value for memLevel in deflateInit2 */
78		-#ifndef MAX_MEM_LEVEL
79		-# ifdef MAXSEG_64K
80		-# define MAX_MEM_LEVEL 8
81		-# else
82		-# define MAX_MEM_LEVEL 9
83		-# endif
84		-#endif
85		-
86		-#ifndef FAR
87		-# define FAR
88		-#endif
89		-
90		-/* Maximum value for windowBits in deflateInit2 and inflateInit2 */
91		-#ifndef MAX_WBITS
92		-# define MAX_WBITS 15 /* 32K LZ77 window */
93		-#endif
94		-
95		-/* The memory requirements for deflate are (in bytes):
96		- 1 << (windowBits+2) + 1 << (memLevel+9)
97		- that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
98		- plus a few kilobytes for small objects. For example, if you want to reduce
99		- the default memory requirements from 256K to 128K, compile with
100		- make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
101		- Of course this will generally degrade compression (there's no free lunch).
102		-
103		- The memory requirements for inflate are (in bytes) 1 << windowBits
104		- that is, 32K for windowBits=15 (default value) plus a few kilobytes
105		- for small objects.
106		-*/
107		-
108		- /* Type declarations */
109		-
110		-#ifndef OF /* function prototypes */
111		-# ifdef STDC
112		-# define OF(args) args
113		-# else
114		-# define OF(args) ()
115		-# endif
116		-#endif
117		-
118		-typedef unsigned char Byte; /* 8 bits */
119		-typedef unsigned int uInt; /* 16 bits or more */
120		-typedef unsigned long uLong; /* 32 bits or more */
121		-
122		-typedef Byte FAR Bytef;
123		-typedef char FAR charf;
124		-typedef int FAR intf;
125		-typedef uInt FAR uIntf;
126		-typedef uLong FAR uLongf;
127		-
128		-#ifdef STDC
129		- typedef void FAR *voidpf;
130		- typedef void *voidp;
131		-#else
132		- typedef Byte FAR *voidpf;
133		- typedef Byte *voidp;
134		-#endif
135		-
136		-/* end of original zconf.h */
137		-
138		-#define ZLIB_VERSION "0.95P"
139		-
140		-/*
141		- The 'zlib' compression library provides in-memory compression and
142		- decompression functions, including integrity checks of the uncompressed
143		- data. This version of the library supports only one compression method
144		- (deflation) but other algorithms may be added later and will have the same
145		- stream interface.
146		-
147		- For compression the application must provide the output buffer and
148		- may optionally provide the input buffer for optimization. For decompression,
149		- the application must provide the input buffer and may optionally provide
150		- the output buffer for optimization.
151		-
152		- Compression can be done in a single step if the buffers are large
153		- enough (for example if an input file is mmap'ed), or can be done by
154		- repeated calls of the compression function. In the latter case, the
155		- application must provide more input and/or consume the output
156		- (providing more output space) before each call.
157		-*/
158		-
159		-typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
160		-typedef void (*free_func) OF((voidpf opaque, voidpf address, uInt nbytes));
161		-
162		-typedef void (cb_func) OF((Bytef buf, uInt len));
163		-
164		-struct internal_state;
165		-
166		-typedef struct z_stream_s {
167		- Bytef next_in; / next input byte */
168		- uInt avail_in; /* number of bytes available at next_in */
169		- uLong total_in; /* total nb of input bytes read so far */
170		-
171		- Bytef next_out; / next output byte should be put there */
172		- uInt avail_out; /* remaining free space at next_out */
173		- uLong total_out; /* total nb of bytes output so far */
174		-
175		- char msg; / last error message, NULL if no error */
176		- struct internal_state FAR state; / not visible by applications */
177		-
178		- alloc_func zalloc; /* used to allocate the internal state */
179		- free_func zfree; /* used to free the internal state */
180		- voidp opaque; /* private data object passed to zalloc and zfree */
181		-
182		- Byte data_type; /* best guess about the data type: ascii or binary */
183		-
184		- cb_func outcb; /* called regularly just before blocks of output */
185		-
186		-} z_stream;
187		-
188		-/*
189		- The application must update next_in and avail_in when avail_in has
190		- dropped to zero. It must update next_out and avail_out when avail_out
191		- has dropped to zero. The application must initialize zalloc, zfree and
192		- opaque before calling the init function. All other fields are set by the
193		- compression library and must not be updated by the application.
194		-
195		- The opaque value provided by the application will be passed as the first
196		- parameter for calls of zalloc and zfree. This can be useful for custom
197		- memory management. The compression library attaches no meaning to the
198		- opaque value.
199		-
200		- zalloc must return Z_NULL if there is not enough memory for the object.
201		- On 16-bit systems, the functions zalloc and zfree must be able to allocate
202		- exactly 65536 bytes, but will not be required to allocate more than this
203		- if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
204		- pointers returned by zalloc for objects of exactly 65536 bytes must
205		- have their offset normalized to zero. The default allocation function
206		- provided by this library ensures this (see zutil.c). To reduce memory
207		- requirements and avoid any allocation of 64K objects, at the expense of
208		- compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
209		-
210		- The fields total_in and total_out can be used for statistics or
211		- progress reports. After compression, total_in holds the total size of
212		- the uncompressed data and may be saved for use in the decompressor
213		- (particularly if the decompressor wants to decompress everything in
214		- a single step).
215		-*/
216		-
217		- /* constants */
218		-
219		-#define Z_NO_FLUSH 0
220		-#define Z_PARTIAL_FLUSH 1
221		-#define Z_FULL_FLUSH 2
222		-#define Z_SYNC_FLUSH 3 /* experimental: partial_flush + byte align */
223		-#define Z_FINISH 4
224		-#define Z_PACKET_FLUSH 5
225		-/* See deflate() below for the usage of these constants */
226		-
227		-#define Z_OK 0
228		-#define Z_STREAM_END 1
229		-#define Z_ERRNO (-1)
230		-#define Z_STREAM_ERROR (-2)
231		-#define Z_DATA_ERROR (-3)
232		-#define Z_MEM_ERROR (-4)
233		-#define Z_BUF_ERROR (-5)
234		-/* error codes for the compression/decompression functions */
235		-
236		-#define Z_BEST_SPEED 1
237		-#define Z_BEST_COMPRESSION 9
238		-#define Z_DEFAULT_COMPRESSION (-1)
239		-/* compression levels */
240		-
241		-#define Z_FILTERED 1
242		-#define Z_HUFFMAN_ONLY 2
243		-#define Z_DEFAULT_STRATEGY 0
244		-
245		-#define Z_BINARY 0
246		-#define Z_ASCII 1
247		-#define Z_UNKNOWN 2
248		-/* Used to set the data_type field */
249		-
250		-#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */
251		-
252		-extern char *zlib_version;
253		-/* The application can compare zlib_version and ZLIB_VERSION for consistency.
254		- If the first character differs, the library code actually used is
255		- not compatible with the zlib.h header file used by the application.
256		- */
257		-
258		- /* basic functions */
259		-
260		-extern int inflateInit OF((z_stream *strm));
261		-/*
262		- Initializes the internal stream state for decompression. The fields
263		- zalloc and zfree must be initialized before by the caller. If zalloc and
264		- zfree are set to Z_NULL, inflateInit updates them to use default allocation
265		- functions.
266		-
267		- inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
268		- enough memory. msg is set to null if there is no error message.
269		- inflateInit does not perform any decompression: this will be done by
270		- inflate().
271		-*/
272		-
273		-
274		-extern int inflate OF((z_stream *strm, int flush));
275		-/*
276		- Performs one or both of the following actions:
277		-
278		- - Decompress more input starting at next_in and update next_in and avail_in
279		- accordingly. If not all input can be processed (because there is not
280		- enough room in the output buffer), next_in is updated and processing
281		- will resume at this point for the next call of inflate().
282		-
283		- - Provide more output starting at next_out and update next_out and avail_out
284		- accordingly. inflate() always provides as much output as possible
285		- (until there is no more input data or no more space in the output buffer).
286		-
287		- Before the call of inflate(), the application should ensure that at least
288		- one of the actions is possible, by providing more input and/or consuming
289		- more output, and updating the next_* and avail_* values accordingly.
290		- The application can consume the uncompressed output when it wants, for
291		- example when the output buffer is full (avail_out == 0), or after each
292		- call of inflate().
293		-
294		- If the parameter flush is set to Z_PARTIAL_FLUSH or Z_PACKET_FLUSH,
295		- inflate flushes as much output as possible to the output buffer. The
296		- flushing behavior of inflate is not specified for values of the flush
297		- parameter other than Z_PARTIAL_FLUSH, Z_PACKET_FLUSH or Z_FINISH, but the
298		- current implementation actually flushes as much output as possible
299		- anyway. For Z_PACKET_FLUSH, inflate checks that once all the input data
300		- has been consumed, it is expecting to see the length field of a stored
301		- block; if not, it returns Z_DATA_ERROR.
302		-
303		- inflate() should normally be called until it returns Z_STREAM_END or an
304		- error. However if all decompression is to be performed in a single step
305		- (a single call of inflate), the parameter flush should be set to
306		- Z_FINISH. In this case all pending input is processed and all pending
307		- output is flushed; avail_out must be large enough to hold all the
308		- uncompressed data. (The size of the uncompressed data may have been saved
309		- by the compressor for this purpose.) The next operation on this stream must
310		- be inflateEnd to deallocate the decompression state. The use of Z_FINISH
311		- is never required, but can be used to inform inflate that a faster routine
312		- may be used for the single inflate() call.
313		-
314		- inflate() returns Z_OK if some progress has been made (more input
315		- processed or more output produced), Z_STREAM_END if the end of the
316		- compressed data has been reached and all uncompressed output has been
317		- produced, Z_DATA_ERROR if the input data was corrupted, Z_STREAM_ERROR if
318		- the stream structure was inconsistent (for example if next_in or next_out
319		- was NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no
320		- progress is possible or if there was not enough room in the output buffer
321		- when Z_FINISH is used. In the Z_DATA_ERROR case, the application may then
322		- call inflateSync to look for a good compression block. */
323		-
324		-
325		-extern int inflateEnd OF((z_stream *strm));
326		-/*
327		- All dynamically allocated data structures for this stream are freed.
328		- This function discards any unprocessed input and does not flush any
329		- pending output.
330		-
331		- inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
332		- was inconsistent. In the error case, msg may be set but then points to a
333		- static string (which must not be deallocated).
334		-*/
335		-
336		- /* advanced functions */
337		-
338		-extern int inflateInit2 OF((z_stream *strm,
339		- int windowBits));
340		-/*
341		- This is another version of inflateInit with more compression options. The
342		- fields next_out, zalloc and zfree must be initialized before by the caller.
343		-
344		- The windowBits parameter is the base two logarithm of the maximum window
345		- size (the size of the history buffer). It should be in the range 8..15 for
346		- this version of the library (the value 16 will be allowed soon). The
347		- default value is 15 if inflateInit is used instead. If a compressed stream
348		- with a larger window size is given as input, inflate() will return with
349		- the error code Z_DATA_ERROR instead of trying to allocate a larger window.
350		-
351		- If next_out is not null, the library will use this buffer for the history
352		- buffer; the buffer must either be large enough to hold the entire output
353		- data, or have at least 1<<windowBits bytes. If next_out is null, the
354		- library will allocate its own buffer (and leave next_out null). next_in
355		- need not be provided here but must be provided by the application for the
356		- next call of inflate().
357		-
358		- If the history buffer is provided by the application, next_out must
359		- never be changed by the application since the decompressor maintains
360		- history information inside this buffer from call to call; the application
361		- can only reset next_out to the beginning of the history buffer when
362		- avail_out is zero and all output has been consumed.
363		-
364		- inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was
365		- not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as
366		- windowBits < 8). msg is set to null if there is no error message.
367		- inflateInit2 does not perform any decompression: this will be done by
368		- inflate().
369		-*/
370		-
371		-extern int inflateSync OF((z_stream *strm));
372		-/*
373		- Skips invalid compressed data until the special marker (see deflate()
374		- above) can be found, or until all available input is skipped. No output
375		- is provided.
376		-
377		- inflateSync returns Z_OK if the special marker has been found, Z_BUF_ERROR
378		- if no more input was provided, Z_DATA_ERROR if no marker has been found,
379		- or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
380		- case, the application may save the current current value of total_in which
381		- indicates where valid compressed data was found. In the error case, the
382		- application may repeatedly call inflateSync, providing more input each time,
383		- until success or end of the input data.
384		-*/
385		-
386		-extern int inflateReset OF((z_stream *strm));
387		-/*
388		- This function is equivalent to inflateEnd followed by inflateInit,
389		- but does not free and reallocate all the internal decompression state.
390		- The stream will keep attributes that may have been set by inflateInit2.
391		-
392		- inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
393		- stream state was inconsistent (such as zalloc or state being NULL).
394		-*/
395		-
396		-extern int inflateIncomp OF((z_stream *strm));
397		-/*
398		- This function adds the data at next_in (avail_in bytes) to the output
399		- history without performing any output. There must be no pending output,
400		- and the decompressor must be expecting to see the start of a block.
401		- Calling this function is equivalent to decompressing a stored block
402		- containing the data at next_in (except that the data is not output).
403		-*/
404		-
405		- /* checksum functions */
406		-
407		-/*
408		- This function is not related to compression but is exported
409		- anyway because it might be useful in applications using the
410		- compression library.
411		-*/
412		-
413		-extern uLong adler32 OF((uLong adler, Bytef *buf, uInt len));
414		-
415		-/*
416		- Update a running Adler-32 checksum with the bytes buf[0..len-1] and
417		- return the updated checksum. If buf is NULL, this function returns
418		- the required initial value for the checksum.
419		- An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
420		- much faster. Usage example:
421		-
422		- uLong adler = adler32(0L, Z_NULL, 0);
423		-
424		- while (read_buffer(buffer, length) != EOF) {
425		- adler = adler32(adler, buffer, length);
426		- }
427		- if (adler != original_adler) error();
428		-*/
429		-
430		-#ifndef _Z_UTIL_H
431		- struct internal_state {int dummy;}; /* hack for buggy compilers */
432		-#endif
433		-
434		-#endif /* _ZLIB_H */
...	...	@@ -24,7 +24,7 @@
24	24	#include <common.h>
25	25	#include <command.h>
26	26	#include <image.h>
27		-#include <zlib.h>
	27	+#include <u-boot/zlib.h>
28	28	#include <asm/byteorder.h>
29	29
30	30	DECLARE_GLOBAL_DATA_PTR;
...	...	@@ -22,7 +22,7 @@
22	22	#include <common.h>
23	23	#include <command.h>
24	24	#include <image.h>
25		-#include <zlib.h>
	25	+#include <u-boot/zlib.h>
26	26	#include <asm/byteorder.h>
27	27	#include <asm/arch/addrspace.h>
28	28	#include <asm/io.h>
...	...	@@ -17,7 +17,7 @@
17	17	#if defined(CONFIG_HW_WATCHDOG) \|\| defined(CONFIG_WATCHDOG)
18	18	#include <watchdog.h>
19	19	#endif
20		-#include "zlib.h"
	20	+#include "u-boot/zlib.h"
21	21
22	22	#define local static
23	23	#define ZEXPORT /* empty */
...	...	@@ -26,7 +26,7 @@
26	26	#include <command.h>
27	27	#include <image.h>
28	28	#include <malloc.h>
29		-#include <zlib.h>
	29	+#include <u-boot/zlib.h>
30	30
31	31	#define ZALLOC_ALIGNMENT 16
32	32	#define HEAD_CRC 2
...	...	@@ -27,7 +27,7 @@
27	27
28	28	#define _Z_UTIL_H
29	29
30		-#include "zlib.h"
	30	+#include "u-boot/zlib.h"
31	31
32	32	#ifndef local
33	33	# define local static
...	...	@@ -29,7 +29,7 @@
29	29	#include <command.h>
30	30	#include <image.h>
31	31	#include <malloc.h>
32		-#include <zlib.h>
	32	+#include <u-boot/zlib.h>
33	33	#include <bzlib.h>
34	34	#include <environment.h>
35	35	#include <asm/byteorder.h>