]> git.sur5r.net Git - u-boot/commitdiff
Coding Style cleanup; update CHANGELOG.
authorWolfgang Denk <wd@denx.de>
Thu, 23 Jul 2009 20:23:23 +0000 (22:23 +0200)
committerWolfgang Denk <wd@denx.de>
Thu, 23 Jul 2009 20:23:23 +0000 (22:23 +0200)
Signed-off-by: Wolfgang Denk <wd@denx.de>
12 files changed:
CHANGELOG
MAINTAINERS
board/phytec/pcm030/pcm030.c
common/cmd_net.c
doc/README.dns
doc/README.phytec.pcm030
drivers/net/fec_mxc.c
drivers/usb/host/ehci-kirkwood.c
include/configs/cm-bf561.h
include/u-boot/zlib.h
lib_generic/zlib.c
net/dns.c

index 68b7be6ea626ece2894087728e5c7f98049be782..b9676604e3d5b56fb101659d898c5e465cf8fa0c 100644 (file)
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,3 +1,60 @@
+commit 2632c008e2c2cd61fefb622ed671ea3e6bd2e2a6
+Author: Mike Frysinger <vapier@gentoo.org>
+Date:  Tue Jul 21 22:59:36 2009 -0400
+
+    autoconf.mk: include before config.mk for top level files
+
+    By including autoconf.mk before config.mk, all top level files can use any
+    config options it sets up (like <arch>_config.mk) or the Makefile itself
+    without being forced to use lazy evaluation.
+
+commit c01171eaecc963d2c1f56a0984a0cbcdd8a3ab3c
+Author: Mark Jackson <mpfj-list@mimc.co.uk>
+Date:  Tue Jul 21 11:30:53 2009 +0100
+
+    Remove static declaration from gunzip_bmp()
+
+    This patch removes the static declaration from gunzip_bmp()
+
+    Without it, the gunzip_bmp() function is not visible to
+    common/lcd.c and fails to compile with an error.
+
+    Signed-off-by: Mark Jackson <mpfj@mimc.co.uk>
+
+commit 2d4a43e230a3c8bfd03b9beaa0eb2a95e779c03b
+Author: Peter Tyser <ptyser@gmail.com>
+Date:  Mon Jul 20 21:51:38 2009 -0500
+
+    cmd_tsi148: General cleanup
+
+    - Fix command help message
+    - Disable DEBUG by default
+    - Fix whitespace issues
+    - Fix lines > 80 characters
+
+    Signed-off-by: Peter Tyser <ptyser@gmail.com>
+    Acked-by: Stefan Roese <sr@denx.de>
+
+commit 9aef73888509d10193615ee5cd9cf439ca44e937
+Author: Mike Frysinger <vapier@gentoo.org>
+Date:  Sun Jul 19 15:17:03 2009 -0400
+
+    unify HOST_CFLAGS and HOSTCFLAGS
+
+    The top build system sets up HOSTCFLAGS a bit and exports it, but other
+    places use HOST_CFLAGS instead.  Unify the two as HOSTCFLAGS so that the
+    values stay in sync.
+
+    Signed-off-by: Mike Frysinger <vapier@gentoo.org>
+
+commit 2e9393f500065f940e5e4ac7fe375e4c0b77b936
+Author: Wolfgang Denk <wd@denx.de>
+Date:  Thu Jul 23 21:16:59 2009 +0200
+
+    Update CHANGELOG
+
+    Signed-off-by: Wolfgang Denk <wd@denx.de>
+
 commit e3b39f84e974df70065fa248f0f63993b1708c9d
 Author: AndrĂ© Schwarz <andre.schwarz@matrix-vision.de>
 Date:  Fri Jul 17 14:50:24 2009 +0200
index 3d722658713d0c13a0783ec1930d6b615bec386a..17b2f9c4cf4f040e04a26f4a40ea45780d21e6da 100644 (file)
@@ -552,7 +552,7 @@ Daniel Gorsulowski <daniel.gorsulowski@esd.eu>
        meesc           ARM926EJS (AT91SAM9263 SoC)
 
 Sedji Gaouaou<sedji.gaouaou@atmel.com>
-       at91sam9g10ek           ARM926EJS (AT91SAM9G10 SoC)     
+       at91sam9g10ek           ARM926EJS (AT91SAM9G10 SoC)
        at91sam9m10g45ek        ARM926EJS (AT91SAM9G45 SoC)
 
 Marius Gröger <mag@sysgo.de>
index 6a938743d229c41e5bce9c8412428c7d902c6cbc..416d3070b59d950737fee4454846c9070a20b2e3 100644 (file)
@@ -217,4 +217,3 @@ void ide_set_reset(int idereset)
                setbits_be32(&wu_gpio->dvo, GPIO_PSC2_4);
 }
 #endif /* defined(CONFIG_CMD_IDE) && defined(CONFIG_IDE_RESET) */
-
index ac706ae8d5e73eb7f6f58d173b3c1e83eba6935f..88f4e5bae5791f2a81a4c521ba6d91ef2ab62d56 100644 (file)
@@ -401,4 +401,3 @@ U_BOOT_CMD(
 );
 
 #endif /* CONFIG_CMD_DNS */
-
index deeccd77200dad39b1c092ecef1e557501e44916..8dff454b1df86a713733121515444aad38431003 100644 (file)
@@ -13,16 +13,14 @@ For example, www.example.com translates to 208.77.188.166.
 
 For more information on DNS - http://en.wikipedia.org/wiki/Domain_Name_System
 
-
-
 U-Boot and DNS
 ------------------------------------------
 
 CONFIG_CMD_DNS - controls if the 'dns' command is compiled in. If it is, it
-                 will send name lookups to the dns server (env var 'dnsip')
-                 Turning this option on will about abou 1k to U-Boot's size.
+                will send name lookups to the dns server (env var 'dnsip')
+                Turning this option on will about abou 1k to U-Boot's size.
 
-                 Example:
+                Example:
 
 bfin> print dnsip
 dnsip=192.168.0.1
@@ -30,12 +28,12 @@ dnsip=192.168.0.1
 bfin> dns www.google.com
 66.102.1.104
 
-                 By default, dns does nothing except print the IP number on
-                 the default console - which by itself, would be pretty
-                 useless. Adding a third argument to the dns command will
-                 use that as the environment variable to be set.
+                By default, dns does nothing except print the IP number on
+                the default console - which by itself, would be pretty
+                useless. Adding a third argument to the dns command will
+                use that as the environment variable to be set.
 
-                 Example:
+                Example:
 
 bfin> print googleip
 ## Error: "googleip" not defined
@@ -47,18 +45,18 @@ bfin> ping ${googleip}
 Using Blackfin EMAC device
 host 64.233.161.104 is alive
 
-                 In this way, you can lookup, and set many more meaningful
-                 things.
+                In this way, you can lookup, and set many more meaningful
+                things.
 
 bfin> sntp
 ntpserverip not set
 bfin> dns pool.ntp.org ntpserverip
 72.18.205.156
 bfin> sntp
-Date: 2009-07-18 Time:  4:06:57
+Date: 2009-07-18 Time: 4:06:57
 
-                 For some helpful things that can be related to DNS in U-Boot,
-                 look at the top level README for these config options:
-                    CONFIG_CMD_DHCP
-                    CONFIG_BOOTP_DNS
-                    CONFIG_BOOTP_DNS2
+                For some helpful things that can be related to DNS in U-Boot,
+                look at the top level README for these config options:
+                   CONFIG_CMD_DHCP
+                   CONFIG_BOOTP_DNS
+                   CONFIG_BOOTP_DNS2
index 35a411a7e9088c14e4d7153d7687cc13bc4fd7f5..29b7637e303538aeabfcdf2bc27d96a2827aeb2e 100644 (file)
@@ -18,7 +18,6 @@ pcm030_LOWBOOT_config:        unconfig
        @$(MKCONFIG) -a pcm030 ppc mpc5xxx pcm030 phytec
        @ echo "remember to set pcm030_REV to 0 for rev 1245.0 rev or to 1 for rev 1245.1"
 
-
 Alternative SDRAM settings:
 
 #define SDRAM_MODE     0x018D0000
@@ -41,6 +40,3 @@ Moving the environment to flash can be more reliable
 #define CONFIG_ENV_ADDR                (CONFIG_SYS_FLASH_BASE + 0xfe0000)
 #define CONFIG_ENV_SIZE                0x20000
 #define CONFIG_ENV_SECT_SIZE   0x20000
-
-
-
index faf008cea16ec958ecc3bb32c8947f9a26d628c8..bd83a249ee34a3ca3291dc1cac5aa6290ec6cca5 100644 (file)
@@ -739,4 +739,3 @@ int fecmxc_initialize(bd_t *bd)
 
        return lout;
 }
-
index 64997b85ce5984887112bce4890e69148c5b893a..5570fc699de55daf79089b0f18c98a5dbb037015 100644 (file)
@@ -105,4 +105,3 @@ int ehci_hcd_stop(void)
 {
        return 0;
 }
-
index 1153f111d34aefd89dbd8657a7559db0bc1d262c..59dc8d24588a1c10ee03e9a1d55f96ef613192a7 100644 (file)
@@ -65,7 +65,7 @@
 #define CONFIG_SMC91111_BASE   0x28000300
 /* The next 3 lines are for use with EXT-BF5xx-USB-ETH2 */
 /* #define CONFIG_DRIVER_SMC911X 1 */
-/* #define CONFIG_DRIVER_SMC911X_BASE 0x24080000 // AMS1 */
+/* #define CONFIG_DRIVER_SMC911X_BASE 0x24080000 /! AMS1 */
 /* #define CONFIG_DRIVER_SMC911X_32_BIT 1 */
 #define CONFIG_HOSTNAME                cm-bf561
 /* Uncomment next line to use fixed MAC address */
index fb2708186dcf7b0adb79b0c9eea89edcec50b201..a817e4cd1406697fd3688a240e6a2138ca56ecf9 100644 (file)
@@ -200,7 +200,7 @@ extern "C" {
 #endif
 
 /* The memory requirements for deflate are (in bytes):
-            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+           (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
@@ -212,7 +212,7 @@ extern "C" {
  for small objects.
 */
 
-                        /* Type declarations */
+                       /* Type declarations */
 
 #ifndef OF /* function prototypes */
 #  ifdef STDC
@@ -461,7 +461,7 @@ typedef struct gz_header_s {
 
 typedef gz_header FAR *gz_headerp;
 
-                        /* constants */
+                       /* constants */
 #define Z_NO_FLUSH      0
 #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
 #define Z_SYNC_FLUSH    2
@@ -507,7 +507,7 @@ typedef gz_header FAR *gz_headerp;
 
 #define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
 
-                        /* basic functions */
+                       /* basic functions */
 
 /* The application can compare zlibVersion and ZLIB_VERSION for consistency.
    If the first character differs, the library code actually used is
@@ -627,11 +627,11 @@ ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
    static string (which must not be deallocated).
 */
 
-                        /* Advanced functions */
+                       /* Advanced functions */
 
 ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
 
-                        /* utility functions */
+                       /* utility functions */
 
 /*
      The following utility functions are implemented on top of the
@@ -681,7 +681,7 @@ ZEXTERN  uInt ZEXPORT crc32  OF((uInt crc, const Bytef *buf, uInt len));
 */
 
 ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
-                                      const char *version, int stream_size));
+                                     const char *version, int stream_size));
 #define inflateInit(strm) \
        inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream))
 #define inflateInit2(strm, windowBits) \
index f415f6b4c37e20657a28dc9e9a42961fd695fb0e..0e1e0d577a2871fdb34cbf68be30ed72f11fccb4 100644 (file)
@@ -214,21 +214,21 @@ typedef enum {
     (most modes can go to the BAD or MEM mode -- not shown for clarity)
 
     Process header:
-        HEAD -> (gzip) or (zlib)
-        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME
-        NAME -> COMMENT -> HCRC -> TYPE
-        (zlib) -> DICTID or TYPE
-        DICTID -> DICT -> TYPE
+       HEAD -> (gzip) or (zlib)
+       (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME
+       NAME -> COMMENT -> HCRC -> TYPE
+       (zlib) -> DICTID or TYPE
+       DICTID -> DICT -> TYPE
     Read deflate blocks:
-            TYPE -> STORED or TABLE or LEN or CHECK
-            STORED -> COPY -> TYPE
-            TABLE -> LENLENS -> CODELENS -> LEN
+           TYPE -> STORED or TABLE or LEN or CHECK
+           STORED -> COPY -> TYPE
+           TABLE -> LENLENS -> CODELENS -> LEN
     Read deflate codes:
-                LEN -> LENEXT or LIT or TYPE
-                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
-                LIT -> LEN
+               LEN -> LENEXT or LIT or TYPE
+               LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
+               LIT -> LEN
     Process trailer:
-        CHECK -> LENGTH -> DONE
+       CHECK -> LENGTH -> DONE
  */
 
 /* state maintained between inflate() calls.  Approximately 7K bytes. */
@@ -242,26 +242,26 @@ struct inflate_state {
        unsigned long check; /* protected copy of check value */
        unsigned long total; /* protected copy of output count */
        gz_headerp head; /* where to save gzip header information */
-        /* sliding window */
+       /* sliding window */
        unsigned wbits; /* log base 2 of requested window size */
        unsigned wsize; /* window size or zero if not using window */
        unsigned whave; /* valid bytes in the window */
        unsigned write; /* window write index */
        unsigned char FAR *window; /* allocated sliding window, if needed */
-        /* bit accumulator */
+       /* bit accumulator */
        unsigned long hold; /* input bit accumulator */
        unsigned bits; /* number of bits in "in" */
-        /* for string and stored block copying */
+       /* for string and stored block copying */
        unsigned length; /* literal or length of data to copy */
        unsigned offset; /* distance back to copy string from */
-        /* for table and code decoding */
+       /* for table and code decoding */
        unsigned extra; /* extra bits needed */
-        /* fixed and dynamic code tables */
+       /* fixed and dynamic code tables */
        code const FAR *lencode; /* starting table for length/literal codes */
        code const FAR *distcode; /* starting table for distance codes */
        unsigned lenbits; /* index bits for lencode */
        unsigned distbits; /* index bits for distcode */
-        /* dynamic table building */
+       /* dynamic table building */
        unsigned ncode; /* number of code length code lengths */
        unsigned nlen; /* number of length code lengths */
        unsigned ndist; /* number of distance code lengths */
@@ -410,17 +410,17 @@ void inflate_fast OF((z_streamp strm, unsigned start));
 
    Entry assumptions:
 
-        state->mode == LEN
-        strm->avail_in >= 6
-        strm->avail_out >= 258
-        start >= strm->avail_out
-        state->bits < 8
+       state->mode == LEN
+       strm->avail_in >= 6
+       strm->avail_out >= 258
+       start >= strm->avail_out
+       state->bits < 8
 
    On return, state->mode is one of:
 
-        LEN -- ran out of enough output space or enough available input
-        TYPE -- reached end of block code, inflate() to interpret next block
-        BAD -- error in block data
+       LEN -- ran out of enough output space or enough available input
+       TYPE -- reached end of block code, inflate() to interpret next block
+       BAD -- error in block data
 
    Notes:
 
@@ -460,7 +460,7 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
     unsigned dmask;             /* mask for first level of distance codes */
     code this;                  /* retrieved table entry */
     unsigned op;                /* code bits, operation, extra bits, or */
-                                /*  window position, window bytes to copy */
+                               /*  window position, window bytes to copy */
     unsigned len;               /* match length, unused bytes */
     unsigned dist;              /* match distance */
     unsigned char FAR *from;    /* where to copy match from */
@@ -489,170 +489,170 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
     /* decode literals and length/distances until end-of-block or not enough
        input data or output space */
     do {
-        if (bits < 15) {
-            hold += (unsigned long)(PUP(in)) << bits;
-            bits += 8;
-            hold += (unsigned long)(PUP(in)) << bits;
-            bits += 8;
-        }
-        this = lcode[hold & lmask];
+       if (bits < 15) {
+           hold += (unsigned long)(PUP(in)) << bits;
+           bits += 8;
+           hold += (unsigned long)(PUP(in)) << bits;
+           bits += 8;
+       }
+       this = lcode[hold & lmask];
       dolen:
-        op = (unsigned)(this.bits);
-        hold >>= op;
-        bits -= op;
-        op = (unsigned)(this.op);
-        if (op == 0) {                          /* literal */
-            Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
-                    "inflate:         literal '%c'\n" :
-                    "inflate:         literal 0x%02x\n", this.val));
-            PUP(out) = (unsigned char)(this.val);
-        }
-        else if (op & 16) {                     /* length base */
-            len = (unsigned)(this.val);
-            op &= 15;                           /* number of extra bits */
-            if (op) {
-                if (bits < op) {
-                    hold += (unsigned long)(PUP(in)) << bits;
-                    bits += 8;
-                }
-                len += (unsigned)hold & ((1U << op) - 1);
-                hold >>= op;
-                bits -= op;
-            }
-            Tracevv((stderr, "inflate:         length %u\n", len));
-            if (bits < 15) {
-                hold += (unsigned long)(PUP(in)) << bits;
-                bits += 8;
-                hold += (unsigned long)(PUP(in)) << bits;
-                bits += 8;
-            }
-            this = dcode[hold & dmask];
-          dodist:
-            op = (unsigned)(this.bits);
-            hold >>= op;
-            bits -= op;
-            op = (unsigned)(this.op);
-            if (op & 16) {                      /* distance base */
-                dist = (unsigned)(this.val);
-                op &= 15;                       /* number of extra bits */
-                if (bits < op) {
-                    hold += (unsigned long)(PUP(in)) << bits;
-                    bits += 8;
-                    if (bits < op) {
-                        hold += (unsigned long)(PUP(in)) << bits;
-                        bits += 8;
-                    }
-                }
-                dist += (unsigned)hold & ((1U << op) - 1);
+       op = (unsigned)(this.bits);
+       hold >>= op;
+       bits -= op;
+       op = (unsigned)(this.op);
+       if (op == 0) {                          /* literal */
+           Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+                   "inflate:         literal '%c'\n" :
+                   "inflate:         literal 0x%02x\n", this.val));
+           PUP(out) = (unsigned char)(this.val);
+       }
+       else if (op & 16) {                     /* length base */
+           len = (unsigned)(this.val);
+           op &= 15;                           /* number of extra bits */
+           if (op) {
+               if (bits < op) {
+                   hold += (unsigned long)(PUP(in)) << bits;
+                   bits += 8;
+               }
+               len += (unsigned)hold & ((1U << op) - 1);
+               hold >>= op;
+               bits -= op;
+           }
+           Tracevv((stderr, "inflate:         length %u\n", len));
+           if (bits < 15) {
+               hold += (unsigned long)(PUP(in)) << bits;
+               bits += 8;
+               hold += (unsigned long)(PUP(in)) << bits;
+               bits += 8;
+           }
+           this = dcode[hold & dmask];
+         dodist:
+           op = (unsigned)(this.bits);
+           hold >>= op;
+           bits -= op;
+           op = (unsigned)(this.op);
+           if (op & 16) {                      /* distance base */
+               dist = (unsigned)(this.val);
+               op &= 15;                       /* number of extra bits */
+               if (bits < op) {
+                   hold += (unsigned long)(PUP(in)) << bits;
+                   bits += 8;
+                   if (bits < op) {
+                       hold += (unsigned long)(PUP(in)) << bits;
+                       bits += 8;
+                   }
+               }
+               dist += (unsigned)hold & ((1U << op) - 1);
 #ifdef INFLATE_STRICT
-                if (dist > dmax) {
-                    strm->msg = (char *)"invalid distance too far back";
-                    state->mode = BAD;
-                    break;
-                }
+               if (dist > dmax) {
+                   strm->msg = (char *)"invalid distance too far back";
+                   state->mode = BAD;
+                   break;
+               }
 #endif
-                hold >>= op;
-                bits -= op;
-                Tracevv((stderr, "inflate:         distance %u\n", dist));
-                op = (unsigned)(out - beg);     /* max distance in output */
-                if (dist > op) {                /* see if copy from window */
-                    op = dist - op;             /* distance back in window */
-                    if (op > whave) {
-                        strm->msg = (char *)"invalid distance too far back";
-                        state->mode = BAD;
-                        break;
-                    }
-                    from = window - OFF;
-                    if (write == 0) {           /* very common case */
-                        from += wsize - op;
-                        if (op < len) {         /* some from window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = out - dist;  /* rest from output */
-                        }
-                    }
-                    else if (write < op) {      /* wrap around window */
-                        from += wsize + write - op;
-                        op -= write;
-                        if (op < len) {         /* some from end of window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = window - OFF;
-                            if (write < len) {  /* some from start of window */
-                                op = write;
-                                len -= op;
-                                do {
-                                    PUP(out) = PUP(from);
-                                } while (--op);
-                                from = out - dist;      /* rest from output */
-                            }
-                        }
-                    }
-                    else {                      /* contiguous in window */
-                        from += write - op;
-                        if (op < len) {         /* some from window */
-                            len -= op;
-                            do {
-                                PUP(out) = PUP(from);
-                            } while (--op);
-                            from = out - dist;  /* rest from output */
-                        }
-                    }
-                    while (len > 2) {
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        len -= 3;
-                    }
-                    if (len) {
-                        PUP(out) = PUP(from);
-                        if (len > 1)
-                            PUP(out) = PUP(from);
-                    }
-                }
-                else {
-                    from = out - dist;          /* copy direct from output */
-                    do {                        /* minimum length is three */
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        PUP(out) = PUP(from);
-                        len -= 3;
-                    } while (len > 2);
-                    if (len) {
-                        PUP(out) = PUP(from);
-                        if (len > 1)
-                            PUP(out) = PUP(from);
-                    }
-                }
-            }
-            else if ((op & 64) == 0) {          /* 2nd level distance code */
-                this = dcode[this.val + (hold & ((1U << op) - 1))];
-                goto dodist;
-            }
-            else {
-                strm->msg = (char *)"invalid distance code";
-                state->mode = BAD;
-                break;
-            }
-        }
-        else if ((op & 64) == 0) {              /* 2nd level length code */
-            this = lcode[this.val + (hold & ((1U << op) - 1))];
-            goto dolen;
-        }
-        else if (op & 32) {                     /* end-of-block */
-            Tracevv((stderr, "inflate:         end of block\n"));
-            state->mode = TYPE;
-            break;
-        }
-        else {
-            strm->msg = (char *)"invalid literal/length code";
-            state->mode = BAD;
-            break;
-        }
+               hold >>= op;
+               bits -= op;
+               Tracevv((stderr, "inflate:         distance %u\n", dist));
+               op = (unsigned)(out - beg);     /* max distance in output */
+               if (dist > op) {                /* see if copy from window */
+                   op = dist - op;             /* distance back in window */
+                   if (op > whave) {
+                       strm->msg = (char *)"invalid distance too far back";
+                       state->mode = BAD;
+                       break;
+                   }
+                   from = window - OFF;
+                   if (write == 0) {           /* very common case */
+                       from += wsize - op;
+                       if (op < len) {         /* some from window */
+                           len -= op;
+                           do {
+                               PUP(out) = PUP(from);
+                           } while (--op);
+                           from = out - dist;  /* rest from output */
+                       }
+                   }
+                   else if (write < op) {      /* wrap around window */
+                       from += wsize + write - op;
+                       op -= write;
+                       if (op < len) {         /* some from end of window */
+                           len -= op;
+                           do {
+                               PUP(out) = PUP(from);
+                           } while (--op);
+                           from = window - OFF;
+                           if (write < len) {  /* some from start of window */
+                               op = write;
+                               len -= op;
+                               do {
+                                   PUP(out) = PUP(from);
+                               } while (--op);
+                               from = out - dist;      /* rest from output */
+                           }
+                       }
+                   }
+                   else {                      /* contiguous in window */
+                       from += write - op;
+                       if (op < len) {         /* some from window */
+                           len -= op;
+                           do {
+                               PUP(out) = PUP(from);
+                           } while (--op);
+                           from = out - dist;  /* rest from output */
+                       }
+                   }
+                   while (len > 2) {
+                       PUP(out) = PUP(from);
+                       PUP(out) = PUP(from);
+                       PUP(out) = PUP(from);
+                       len -= 3;
+                   }
+                   if (len) {
+                       PUP(out) = PUP(from);
+                       if (len > 1)
+                           PUP(out) = PUP(from);
+                   }
+               }
+               else {
+                   from = out - dist;          /* copy direct from output */
+                   do {                        /* minimum length is three */
+                       PUP(out) = PUP(from);
+                       PUP(out) = PUP(from);
+                       PUP(out) = PUP(from);
+                       len -= 3;
+                   } while (len > 2);
+                   if (len) {
+                       PUP(out) = PUP(from);
+                       if (len > 1)
+                           PUP(out) = PUP(from);
+                   }
+               }
+           }
+           else if ((op & 64) == 0) {          /* 2nd level distance code */
+               this = dcode[this.val + (hold & ((1U << op) - 1))];
+               goto dodist;
+           }
+           else {
+               strm->msg = (char *)"invalid distance code";
+               state->mode = BAD;
+               break;
+           }
+       }
+       else if ((op & 64) == 0) {              /* 2nd level length code */
+           this = lcode[this.val + (hold & ((1U << op) - 1))];
+           goto dolen;
+       }
+       else if (op & 32) {                     /* end-of-block */
+           Tracevv((stderr, "inflate:         end of block\n"));
+           state->mode = TYPE;
+           break;
+       }
+       else {
+           strm->msg = (char *)"invalid literal/length code";
+           state->mode = BAD;
+           break;
+       }
     } while (in < last && out < end);
 
     /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
@@ -666,7 +666,7 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
     strm->next_out = out + OFF;
     strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
     strm->avail_out = (unsigned)(out < end ?
-                                 257 + (end - out) : 257 - (out - end));
+                                257 + (end - out) : 257 - (out - end));
     state->hold = hold;
     state->bits = bits;
     return;
@@ -741,19 +741,19 @@ unsigned short FAR *work;
     unsigned short count[MAXBITS+1];    /* number of codes of each length */
     unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
     static const unsigned short lbase[31] = { /* Length codes 257..285 base */
-        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
-        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+       3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+       35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
     static const unsigned short lext[31] = { /* Length codes 257..285 extra */
-        16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
-        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
+       16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
+       19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
     static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
-        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
-        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
-        8193, 12289, 16385, 24577, 0, 0};
+       1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+       257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+       8193, 12289, 16385, 24577, 0, 0};
     static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
-        16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
-        23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
-        28, 28, 29, 29, 64, 64};
+       16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+       23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
+       28, 28, 29, 29, 64, 64};
 
     /*
        Process a set of code lengths to create a canonical Huffman code.  The
@@ -788,46 +788,46 @@ unsigned short FAR *work;
 
     /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
     for (len = 0; len <= MAXBITS; len++)
-        count[len] = 0;
+       count[len] = 0;
     for (sym = 0; sym < codes; sym++)
-        count[lens[sym]]++;
+       count[lens[sym]]++;
 
     /* bound code lengths, force root to be within code lengths */
     root = *bits;
     for (max = MAXBITS; max >= 1; max--)
-        if (count[max] != 0) break;
+       if (count[max] != 0) break;
     if (root > max) root = max;
     if (max == 0) {                     /* no symbols to code at all */
-        this.op = (unsigned char)64;    /* invalid code marker */
-        this.bits = (unsigned char)1;
-        this.val = (unsigned short)0;
-        *(*table)++ = this;             /* make a table to force an error */
-        *(*table)++ = this;
-        *bits = 1;
-        return 0;     /* no symbols, but wait for decoding to report error */
+       this.op = (unsigned char)64;    /* invalid code marker */
+       this.bits = (unsigned char)1;
+       this.val = (unsigned short)0;
+       *(*table)++ = this;             /* make a table to force an error */
+       *(*table)++ = this;
+       *bits = 1;
+       return 0;     /* no symbols, but wait for decoding to report error */
     }
     for (min = 1; min <= MAXBITS; min++)
-        if (count[min] != 0) break;
+       if (count[min] != 0) break;
     if (root < min) root = min;
 
     /* check for an over-subscribed or incomplete set of lengths */
     left = 1;
     for (len = 1; len <= MAXBITS; len++) {
-        left <<= 1;
-        left -= count[len];
-        if (left < 0) return -1;        /* over-subscribed */
+       left <<= 1;
+       left -= count[len];
+       if (left < 0) return -1;        /* over-subscribed */
     }
     if (left > 0 && (type == CODES || max != 1))
-        return -1;                      /* incomplete set */
+       return -1;                      /* incomplete set */
 
     /* generate offsets into symbol table for each length for sorting */
     offs[1] = 0;
     for (len = 1; len < MAXBITS; len++)
-        offs[len + 1] = offs[len] + count[len];
+       offs[len + 1] = offs[len] + count[len];
 
     /* sort symbols by length, by symbol order within each length */
     for (sym = 0; sym < codes; sym++)
-        if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
+       if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
 
     /*
        Create and fill in decoding tables.  In this loop, the table being
@@ -864,20 +864,20 @@ unsigned short FAR *work;
     /* set up for code type */
     switch (type) {
     case CODES:
-        base = extra = work;    /* dummy value--not used */
-        end = 19;
-        break;
+       base = extra = work;    /* dummy value--not used */
+       end = 19;
+       break;
     case LENS:
-        base = lbase;
-        base -= 257;
-        extra = lext;
-        extra -= 257;
-        end = 256;
-        break;
+       base = lbase;
+       base -= 257;
+       extra = lext;
+       extra -= 257;
+       end = 256;
+       break;
     default:            /* DISTS */
-        base = dbase;
-        extra = dext;
-        end = -1;
+       base = dbase;
+       extra = dext;
+       end = -1;
     }
 
     /* initialize state for loop */
@@ -893,82 +893,82 @@ unsigned short FAR *work;
 
     /* check available table space */
     if (type == LENS && used >= ENOUGH - MAXD)
-        return 1;
+       return 1;
 
     /* process all codes and make table entries */
     for (;;) {
-        /* create table entry */
-        this.bits = (unsigned char)(len - drop);
-        if ((int)(work[sym]) < end) {
-            this.op = (unsigned char)0;
-            this.val = work[sym];
-        }
-        else if ((int)(work[sym]) > end) {
-            this.op = (unsigned char)(extra[work[sym]]);
-            this.val = base[work[sym]];
-        }
-        else {
-            this.op = (unsigned char)(32 + 64);         /* end of block */
-            this.val = 0;
-        }
-
-        /* replicate for those indices with low len bits equal to huff */
-        incr = 1U << (len - drop);
-        fill = 1U << curr;
-        min = fill;                 /* save offset to next table */
-        do {
-            fill -= incr;
-            next[(huff >> drop) + fill] = this;
-        } while (fill != 0);
-
-        /* backwards increment the len-bit code huff */
-        incr = 1U << (len - 1);
-        while (huff & incr)
-            incr >>= 1;
-        if (incr != 0) {
-            huff &= incr - 1;
-            huff += incr;
-        }
-        else
-            huff = 0;
-
-        /* go to next symbol, update count, len */
-        sym++;
-        if (--(count[len]) == 0) {
-            if (len == max) break;
-            len = lens[work[sym]];
-        }
-
-        /* create new sub-table if needed */
-        if (len > root && (huff & mask) != low) {
-            /* if first time, transition to sub-tables */
-            if (drop == 0)
-                drop = root;
-
-            /* increment past last table */
-            next += min;            /* here min is 1 << curr */
-
-            /* determine length of next table */
-            curr = len - drop;
-            left = (int)(1 << curr);
-            while (curr + drop < max) {
-                left -= count[curr + drop];
-                if (left <= 0) break;
-                curr++;
-                left <<= 1;
-            }
-
-            /* check for enough space */
-            used += 1U << curr;
-            if (type == LENS && used >= ENOUGH - MAXD)
-                return 1;
-
-            /* point entry in root table to sub-table */
-            low = huff & mask;
-            (*table)[low].op = (unsigned char)curr;
-            (*table)[low].bits = (unsigned char)root;
-            (*table)[low].val = (unsigned short)(next - *table);
-        }
+       /* create table entry */
+       this.bits = (unsigned char)(len - drop);
+       if ((int)(work[sym]) < end) {
+           this.op = (unsigned char)0;
+           this.val = work[sym];
+       }
+       else if ((int)(work[sym]) > end) {
+           this.op = (unsigned char)(extra[work[sym]]);
+           this.val = base[work[sym]];
+       }
+       else {
+           this.op = (unsigned char)(32 + 64);         /* end of block */
+           this.val = 0;
+       }
+
+       /* replicate for those indices with low len bits equal to huff */
+       incr = 1U << (len - drop);
+       fill = 1U << curr;
+       min = fill;                 /* save offset to next table */
+       do {
+           fill -= incr;
+           next[(huff >> drop) + fill] = this;
+       } while (fill != 0);
+
+       /* backwards increment the len-bit code huff */
+       incr = 1U << (len - 1);
+       while (huff & incr)
+           incr >>= 1;
+       if (incr != 0) {
+           huff &= incr - 1;
+           huff += incr;
+       }
+       else
+           huff = 0;
+
+       /* go to next symbol, update count, len */
+       sym++;
+       if (--(count[len]) == 0) {
+           if (len == max) break;
+           len = lens[work[sym]];
+       }
+
+       /* create new sub-table if needed */
+       if (len > root && (huff & mask) != low) {
+           /* if first time, transition to sub-tables */
+           if (drop == 0)
+               drop = root;
+
+           /* increment past last table */
+           next += min;            /* here min is 1 << curr */
+
+           /* determine length of next table */
+           curr = len - drop;
+           left = (int)(1 << curr);
+           while (curr + drop < max) {
+               left -= count[curr + drop];
+               if (left <= 0) break;
+               curr++;
+               left <<= 1;
+           }
+
+           /* check for enough space */
+           used += 1U << curr;
+           if (type == LENS && used >= ENOUGH - MAXD)
+               return 1;
+
+           /* point entry in root table to sub-table */
+           low = huff & mask;
+           (*table)[low].op = (unsigned char)curr;
+           (*table)[low].bits = (unsigned char)root;
+           (*table)[low].val = (unsigned short)(next - *table);
+       }
     }
 
     /*
@@ -982,27 +982,27 @@ unsigned short FAR *work;
     this.bits = (unsigned char)(len - drop);
     this.val = (unsigned short)0;
     while (huff != 0) {
-        /* when done with sub-table, drop back to root table */
-        if (drop != 0 && (huff & mask) != low) {
-            drop = 0;
-            len = root;
-            next = *table;
-            this.bits = (unsigned char)len;
-        }
-
-        /* put invalid code marker in table */
-        next[huff >> drop] = this;
-
-        /* backwards increment the len-bit code huff */
-        incr = 1U << (len - 1);
-        while (huff & incr)
-            incr >>= 1;
-        if (incr != 0) {
-            huff &= incr - 1;
-            huff += incr;
-        }
-        else
-            huff = 0;
+       /* when done with sub-table, drop back to root table */
+       if (drop != 0 && (huff & mask) != low) {
+           drop = 0;
+           len = root;
+           next = *table;
+           this.bits = (unsigned char)len;
+       }
+
+       /* put invalid code marker in table */
+       next[huff >> drop] = this;
+
+       /* backwards increment the len-bit code huff */
+       incr = 1U << (len - 1);
+       while (huff & incr)
+           incr >>= 1;
+       if (incr != 0) {
+           huff &= incr - 1;
+           huff += incr;
+       }
+       else
+           huff = 0;
     }
 
     /* set return parameters */
@@ -1053,34 +1053,34 @@ int stream_size;
     struct inflate_state FAR *state;
 
     if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
-        stream_size != (int)(sizeof(z_stream)))
-        return Z_VERSION_ERROR;
+       stream_size != (int)(sizeof(z_stream)))
+       return Z_VERSION_ERROR;
     if (strm == Z_NULL) return Z_STREAM_ERROR;
     strm->msg = Z_NULL;                 /* in case we return an error */
     if (strm->zalloc == (alloc_func)0) {
-        strm->zalloc = zcalloc;
-        strm->opaque = (voidpf)0;
+       strm->zalloc = zcalloc;
+       strm->opaque = (voidpf)0;
     }
     if (strm->zfree == (free_func)0) strm->zfree = zcfree;
     state = (struct inflate_state FAR *)
-            ZALLOC(strm, 1, sizeof(struct inflate_state));
+           ZALLOC(strm, 1, sizeof(struct inflate_state));
     if (state == Z_NULL) return Z_MEM_ERROR;
     Tracev((stderr, "inflate: allocated\n"));
     strm->state = (struct internal_state FAR *)state;
     if (windowBits < 0) {
-        state->wrap = 0;
-        windowBits = -windowBits;
+       state->wrap = 0;
+       windowBits = -windowBits;
     }
     else {
-        state->wrap = (windowBits >> 4) + 1;
+       state->wrap = (windowBits >> 4) + 1;
 #ifdef GUNZIP
-        if (windowBits < 48) windowBits &= 15;
+       if (windowBits < 48) windowBits &= 15;
 #endif
     }
     if (windowBits < 8 || windowBits > 15) {
-        ZFREE(strm, state);
-        strm->state = Z_NULL;
-        return Z_STREAM_ERROR;
+       ZFREE(strm, state);
+       strm->state = Z_NULL;
+       return Z_STREAM_ERROR;
     }
     state->wbits = (unsigned)windowBits;
     state->window = Z_NULL;
@@ -1129,41 +1129,41 @@ unsigned out;
 
     /* if it hasn't been done already, allocate space for the window */
     if (state->window == Z_NULL) {
-        state->window = (unsigned char FAR *)
-                        ZALLOC(strm, 1U << state->wbits,
-                               sizeof(unsigned char));
-        if (state->window == Z_NULL) return 1;
+       state->window = (unsigned char FAR *)
+                       ZALLOC(strm, 1U << state->wbits,
+                              sizeof(unsigned char));
+       if (state->window == Z_NULL) return 1;
     }
 
     /* if window not in use yet, initialize */
     if (state->wsize == 0) {
-        state->wsize = 1U << state->wbits;
-        state->write = 0;
-        state->whave = 0;
+       state->wsize = 1U << state->wbits;
+       state->write = 0;
+       state->whave = 0;
     }
 
     /* copy state->wsize or less output bytes into the circular window */
     copy = out - strm->avail_out;
     if (copy >= state->wsize) {
-        zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
-        state->write = 0;
-        state->whave = state->wsize;
+       zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
+       state->write = 0;
+       state->whave = state->wsize;
     }
     else {
-        dist = state->wsize - state->write;
-        if (dist > copy) dist = copy;
-        zmemcpy(state->window + state->write, strm->next_out - copy, dist);
-        copy -= dist;
-        if (copy) {
-            zmemcpy(state->window, strm->next_out - copy, copy);
-            state->write = copy;
-            state->whave = state->wsize;
-        }
-        else {
-            state->write += dist;
-            if (state->write == state->wsize) state->write = 0;
-            if (state->whave < state->wsize) state->whave += dist;
-        }
+       dist = state->wsize - state->write;
+       if (dist > copy) dist = copy;
+       zmemcpy(state->window + state->write, strm->next_out - copy, dist);
+       copy -= dist;
+       if (copy) {
+           zmemcpy(state->window, strm->next_out - copy, copy);
+           state->write = copy;
+           state->whave = state->wsize;
+       }
+       else {
+           state->write += dist;
+           if (state->write == state->wsize) state->write = 0;
+           if (state->whave < state->wsize) state->whave += dist;
+       }
     }
     return 0;
 }
@@ -1269,11 +1269,11 @@ unsigned out;
     for (;;) switch (state) {
     ...
     case STATEn:
-        if (not enough input data or output space to make progress)
-            return;
-        ... make progress ...
-        state = STATEm;
-        break;
+       if (not enough input data or output space to make progress)
+           return;
+       ... make progress ...
+       state = STATEm;
+       break;
     ...
     }
 
@@ -1284,9 +1284,9 @@ unsigned out;
    the requested bits are not available.  The typical use of the BITS macros
    is:
 
-        NEEDBITS(n);
-        ... do something with BITS(n) ...
-        DROPBITS(n);
+       NEEDBITS(n);
+       ... do something with BITS(n) ...
+       DROPBITS(n);
 
    where NEEDBITS(n) either returns from inflate() if there isn't enough
    input left to load n bits into the accumulator, or it continues.  BITS(n)
@@ -1308,12 +1308,12 @@ unsigned out;
    returns:
 
     case STATEw:
-        while (want < need) {
-            NEEDBITS(n);
-            keep[want++] = BITS(n);
-            DROPBITS(n);
-        }
-        state = STATEx;
+       while (want < need) {
+           NEEDBITS(n);
+           keep[want++] = BITS(n);
+           DROPBITS(n);
+       }
+       state = STATEx;
     case STATEx:
 
    As shown above, if the next state is also the next case, then the break
@@ -1363,11 +1363,11 @@ int flush;
     unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
 #endif
     static const unsigned short order[19] = /* permutation of code lengths */
-        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+       {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
 
     if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
-        (strm->next_in == Z_NULL && strm->avail_in != 0))
-        return Z_STREAM_ERROR;
+       (strm->next_in == Z_NULL && strm->avail_in != 0))
+       return Z_STREAM_ERROR;
 
     state = (struct inflate_state FAR *)strm->state;
     if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
@@ -1376,544 +1376,544 @@ int flush;
     out = left;
     ret = Z_OK;
     for (;;)
-        switch (state->mode) {
-        case HEAD:
-            if (state->wrap == 0) {
-                state->mode = TYPEDO;
-                break;
-            }
-            NEEDBITS(16);
+       switch (state->mode) {
+       case HEAD:
+           if (state->wrap == 0) {
+               state->mode = TYPEDO;
+               break;
+           }
+           NEEDBITS(16);
 #ifdef GUNZIP
-            if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
-                state->check = crc32(0L, Z_NULL, 0);
-                CRC2(state->check, hold);
-                INITBITS();
-                state->mode = FLAGS;
-                break;
-            }
-            state->flags = 0;           /* expect zlib header */
-            if (state->head != Z_NULL)
-                state->head->done = -1;
-            if (!(state->wrap & 1) ||   /* check if zlib header allowed */
+           if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
+               state->check = crc32(0L, Z_NULL, 0);
+               CRC2(state->check, hold);
+               INITBITS();
+               state->mode = FLAGS;
+               break;
+           }
+           state->flags = 0;           /* expect zlib header */
+           if (state->head != Z_NULL)
+               state->head->done = -1;
+           if (!(state->wrap & 1) ||   /* check if zlib header allowed */
 #else
-            if (
+           if (
 #endif
-                ((BITS(8) << 8) + (hold >> 8)) % 31) {
-                strm->msg = (char *)"incorrect header check";
-                state->mode = BAD;
-                break;
-            }
-            if (BITS(4) != Z_DEFLATED) {
-                strm->msg = (char *)"unknown compression method";
-                state->mode = BAD;
-                break;
-            }
-            DROPBITS(4);
-            len = BITS(4) + 8;
-            if (len > state->wbits) {
-                strm->msg = (char *)"invalid window size";
-                state->mode = BAD;
-                break;
-            }
-            state->dmax = 1U << len;
-            Tracev((stderr, "inflate:   zlib header ok\n"));
-            strm->adler = state->check = adler32(0L, Z_NULL, 0);
-            state->mode = hold & 0x200 ? DICTID : TYPE;
-            INITBITS();
-            break;
+               ((BITS(8) << 8) + (hold >> 8)) % 31) {
+               strm->msg = (char *)"incorrect header check";
+               state->mode = BAD;
+               break;
+           }
+           if (BITS(4) != Z_DEFLATED) {
+               strm->msg = (char *)"unknown compression method";
+               state->mode = BAD;
+               break;
+           }
+           DROPBITS(4);
+           len = BITS(4) + 8;
+           if (len > state->wbits) {
+               strm->msg = (char *)"invalid window size";
+               state->mode = BAD;
+               break;
+           }
+           state->dmax = 1U << len;
+           Tracev((stderr, "inflate:   zlib header ok\n"));
+           strm->adler = state->check = adler32(0L, Z_NULL, 0);
+           state->mode = hold & 0x200 ? DICTID : TYPE;
+           INITBITS();
+           break;
 #ifdef GUNZIP
-        case FLAGS:
-            NEEDBITS(16);
-            state->flags = (int)(hold);
-            if ((state->flags & 0xff) != Z_DEFLATED) {
-                strm->msg = (char *)"unknown compression method";
-                state->mode = BAD;
-                break;
-            }
-            if (state->flags & 0xe000) {
-                strm->msg = (char *)"unknown header flags set";
-                state->mode = BAD;
-                break;
-            }
-            if (state->head != Z_NULL)
-                state->head->text = (int)((hold >> 8) & 1);
-            if (state->flags & 0x0200) CRC2(state->check, hold);
-            INITBITS();
-            state->mode = TIME;
-        case TIME:
-            NEEDBITS(32);
-            if (state->head != Z_NULL)
-                state->head->time = hold;
-            if (state->flags & 0x0200) CRC4(state->check, hold);
-            INITBITS();
-            state->mode = OS;
-        case OS:
-            NEEDBITS(16);
-            if (state->head != Z_NULL) {
-                state->head->xflags = (int)(hold & 0xff);
-                state->head->os = (int)(hold >> 8);
-            }
-            if (state->flags & 0x0200) CRC2(state->check, hold);
-            INITBITS();
-            state->mode = EXLEN;
-        case EXLEN:
-            if (state->flags & 0x0400) {
-                NEEDBITS(16);
-                state->length = (unsigned)(hold);
-                if (state->head != Z_NULL)
-                    state->head->extra_len = (unsigned)hold;
-                if (state->flags & 0x0200) CRC2(state->check, hold);
-                INITBITS();
-            }
-            else if (state->head != Z_NULL)
-                state->head->extra = Z_NULL;
-            state->mode = EXTRA;
-        case EXTRA:
-            if (state->flags & 0x0400) {
-                copy = state->length;
-                if (copy > have) copy = have;
-                if (copy) {
-                    if (state->head != Z_NULL &&
-                        state->head->extra != Z_NULL) {
-                        len = state->head->extra_len - state->length;
-                        zmemcpy(state->head->extra + len, next,
-                                len + copy > state->head->extra_max ?
-                                state->head->extra_max - len : copy);
-                    }
-                    if (state->flags & 0x0200)
-                        state->check = crc32(state->check, next, copy);
-                    have -= copy;
-                    next += copy;
-                    state->length -= copy;
-                }
-                if (state->length) goto inf_leave;
-            }
-            state->length = 0;
-            state->mode = NAME;
-        case NAME:
-            if (state->flags & 0x0800) {
-                if (have == 0) goto inf_leave;
-                copy = 0;
-                do {
-                    len = (unsigned)(next[copy++]);
-                    if (state->head != Z_NULL &&
-                            state->head->name != Z_NULL &&
-                            state->length < state->head->name_max)
-                        state->head->name[state->length++] = len;
-                } while (len && copy < have);
-                if (state->flags & 0x0200)
-                    state->check = crc32(state->check, next, copy);
-                have -= copy;
-                next += copy;
-                if (len) goto inf_leave;
-            }
-            else if (state->head != Z_NULL)
-                state->head->name = Z_NULL;
-            state->length = 0;
-            state->mode = COMMENT;
-        case COMMENT:
-            if (state->flags & 0x1000) {
-                if (have == 0) goto inf_leave;
-                copy = 0;
-                do {
-                    len = (unsigned)(next[copy++]);
-                    if (state->head != Z_NULL &&
-                            state->head->comment != Z_NULL &&
-                            state->length < state->head->comm_max)
-                        state->head->comment[state->length++] = len;
-                } while (len && copy < have);
-                if (state->flags & 0x0200)
-                    state->check = crc32(state->check, next, copy);
-                have -= copy;
-                next += copy;
-                if (len) goto inf_leave;
-            }
-            else if (state->head != Z_NULL)
-                state->head->comment = Z_NULL;
-            state->mode = HCRC;
-        case HCRC:
-            if (state->flags & 0x0200) {
-                NEEDBITS(16);
-                if (hold != (state->check & 0xffff)) {
-                    strm->msg = (char *)"header crc mismatch";
-                    state->mode = BAD;
-                    break;
-                }
-                INITBITS();
-            }
-            if (state->head != Z_NULL) {
-                state->head->hcrc = (int)((state->flags >> 9) & 1);
-                state->head->done = 1;
-            }
-            strm->adler = state->check = crc32(0L, Z_NULL, 0);
-            state->mode = TYPE;
-            break;
+       case FLAGS:
+           NEEDBITS(16);
+           state->flags = (int)(hold);
+           if ((state->flags & 0xff) != Z_DEFLATED) {
+               strm->msg = (char *)"unknown compression method";
+               state->mode = BAD;
+               break;
+           }
+           if (state->flags & 0xe000) {
+               strm->msg = (char *)"unknown header flags set";
+               state->mode = BAD;
+               break;
+           }
+           if (state->head != Z_NULL)
+               state->head->text = (int)((hold >> 8) & 1);
+           if (state->flags & 0x0200) CRC2(state->check, hold);
+           INITBITS();
+           state->mode = TIME;
+       case TIME:
+           NEEDBITS(32);
+           if (state->head != Z_NULL)
+               state->head->time = hold;
+           if (state->flags & 0x0200) CRC4(state->check, hold);
+           INITBITS();
+           state->mode = OS;
+       case OS:
+           NEEDBITS(16);
+           if (state->head != Z_NULL) {
+               state->head->xflags = (int)(hold & 0xff);
+               state->head->os = (int)(hold >> 8);
+           }
+           if (state->flags & 0x0200) CRC2(state->check, hold);
+           INITBITS();
+           state->mode = EXLEN;
+       case EXLEN:
+           if (state->flags & 0x0400) {
+               NEEDBITS(16);
+               state->length = (unsigned)(hold);
+               if (state->head != Z_NULL)
+                   state->head->extra_len = (unsigned)hold;
+               if (state->flags & 0x0200) CRC2(state->check, hold);
+               INITBITS();
+           }
+           else if (state->head != Z_NULL)
+               state->head->extra = Z_NULL;
+           state->mode = EXTRA;
+       case EXTRA:
+           if (state->flags & 0x0400) {
+               copy = state->length;
+               if (copy > have) copy = have;
+               if (copy) {
+                   if (state->head != Z_NULL &&
+                       state->head->extra != Z_NULL) {
+                       len = state->head->extra_len - state->length;
+                       zmemcpy(state->head->extra + len, next,
+                               len + copy > state->head->extra_max ?
+                               state->head->extra_max - len : copy);
+                   }
+                   if (state->flags & 0x0200)
+                       state->check = crc32(state->check, next, copy);
+                   have -= copy;
+                   next += copy;
+                   state->length -= copy;
+               }
+               if (state->length) goto inf_leave;
+           }
+           state->length = 0;
+           state->mode = NAME;
+       case NAME:
+           if (state->flags & 0x0800) {
+               if (have == 0) goto inf_leave;
+               copy = 0;
+               do {
+                   len = (unsigned)(next[copy++]);
+                   if (state->head != Z_NULL &&
+                           state->head->name != Z_NULL &&
+                           state->length < state->head->name_max)
+                       state->head->name[state->length++] = len;
+               } while (len && copy < have);
+               if (state->flags & 0x0200)
+                   state->check = crc32(state->check, next, copy);
+               have -= copy;
+               next += copy;
+               if (len) goto inf_leave;
+           }
+           else if (state->head != Z_NULL)
+               state->head->name = Z_NULL;
+           state->length = 0;
+           state->mode = COMMENT;
+       case COMMENT:
+           if (state->flags & 0x1000) {
+               if (have == 0) goto inf_leave;
+               copy = 0;
+               do {
+                   len = (unsigned)(next[copy++]);
+                   if (state->head != Z_NULL &&
+                           state->head->comment != Z_NULL &&
+                           state->length < state->head->comm_max)
+                       state->head->comment[state->length++] = len;
+               } while (len && copy < have);
+               if (state->flags & 0x0200)
+                   state->check = crc32(state->check, next, copy);
+               have -= copy;
+               next += copy;
+               if (len) goto inf_leave;
+           }
+           else if (state->head != Z_NULL)
+               state->head->comment = Z_NULL;
+           state->mode = HCRC;
+       case HCRC:
+           if (state->flags & 0x0200) {
+               NEEDBITS(16);
+               if (hold != (state->check & 0xffff)) {
+                   strm->msg = (char *)"header crc mismatch";
+                   state->mode = BAD;
+                   break;
+               }
+               INITBITS();
+           }
+           if (state->head != Z_NULL) {
+               state->head->hcrc = (int)((state->flags >> 9) & 1);
+               state->head->done = 1;
+           }
+           strm->adler = state->check = crc32(0L, Z_NULL, 0);
+           state->mode = TYPE;
+           break;
 #endif
-        case DICTID:
-            NEEDBITS(32);
-            strm->adler = state->check = REVERSE(hold);
-            INITBITS();
-            state->mode = DICT;
-        case DICT:
-            if (state->havedict == 0) {
-                RESTORE();
-                return Z_NEED_DICT;
-            }
-            strm->adler = state->check = adler32(0L, Z_NULL, 0);
-            state->mode = TYPE;
-        case TYPE:
-            if (flush == Z_BLOCK) goto inf_leave;
-        case TYPEDO:
-            if (state->last) {
-                BYTEBITS();
-                state->mode = CHECK;
-                break;
-            }
-            NEEDBITS(3);
-            state->last = BITS(1);
-            DROPBITS(1);
-            switch (BITS(2)) {
-            case 0:                             /* stored block */
-                Tracev((stderr, "inflate:     stored block%s\n",
-                        state->last ? " (last)" : ""));
-                state->mode = STORED;
-                break;
-            case 1:                             /* fixed block */
-                fixedtables(state);
-                Tracev((stderr, "inflate:     fixed codes block%s\n",
-                        state->last ? " (last)" : ""));
-                state->mode = LEN;              /* decode codes */
-                break;
-            case 2:                             /* dynamic block */
-                Tracev((stderr, "inflate:     dynamic codes block%s\n",
-                        state->last ? " (last)" : ""));
-                state->mode = TABLE;
-                break;
-            case 3:
-                strm->msg = (char *)"invalid block type";
-                state->mode = BAD;
-            }
-            DROPBITS(2);
-            break;
-        case STORED:
-            BYTEBITS();                         /* go to byte boundary */
-            NEEDBITS(32);
-            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
-                strm->msg = (char *)"invalid stored block lengths";
-                state->mode = BAD;
-                break;
-            }
-            state->length = (unsigned)hold & 0xffff;
-            Tracev((stderr, "inflate:       stored length %u\n",
-                    state->length));
-            INITBITS();
-            state->mode = COPY;
-        case COPY:
-            copy = state->length;
-            if (copy) {
-                if (copy > have) copy = have;
-                if (copy > left) copy = left;
-                if (copy == 0) goto inf_leave;
-                zmemcpy(put, next, copy);
-                have -= copy;
-                next += copy;
-                left -= copy;
-                put += copy;
-                state->length -= copy;
-                break;
-            }
-            Tracev((stderr, "inflate:       stored end\n"));
-            state->mode = TYPE;
-            break;
-        case TABLE:
-            NEEDBITS(14);
-            state->nlen = BITS(5) + 257;
-            DROPBITS(5);
-            state->ndist = BITS(5) + 1;
-            DROPBITS(5);
-            state->ncode = BITS(4) + 4;
-            DROPBITS(4);
+       case DICTID:
+           NEEDBITS(32);
+           strm->adler = state->check = REVERSE(hold);
+           INITBITS();
+           state->mode = DICT;
+       case DICT:
+           if (state->havedict == 0) {
+               RESTORE();
+               return Z_NEED_DICT;
+           }
+           strm->adler = state->check = adler32(0L, Z_NULL, 0);
+           state->mode = TYPE;
+       case TYPE:
+           if (flush == Z_BLOCK) goto inf_leave;
+       case TYPEDO:
+           if (state->last) {
+               BYTEBITS();
+               state->mode = CHECK;
+               break;
+           }
+           NEEDBITS(3);
+           state->last = BITS(1);
+           DROPBITS(1);
+           switch (BITS(2)) {
+           case 0:                             /* stored block */
+               Tracev((stderr, "inflate:     stored block%s\n",
+                       state->last ? " (last)" : ""));
+               state->mode = STORED;
+               break;
+           case 1:                             /* fixed block */
+               fixedtables(state);
+               Tracev((stderr, "inflate:     fixed codes block%s\n",
+                       state->last ? " (last)" : ""));
+               state->mode = LEN;              /* decode codes */
+               break;
+           case 2:                             /* dynamic block */
+               Tracev((stderr, "inflate:     dynamic codes block%s\n",
+                       state->last ? " (last)" : ""));
+               state->mode = TABLE;
+               break;
+           case 3:
+               strm->msg = (char *)"invalid block type";
+               state->mode = BAD;
+           }
+           DROPBITS(2);
+           break;
+       case STORED:
+           BYTEBITS();                         /* go to byte boundary */
+           NEEDBITS(32);
+           if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+               strm->msg = (char *)"invalid stored block lengths";
+               state->mode = BAD;
+               break;
+           }
+           state->length = (unsigned)hold & 0xffff;
+           Tracev((stderr, "inflate:       stored length %u\n",
+                   state->length));
+           INITBITS();
+           state->mode = COPY;
+       case COPY:
+           copy = state->length;
+           if (copy) {
+               if (copy > have) copy = have;
+               if (copy > left) copy = left;
+               if (copy == 0) goto inf_leave;
+               zmemcpy(put, next, copy);
+               have -= copy;
+               next += copy;
+               left -= copy;
+               put += copy;
+               state->length -= copy;
+               break;
+           }
+           Tracev((stderr, "inflate:       stored end\n"));
+           state->mode = TYPE;
+           break;
+       case TABLE:
+           NEEDBITS(14);
+           state->nlen = BITS(5) + 257;
+           DROPBITS(5);
+           state->ndist = BITS(5) + 1;
+           DROPBITS(5);
+           state->ncode = BITS(4) + 4;
+           DROPBITS(4);
 #ifndef PKZIP_BUG_WORKAROUND
-            if (state->nlen > 286 || state->ndist > 30) {
-                strm->msg = (char *)"too many length or distance symbols";
-                state->mode = BAD;
-                break;
-            }
+           if (state->nlen > 286 || state->ndist > 30) {
+               strm->msg = (char *)"too many length or distance symbols";
+               state->mode = BAD;
+               break;
+           }
 #endif
-            Tracev((stderr, "inflate:       table sizes ok\n"));
-            state->have = 0;
-            state->mode = LENLENS;
-        case LENLENS:
-            while (state->have < state->ncode) {
-                NEEDBITS(3);
-                state->lens[order[state->have++]] = (unsigned short)BITS(3);
-                DROPBITS(3);
-            }
-            while (state->have < 19)
-                state->lens[order[state->have++]] = 0;
-            state->next = state->codes;
-            state->lencode = (code const FAR *)(state->next);
-            state->lenbits = 7;
-            ret = inflate_table(CODES, state->lens, 19, &(state->next),
-                                &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid code lengths set";
-                state->mode = BAD;
-                break;
-            }
-            Tracev((stderr, "inflate:       code lengths ok\n"));
-            state->have = 0;
-            state->mode = CODELENS;
-        case CODELENS:
-            while (state->have < state->nlen + state->ndist) {
-                for (;;) {
-                    this = state->lencode[BITS(state->lenbits)];
-                    if ((unsigned)(this.bits) <= bits) break;
-                    PULLBYTE();
-                }
-                if (this.val < 16) {
-                    NEEDBITS(this.bits);
-                    DROPBITS(this.bits);
-                    state->lens[state->have++] = this.val;
-                }
-                else {
-                    if (this.val == 16) {
-                        NEEDBITS(this.bits + 2);
-                        DROPBITS(this.bits);
-                        if (state->have == 0) {
-                            strm->msg = (char *)"invalid bit length repeat";
-                            state->mode = BAD;
-                            break;
-                        }
-                        len = state->lens[state->have - 1];
-                        copy = 3 + BITS(2);
-                        DROPBITS(2);
-                    }
-                    else if (this.val == 17) {
-                        NEEDBITS(this.bits + 3);
-                        DROPBITS(this.bits);
-                        len = 0;
-                        copy = 3 + BITS(3);
-                        DROPBITS(3);
-                    }
-                    else {
-                        NEEDBITS(this.bits + 7);
-                        DROPBITS(this.bits);
-                        len = 0;
-                        copy = 11 + BITS(7);
-                        DROPBITS(7);
-                    }
-                    if (state->have + copy > state->nlen + state->ndist) {
-                        strm->msg = (char *)"invalid bit length repeat";
-                        state->mode = BAD;
-                        break;
-                    }
-                    while (copy--)
-                        state->lens[state->have++] = (unsigned short)len;
-                }
-            }
-
-            /* handle error breaks in while */
-            if (state->mode == BAD) break;
-
-            /* build code tables */
-            state->next = state->codes;
-            state->lencode = (code const FAR *)(state->next);
-            state->lenbits = 9;
-            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
-                                &(state->lenbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid literal/lengths set";
-                state->mode = BAD;
-                break;
-            }
-            state->distcode = (code const FAR *)(state->next);
-            state->distbits = 6;
-            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
-                            &(state->next), &(state->distbits), state->work);
-            if (ret) {
-                strm->msg = (char *)"invalid distances set";
-                state->mode = BAD;
-                break;
-            }
-            Tracev((stderr, "inflate:       codes ok\n"));
-            state->mode = LEN;
-        case LEN:
-            if (have >= 6 && left >= 258) {
-                RESTORE();
-                inflate_fast(strm, out);
-                LOAD();
-                break;
-            }
-            for (;;) {
-                this = state->lencode[BITS(state->lenbits)];
-                if ((unsigned)(this.bits) <= bits) break;
-                PULLBYTE();
-            }
-            if (this.op && (this.op & 0xf0) == 0) {
-                last = this;
-                for (;;) {
-                    this = state->lencode[last.val +
-                            (BITS(last.bits + last.op) >> last.bits)];
-                    if ((unsigned)(last.bits + this.bits) <= bits) break;
-                    PULLBYTE();
-                }
-                DROPBITS(last.bits);
-            }
-            DROPBITS(this.bits);
-            state->length = (unsigned)this.val;
-            if ((int)(this.op) == 0) {
-                Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
-                        "inflate:         literal '%c'\n" :
-                        "inflate:         literal 0x%02x\n", this.val));
-                state->mode = LIT;
-                break;
-            }
-            if (this.op & 32) {
-                Tracevv((stderr, "inflate:         end of block\n"));
-                state->mode = TYPE;
-                break;
-            }
-            if (this.op & 64) {
-                strm->msg = (char *)"invalid literal/length code";
-                state->mode = BAD;
-                break;
-            }
-            state->extra = (unsigned)(this.op) & 15;
-            state->mode = LENEXT;
-        case LENEXT:
-            if (state->extra) {
-                NEEDBITS(state->extra);
-                state->length += BITS(state->extra);
-                DROPBITS(state->extra);
-            }
-            Tracevv((stderr, "inflate:         length %u\n", state->length));
-            state->mode = DIST;
-        case DIST:
-            for (;;) {
-                this = state->distcode[BITS(state->distbits)];
-                if ((unsigned)(this.bits) <= bits) break;
-                PULLBYTE();
-            }
-            if ((this.op & 0xf0) == 0) {
-                last = this;
-                for (;;) {
-                    this = state->distcode[last.val +
-                            (BITS(last.bits + last.op) >> last.bits)];
-                    if ((unsigned)(last.bits + this.bits) <= bits) break;
-                    PULLBYTE();
-                }
-                DROPBITS(last.bits);
-            }
-            DROPBITS(this.bits);
-            if (this.op & 64) {
-                strm->msg = (char *)"invalid distance code";
-                state->mode = BAD;
-                break;
-            }
-            state->offset = (unsigned)this.val;
-            state->extra = (unsigned)(this.op) & 15;
-            state->mode = DISTEXT;
-        case DISTEXT:
-            if (state->extra) {
-                NEEDBITS(state->extra);
-                state->offset += BITS(state->extra);
-                DROPBITS(state->extra);
-            }
+           Tracev((stderr, "inflate:       table sizes ok\n"));
+           state->have = 0;
+           state->mode = LENLENS;
+       case LENLENS:
+           while (state->have < state->ncode) {
+               NEEDBITS(3);
+               state->lens[order[state->have++]] = (unsigned short)BITS(3);
+               DROPBITS(3);
+           }
+           while (state->have < 19)
+               state->lens[order[state->have++]] = 0;
+           state->next = state->codes;
+           state->lencode = (code const FAR *)(state->next);
+           state->lenbits = 7;
+           ret = inflate_table(CODES, state->lens, 19, &(state->next),
+                               &(state->lenbits), state->work);
+           if (ret) {
+               strm->msg = (char *)"invalid code lengths set";
+               state->mode = BAD;
+               break;
+           }
+           Tracev((stderr, "inflate:       code lengths ok\n"));
+           state->have = 0;
+           state->mode = CODELENS;
+       case CODELENS:
+           while (state->have < state->nlen + state->ndist) {
+               for (;;) {
+                   this = state->lencode[BITS(state->lenbits)];
+                   if ((unsigned)(this.bits) <= bits) break;
+                   PULLBYTE();
+               }
+               if (this.val < 16) {
+                   NEEDBITS(this.bits);
+                   DROPBITS(this.bits);
+                   state->lens[state->have++] = this.val;
+               }
+               else {
+                   if (this.val == 16) {
+                       NEEDBITS(this.bits + 2);
+                       DROPBITS(this.bits);
+                       if (state->have == 0) {
+                           strm->msg = (char *)"invalid bit length repeat";
+                           state->mode = BAD;
+                           break;
+                       }
+                       len = state->lens[state->have - 1];
+                       copy = 3 + BITS(2);
+                       DROPBITS(2);
+                   }
+                   else if (this.val == 17) {
+                       NEEDBITS(this.bits + 3);
+                       DROPBITS(this.bits);
+                       len = 0;
+                       copy = 3 + BITS(3);
+                       DROPBITS(3);
+                   }
+                   else {
+                       NEEDBITS(this.bits + 7);
+                       DROPBITS(this.bits);
+                       len = 0;
+                       copy = 11 + BITS(7);
+                       DROPBITS(7);
+                   }
+                   if (state->have + copy > state->nlen + state->ndist) {
+                       strm->msg = (char *)"invalid bit length repeat";
+                       state->mode = BAD;
+                       break;
+                   }
+                   while (copy--)
+                       state->lens[state->have++] = (unsigned short)len;
+               }
+           }
+
+           /* handle error breaks in while */
+           if (state->mode == BAD) break;
+
+           /* build code tables */
+           state->next = state->codes;
+           state->lencode = (code const FAR *)(state->next);
+           state->lenbits = 9;
+           ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+                               &(state->lenbits), state->work);
+           if (ret) {
+               strm->msg = (char *)"invalid literal/lengths set";
+               state->mode = BAD;
+               break;
+           }
+           state->distcode = (code const FAR *)(state->next);
+           state->distbits = 6;
+           ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+                           &(state->next), &(state->distbits), state->work);
+           if (ret) {
+               strm->msg = (char *)"invalid distances set";
+               state->mode = BAD;
+               break;
+           }
+           Tracev((stderr, "inflate:       codes ok\n"));
+           state->mode = LEN;
+       case LEN:
+           if (have >= 6 && left >= 258) {
+               RESTORE();
+               inflate_fast(strm, out);
+               LOAD();
+               break;
+           }
+           for (;;) {
+               this = state->lencode[BITS(state->lenbits)];
+               if ((unsigned)(this.bits) <= bits) break;
+               PULLBYTE();
+           }
+           if (this.op && (this.op & 0xf0) == 0) {
+               last = this;
+               for (;;) {
+                   this = state->lencode[last.val +
+                           (BITS(last.bits + last.op) >> last.bits)];
+                   if ((unsigned)(last.bits + this.bits) <= bits) break;
+                   PULLBYTE();
+               }
+               DROPBITS(last.bits);
+           }
+           DROPBITS(this.bits);
+           state->length = (unsigned)this.val;
+           if ((int)(this.op) == 0) {
+               Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+                       "inflate:         literal '%c'\n" :
+                       "inflate:         literal 0x%02x\n", this.val));
+               state->mode = LIT;
+               break;
+           }
+           if (this.op & 32) {
+               Tracevv((stderr, "inflate:         end of block\n"));
+               state->mode = TYPE;
+               break;
+           }
+           if (this.op & 64) {
+               strm->msg = (char *)"invalid literal/length code";
+               state->mode = BAD;
+               break;
+           }
+           state->extra = (unsigned)(this.op) & 15;
+           state->mode = LENEXT;
+       case LENEXT:
+           if (state->extra) {
+               NEEDBITS(state->extra);
+               state->length += BITS(state->extra);
+               DROPBITS(state->extra);
+           }
+           Tracevv((stderr, "inflate:         length %u\n", state->length));
+           state->mode = DIST;
+       case DIST:
+           for (;;) {
+               this = state->distcode[BITS(state->distbits)];
+               if ((unsigned)(this.bits) <= bits) break;
+               PULLBYTE();
+           }
+           if ((this.op & 0xf0) == 0) {
+               last = this;
+               for (;;) {
+                   this = state->distcode[last.val +
+                           (BITS(last.bits + last.op) >> last.bits)];
+                   if ((unsigned)(last.bits + this.bits) <= bits) break;
+                   PULLBYTE();
+               }
+               DROPBITS(last.bits);
+           }
+           DROPBITS(this.bits);
+           if (this.op & 64) {
+               strm->msg = (char *)"invalid distance code";
+               state->mode = BAD;
+               break;
+           }
+           state->offset = (unsigned)this.val;
+           state->extra = (unsigned)(this.op) & 15;
+           state->mode = DISTEXT;
+       case DISTEXT:
+           if (state->extra) {
+               NEEDBITS(state->extra);
+               state->offset += BITS(state->extra);
+               DROPBITS(state->extra);
+           }
 #ifdef INFLATE_STRICT
-            if (state->offset > state->dmax) {
-                strm->msg = (char *)"invalid distance too far back";
-                state->mode = BAD;
-                break;
-            }
+           if (state->offset > state->dmax) {
+               strm->msg = (char *)"invalid distance too far back";
+               state->mode = BAD;
+               break;
+           }
 #endif
-            if (state->offset > state->whave + out - left) {
-                strm->msg = (char *)"invalid distance too far back";
-                state->mode = BAD;
-                break;
-            }
-            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
-            state->mode = MATCH;
-        case MATCH:
-            if (left == 0) goto inf_leave;
-            copy = out - left;
-            if (state->offset > copy) {         /* copy from window */
-                copy = state->offset - copy;
-                if (copy > state->write) {
-                    copy -= state->write;
-                    from = state->window + (state->wsize - copy);
-                }
-                else
-                    from = state->window + (state->write - copy);
-                if (copy > state->length) copy = state->length;
-            }
-            else {                              /* copy from output */
-                from = put - state->offset;
-                copy = state->length;
-            }
-            if (copy > left) copy = left;
-            left -= copy;
-            state->length -= copy;
-            do {
-                *put++ = *from++;
-            } while (--copy);
-            if (state->length == 0) state->mode = LEN;
-            break;
-        case LIT:
-            if (left == 0) goto inf_leave;
-            *put++ = (unsigned char)(state->length);
-            left--;
-            state->mode = LEN;
-            break;
-        case CHECK:
-            if (state->wrap) {
-                NEEDBITS(32);
-                out -= left;
-                strm->total_out += out;
-                state->total += out;
-                if (out)
-                    strm->adler = state->check =
-                        UPDATE(state->check, put - out, out);
-                out = left;
-                if ((
+           if (state->offset > state->whave + out - left) {
+               strm->msg = (char *)"invalid distance too far back";
+               state->mode = BAD;
+               break;
+           }
+           Tracevv((stderr, "inflate:         distance %u\n", state->offset));
+           state->mode = MATCH;
+       case MATCH:
+           if (left == 0) goto inf_leave;
+           copy = out - left;
+           if (state->offset > copy) {         /* copy from window */
+               copy = state->offset - copy;
+               if (copy > state->write) {
+                   copy -= state->write;
+                   from = state->window + (state->wsize - copy);
+               }
+               else
+                   from = state->window + (state->write - copy);
+               if (copy > state->length) copy = state->length;
+           }
+           else {                              /* copy from output */
+               from = put - state->offset;
+               copy = state->length;
+           }
+           if (copy > left) copy = left;
+           left -= copy;
+           state->length -= copy;
+           do {
+               *put++ = *from++;
+           } while (--copy);
+           if (state->length == 0) state->mode = LEN;
+           break;
+       case LIT:
+           if (left == 0) goto inf_leave;
+           *put++ = (unsigned char)(state->length);
+           left--;
+           state->mode = LEN;
+           break;
+       case CHECK:
+           if (state->wrap) {
+               NEEDBITS(32);
+               out -= left;
+               strm->total_out += out;
+               state->total += out;
+               if (out)
+                   strm->adler = state->check =
+                       UPDATE(state->check, put - out, out);
+               out = left;
+               if ((
 #ifdef GUNZIP
-                     state->flags ? hold :
+                    state->flags ? hold :
 #endif
-                     REVERSE(hold)) != state->check) {
-                    strm->msg = (char *)"incorrect data check";
-                    state->mode = BAD;
-                    break;
-                }
-                INITBITS();
-                Tracev((stderr, "inflate:   check matches trailer\n"));
-            }
+                    REVERSE(hold)) != state->check) {
+                   strm->msg = (char *)"incorrect data check";
+                   state->mode = BAD;
+                   break;
+               }
+               INITBITS();
+               Tracev((stderr, "inflate:   check matches trailer\n"));
+           }
 #ifdef GUNZIP
-            state->mode = LENGTH;
-        case LENGTH:
-            if (state->wrap && state->flags) {
-                NEEDBITS(32);
-                if (hold != (state->total & 0xffffffffUL)) {
-                    strm->msg = (char *)"incorrect length check";
-                    state->mode = BAD;
-                    break;
-                }
-                INITBITS();
-                Tracev((stderr, "inflate:   length matches trailer\n"));
-            }
+           state->mode = LENGTH;
+       case LENGTH:
+           if (state->wrap && state->flags) {
+               NEEDBITS(32);
+               if (hold != (state->total & 0xffffffffUL)) {
+                   strm->msg = (char *)"incorrect length check";
+                   state->mode = BAD;
+                   break;
+               }
+               INITBITS();
+               Tracev((stderr, "inflate:   length matches trailer\n"));
+           }
 #endif
-            state->mode = DONE;
-        case DONE:
-            ret = Z_STREAM_END;
-            goto inf_leave;
-        case BAD:
-            ret = Z_DATA_ERROR;
-            goto inf_leave;
-        case MEM:
-            return Z_MEM_ERROR;
-        case SYNC:
-        default:
-            return Z_STREAM_ERROR;
-        }
+           state->mode = DONE;
+       case DONE:
+           ret = Z_STREAM_END;
+           goto inf_leave;
+       case BAD:
+           ret = Z_DATA_ERROR;
+           goto inf_leave;
+       case MEM:
+           return Z_MEM_ERROR;
+       case SYNC:
+       default:
+           return Z_STREAM_ERROR;
+       }
 
     /*
        Return from inflate(), updating the total counts and the check value.
@@ -1924,22 +1924,22 @@ int flush;
   inf_leave:
     RESTORE();
     if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
-        if (updatewindow(strm, out)) {
-            state->mode = MEM;
-            return Z_MEM_ERROR;
-        }
+       if (updatewindow(strm, out)) {
+           state->mode = MEM;
+           return Z_MEM_ERROR;
+       }
     in -= strm->avail_in;
     out -= strm->avail_out;
     strm->total_in += in;
     strm->total_out += out;
     state->total += out;
     if (state->wrap && out)
-        strm->adler = state->check =
-            UPDATE(state->check, strm->next_out - out, out);
+       strm->adler = state->check =
+           UPDATE(state->check, strm->next_out - out, out);
     strm->data_type = state->bits + (state->last ? 64 : 0) +
-                      (state->mode == TYPE ? 128 : 0);
+                     (state->mode == TYPE ? 128 : 0);
     if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
-        ret = Z_BUF_ERROR;
+       ret = Z_BUF_ERROR;
     return ret;
 }
 
@@ -1948,7 +1948,7 @@ z_streamp strm;
 {
     struct inflate_state FAR *state;
     if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
-        return Z_STREAM_ERROR;
+       return Z_STREAM_ERROR;
     state = (struct inflate_state FAR *)strm->state;
     if (state->window != Z_NULL) ZFREE(strm, state->window);
     ZFREE(strm, strm->state);
@@ -2119,56 +2119,56 @@ uLong ZEXPORT adler32(adler, buf, len)
 
     /* in case user likes doing a byte at a time, keep it fast */
     if (len == 1) {
-        adler += buf[0];
-        if (adler >= BASE)
-            adler -= BASE;
-        sum2 += adler;
-        if (sum2 >= BASE)
-            sum2 -= BASE;
-        return adler | (sum2 << 16);
+       adler += buf[0];
+       if (adler >= BASE)
+           adler -= BASE;
+       sum2 += adler;
+       if (sum2 >= BASE)
+           sum2 -= BASE;
+       return adler | (sum2 << 16);
     }
 
     /* initial Adler-32 value (deferred check for len == 1 speed) */
     if (buf == Z_NULL)
-        return 1L;
+       return 1L;
 
     /* in case short lengths are provided, keep it somewhat fast */
     if (len < 16) {
-        while (len--) {
-            adler += *buf++;
-            sum2 += adler;
-        }
-        if (adler >= BASE)
-            adler -= BASE;
-        MOD4(sum2);             /* only added so many BASE's */
-        return adler | (sum2 << 16);
+       while (len--) {
+           adler += *buf++;
+           sum2 += adler;
+       }
+       if (adler >= BASE)
+           adler -= BASE;
+       MOD4(sum2);             /* only added so many BASE's */
+       return adler | (sum2 << 16);
     }
 
     /* do length NMAX blocks -- requires just one modulo operation */
     while (len >= NMAX) {
-        len -= NMAX;
-        n = NMAX / 16;          /* NMAX is divisible by 16 */
-        do {
-            DO16(buf);          /* 16 sums unrolled */
-            buf += 16;
-        } while (--n);
-        MOD(adler);
-        MOD(sum2);
+       len -= NMAX;
+       n = NMAX / 16;          /* NMAX is divisible by 16 */
+       do {
+           DO16(buf);          /* 16 sums unrolled */
+           buf += 16;
+       } while (--n);
+       MOD(adler);
+       MOD(sum2);
     }
 
     /* do remaining bytes (less than NMAX, still just one modulo) */
     if (len) {                  /* avoid modulos if none remaining */
-        while (len >= 16) {
-            len -= 16;
-            DO16(buf);
-            buf += 16;
-        }
-        while (len--) {
-            adler += *buf++;
-            sum2 += adler;
-        }
-        MOD(adler);
-        MOD(sum2);
+       while (len >= 16) {
+           len -= 16;
+           DO16(buf);
+           buf += 16;
+       }
+       while (len--) {
+           adler += *buf++;
+           sum2 += adler;
+       }
+       MOD(adler);
+       MOD(sum2);
     }
 
     /* return recombined sums */
index f25c3f8c247c937fe128d75224f822da347e3bcf..bb3e3f54e05d03f3f8799cc65a376d2788350188 100644 (file)
--- a/net/dns.c
+++ b/net/dns.c
@@ -208,4 +208,3 @@ DnsStart(void)
 
        DnsSend();
 }
-