zlib-streams 1.0.5 → 1.0.7

package/src/inflate9.c

@@ -1,859 +0,0 @@
-/* inflate9.c -- zlib decompression
- * Copyright (C) 2025 Gildas Lormeau (inflate9.c) - 1995-2022 Mark Adler (zlib)
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "zutil.h"
-#include "inftree9.h"
-#include "inflate.h"
-
-#ifdef MAKEFIXED
-#ifndef BUILDFIXED
-#define BUILDFIXED
-#endif
-#endif
-
-extern int ZEXPORT inflate9Init2_(z_streamp strm, int windowBits,
-                                  const char *version, int stream_size);
-
-int ZEXPORT inflate9Init(z_streamp strm) {
-  return inflate9Init2_(strm, 16, ZLIB_VERSION, (int)sizeof(z_stream));
-}
-
-local int inflateStateCheck(z_streamp strm) {
-  struct inflate_state FAR *state;
-  if (strm == Z_NULL || strm->zalloc == (alloc_func)0 ||
-      strm->zfree == (free_func)0)
-    return 1;
-  state = (struct inflate_state FAR *)strm->state;
-  if (state == Z_NULL || state->strm != strm || state->mode < TYPE ||
-      state->mode > BAD)
-    return 1;
-  return 0;
-}
-
-int ZEXPORT inflate9ResetKeep(z_streamp strm) {
-  struct inflate_state FAR *state;
-
-  if (inflateStateCheck(strm))
-    return Z_STREAM_ERROR;
-  state = (struct inflate_state FAR *)strm->state;
-  strm->total_in = strm->total_out = state->total = 0;
-  strm->msg = Z_NULL;
-  if (state->wrap) /* to support ill-conceived Java test suite */
-    strm->adler = state->wrap & 1;
-  state->mode = TYPE;
-  state->last = 0;
-  state->havedict = 0;
-  state->flags = -1;
-  state->dmax = 65536U;
-  state->head = Z_NULL;
-  state->hold = 0;
-  state->bits = 0;
-  state->lencode = state->distcode = state->next = state->codes;
-  state->sane = 1;
-  state->back = -1;
-  Tracev((stderr, "inflate: reset\n"));
-  return Z_OK;
-}
-
-int ZEXPORT inflate9Reset(z_streamp strm) {
-  struct inflate_state FAR *state;
-
-  if (inflateStateCheck(strm))
-    return Z_STREAM_ERROR;
-  state = (struct inflate_state FAR *)strm->state;
-  state->wsize = 0;
-  state->whave = 0;
-  state->wnext = 0;
-  return inflate9ResetKeep(strm);
-}
-
-int ZEXPORT inflate9Reset2(z_streamp strm, int windowBits) {
-  int wrap;
-  struct inflate_state FAR *state;
-
-  /* get the state */
-  if (inflateStateCheck(strm))
-    return Z_STREAM_ERROR;
-  state = (struct inflate_state FAR *)strm->state;
-
-  /* extract wrap request from windowBits parameter */
-  if (windowBits < 0) {
-    if (windowBits < -16)
-      return Z_STREAM_ERROR;
-    wrap = 0;
-    windowBits = -windowBits;
-  } else {
-    wrap = (windowBits >> 4) + 5;
-  }
-
-  /* set number of window bits, free window if different */
-  if (windowBits && (windowBits < 8 || windowBits > 16))
-    return Z_STREAM_ERROR;
-  if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
-    ZFREE(strm, state->window);
-    state->window = Z_NULL;
-  }
-
-  /* update state and reset the rest of it */
-  state->wrap = wrap;
-  state->wbits = (unsigned)windowBits;
-  return inflate9Reset(strm);
-}
-
-int ZEXPORT inflate9Init2_(z_streamp strm, int windowBits, const char *version,
-                           int stream_size) {
-  int ret;
-  struct inflate_state FAR *state;
-
-  if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
-      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) {
-#ifdef Z_SOLO
-    return Z_STREAM_ERROR;
-#else
-    strm->zalloc = zcalloc;
-    strm->opaque = (voidpf)0;
-#endif
-  }
-  if (strm->zfree == (free_func)0)
-#ifdef Z_SOLO
-    return Z_STREAM_ERROR;
-#else
-    strm->zfree = zcfree;
-#endif
-  state =
-      (struct inflate_state FAR *)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;
-  state->strm = strm;
-  state->window = Z_NULL;
-  state->mode = TYPE; /* to pass state test in inflate9Reset2() */
-  ret = inflate9Reset2(strm, windowBits);
-  if (ret != Z_OK) {
-    ZFREE(strm, state);
-    strm->state = Z_NULL;
-  }
-  return ret;
-}
-
-int ZEXPORT inflate9Init_(z_streamp strm, const char *version,
-                          int stream_size) {
-  return inflate9Init2_(strm, DEF_WBITS, version, stream_size);
-}
-
-/*
-   Return state with length and distance decoding tables and index sizes set to
-   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
-   If BUILDFIXED is defined, then instead this routine builds the tables the
-   first time it's called, and returns those tables the first time and
-   thereafter.  This reduces the size of the code by about 2K bytes, in
-   exchange for a little execution time.  However, BUILDFIXED should not be
-   used for threaded applications, since the rewriting of the tables and virgin
-   may not be thread-safe.
- */
-local void fixedtables(struct inflate_state FAR *state) {
-#ifdef BUILDFIXED
-  static int virgin = 1;
-  static code *lenfix, *distfix;
-  static code fixed[544];
-
-  /* build fixed huffman tables if first call (may not be thread safe) */
-  if (virgin) {
-    unsigned sym, bits;
-    static code *next;
-
-    /* literal/length table */
-    sym = 0;
-    while (sym < 144)
-      state->lens[sym++] = 8;
-    while (sym < 256)
-      state->lens[sym++] = 9;
-    while (sym < 280)
-      state->lens[sym++] = 7;
-    while (sym < 288)
-      state->lens[sym++] = 8;
-    next = fixed;
-    lenfix = next;
-    bits = 9;
-    inflate_table9(LENS, state->lens, 288, &(next), &(bits), state->work);
-
-    /* distance table */
-    sym = 0;
-    while (sym < 32)
-      state->lens[sym++] = 5;
-    distfix = next;
-    bits = 5;
-    inflate_table9(DISTS, state->lens, 32, &(next), &(bits), state->work);
-
-    /* do this just once */
-    virgin = 0;
-  }
-#else /* !BUILDFIXED */
-#include "inffixed.h"
-#endif /* BUILDFIXED */
-  state->lencode = lenfix;
-  state->lenbits = 9;
-  state->distcode = distfix;
-  state->distbits = 5;
-}
-
-/*
-   Update the window with the last wsize (normally 32K) bytes written before
-   returning.  If window does not exist yet, create it.  This is only called
-   when a window is already in use, or when output has been written during this
-   inflate call, but the end of the deflate stream has not been reached yet.
-   It is also called to create a window for dictionary data when a dictionary
-   is loaded.
-
-   Providing output buffers larger than 32K to inflate() should provide a speed
-   advantage, since only the last 32K of output is copied to the sliding window
-   upon return from inflate(), and since all distances after the first 32K of
-   output will fall in the output data, making match copies simpler and faster.
-   The advantage may be dependent on the size of the processor's data caches.
- */
-local int updatewindow(z_streamp strm, const Bytef *end, unsigned copy) {
-  struct inflate_state FAR *state;
-  unsigned dist;
-
-  state = (struct inflate_state FAR *)strm->state;
-
-  /* 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;
-  }
-
-  /* if window not in use yet, initialize */
-  if (state->wsize == 0) {
-    state->wsize = 1U << state->wbits;
-    state->wnext = 0;
-    state->whave = 0;
-  }
-
-  /* copy state->wsize or less output bytes into the circular window */
-  if (copy >= state->wsize) {
-    zmemcpy(state->window, end - state->wsize, state->wsize);
-    state->wnext = 0;
-    state->whave = state->wsize;
-  } else {
-    dist = state->wsize - state->wnext;
-    if (dist > copy)
-      dist = copy;
-    zmemcpy(state->window + state->wnext, end - copy, dist);
-    copy -= dist;
-    if (copy) {
-      zmemcpy(state->window, end - copy, copy);
-      state->wnext = copy;
-      state->whave = state->wsize;
-    } else {
-      state->wnext += dist;
-      if (state->wnext == state->wsize)
-        state->wnext = 0;
-      if (state->whave < state->wsize)
-        state->whave += dist;
-    }
-  }
-  return 0;
-}
-
-/* Load registers with state in inflate() for speed */
-#define LOAD()                                                                 \
-  do {                                                                         \
-    put = strm->next_out;                                                      \
-    left = strm->avail_out;                                                    \
-    next = strm->next_in;                                                      \
-    have = strm->avail_in;                                                     \
-    hold = state->hold;                                                        \
-    bits = state->bits;                                                        \
-  } while (0)
-
-/* Restore state from registers in inflate() */
-#define RESTORE()                                                              \
-  do {                                                                         \
-    strm->next_out = put;                                                      \
-    strm->avail_out = left;                                                    \
-    strm->next_in = next;                                                      \
-    strm->avail_in = have;                                                     \
-    state->hold = hold;                                                        \
-    state->bits = bits;                                                        \
-  } while (0)
-
-/* Clear the input bit accumulator */
-#define INITBITS()                                                             \
-  do {                                                                         \
-    hold = 0;                                                                  \
-    bits = 0;                                                                  \
-  } while (0)
-
-/* Get a byte of input into the bit accumulator, or return from inflate()
-   if there is no input available. */
-#define PULLBYTE()                                                             \
-  do {                                                                         \
-    if (have == 0)                                                             \
-      goto inf_leave;                                                          \
-    have--;                                                                    \
-    hold += (unsigned long)(*next++) << bits;                                  \
-    bits += 8;                                                                 \
-  } while (0)
-
-/* Assure that there are at least n bits in the bit accumulator.  If there is
-   not enough available input to do that, then return from inflate(). */
-#define NEEDBITS(n)                                                            \
-  do {                                                                         \
-    while (bits < (unsigned)(n))                                               \
-      PULLBYTE();                                                              \
-  } while (0)
-
-/* Return the low n bits of the bit accumulator (n < 16) */
-#define BITS(n) ((unsigned)hold & ((1U << (n)) - 1))
-
-/* Remove n bits from the bit accumulator */
-#define DROPBITS(n)                                                            \
-  do {                                                                         \
-    hold >>= (n);                                                              \
-    bits -= (unsigned)(n);                                                     \
-  } while (0)
-
-/* Remove zero to seven bits as needed to go to a byte boundary */
-#define BYTEBITS()                                                             \
-  do {                                                                         \
-    hold >>= bits & 7;                                                         \
-    bits -= bits & 7;                                                          \
-  } while (0)
-
-/*
-   inflate() uses a state machine to process as much input data and generate as
-   much output data as possible before returning.  The state machine is
-   structured roughly as follows:
-
-    for (;;) switch (state) {
-    ...
-    case STATEn:
-        if (not enough input data or output space to make progress)
-            return;
-        ... make progress ...
-        state = STATEm;
-        break;
-    ...
-    }
-
-   so when inflate() is called again, the same case is attempted again, and
-   if the appropriate resources are provided, the machine proceeds to the
-   next state.  The NEEDBITS() macro is usually the way the state evaluates
-   whether it can proceed or should return.  NEEDBITS() does the return if
-   the requested bits are not available.  The typical use of the BITS macros
-   is:
-
-        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)
-   gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
-   the low n bits off the accumulator.  INITBITS() clears the accumulator
-   and sets the number of available bits to zero.  BYTEBITS() discards just
-   enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
-   and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
-
-   NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
-   if there is no input available.  The decoding of variable length codes uses
-   PULLBYTE() directly in order to pull just enough bytes to decode the next
-   code, and no more.
-
-   Some states loop until they get enough input, making sure that enough
-   state information is maintained to continue the loop where it left off
-   if NEEDBITS() returns in the loop.  For example, want, need, and keep
-   would all have to actually be part of the saved state in case NEEDBITS()
-   returns:
-
-    case STATEw:
-        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
-   is omitted.
-
-   A state may also return if there is not enough output space available to
-   complete that state.  Those states are copying stored data, writing a
-   literal byte, and copying a matching string.
-
-   When returning, a "goto inf_leave" is used to update the total counters,
-   update the check value, and determine whether any progress has been made
-   during that inflate() call in order to return the proper return code.
-   Progress is defined as a change in either strm->avail_in or strm->avail_out.
-   When there is a window, goto inf_leave will update the window with the last
-   output written.  If a goto inf_leave occurs in the middle of decompression
-   and there is no window currently, goto inf_leave will create one and copy
-   output to the window for the next call of inflate().
-
-   In this implementation, the flush parameter of inflate() only affects the
-   return code (per zlib.h).  inflate() always writes as much as possible to
-   strm->next_out, given the space available and the provided input--the effect
-   documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
-   the allocation of and copying into a sliding window until necessary, which
-   provides the effect documented in zlib.h for Z_FINISH when the entire input
-   stream available.  So the only thing the flush parameter actually does is:
-   when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
-   will return Z_BUF_ERROR if it has not reached the end of the stream.
- */
-
-int ZEXPORT inflate9(z_streamp strm, int flush) {
-  struct inflate_state FAR *state;
-  z_const unsigned char FAR *next; /* next input */
-  unsigned char FAR *put;          /* next output */
-  unsigned have, left;             /* available input and output */
-  unsigned long hold;              /* bit buffer */
-  unsigned bits;                   /* bits in bit buffer */
-  unsigned in, out;        /* save starting available input and output */
-  unsigned copy;           /* number of stored or match bytes to copy */
-  unsigned char FAR *from; /* where to copy match bytes from */
-  code here;               /* current decoding table entry */
-  code last;               /* parent table entry */
-  unsigned len;            /* length to copy for repeats, bits to drop */
-  int ret;                 /* return code */
-  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};
-
-  if (inflateStateCheck(strm) || strm->next_out == Z_NULL ||
-      (strm->next_in == Z_NULL && strm->avail_in != 0))
-    return Z_STREAM_ERROR;
-
-  state = (struct inflate_state FAR *)strm->state;
-  LOAD();
-  in = have;
-  out = left;
-  ret = Z_OK;
-  for (;;)
-    switch (state->mode) {
-    case TYPE:
-      if (flush == Z_BLOCK || flush == Z_TREES)
-        goto inf_leave;
-      /* fallthrough */
-    case TYPEDO:
-      if (state->last) {
-        BYTEBITS();
-        state->mode = DONE;
-        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 */
-        if (flush == Z_TREES) {
-          DROPBITS(2);
-          goto inf_leave;
-        }
-        break;
-      case 2: /* dynamic block */
-        Tracev((stderr, "inflate:     dynamic codes block%s\n",
-                state->last ? " (last)" : ""));
-        state->mode = TABLE;
-        break;
-      case 3:
-        strm->msg = (z_const 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 = (z_const 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_;
-      if (flush == Z_TREES)
-        goto inf_leave;
-      /* fallthrough */
-    case COPY_:
-      state->mode = COPY;
-      /* fallthrough */
-    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) {
-        strm->msg = (z_const char *)"too many length symbols";
-        state->mode = BAD;
-        break;
-      }
-#endif
-      Tracev((stderr, "inflate:       table sizes ok\n"));
-      state->have = 0;
-      state->mode = LENLENS;
-      /* fallthrough */
-    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 = state->distcode = (const code FAR *)(state->next);
-      state->lenbits = 7;
-      ret = inflate_table9(CODES, state->lens, 19, &(state->next),
-                           &(state->lenbits), state->work);
-      if (ret) {
-        strm->msg = (z_const char *)"invalid code lengths set";
-        state->mode = BAD;
-        break;
-      }
-      Tracev((stderr, "inflate:       code lengths ok\n"));
-      state->have = 0;
-      state->mode = CODELENS;
-      /* fallthrough */
-    case CODELENS:
-      while (state->have < state->nlen + state->ndist) {
-        for (;;) {
-          here = state->lencode[BITS(state->lenbits)];
-          if ((unsigned)(here.bits) <= bits)
-            break;
-          PULLBYTE();
-        }
-        if (here.val < 16) {
-          DROPBITS(here.bits);
-          state->lens[state->have++] = here.val;
-        } else {
-          if (here.val == 16) {
-            NEEDBITS(here.bits + 2);
-            DROPBITS(here.bits);
-            if (state->have == 0) {
-              strm->msg = (z_const char *)"invalid bit length repeat";
-              state->mode = BAD;
-              break;
-            }
-            len = state->lens[state->have - 1];
-            copy = 3 + BITS(2);
-            DROPBITS(2);
-          } else if (here.val == 17) {
-            NEEDBITS(here.bits + 3);
-            DROPBITS(here.bits);
-            len = 0;
-            copy = 3 + BITS(3);
-            DROPBITS(3);
-          } else {
-            NEEDBITS(here.bits + 7);
-            DROPBITS(here.bits);
-            len = 0;
-            copy = 11 + BITS(7);
-            DROPBITS(7);
-          }
-          if (state->have + copy > state->nlen + state->ndist) {
-            strm->msg = (z_const 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;
-
-      /* check for end-of-block code (better have one) */
-      if (state->lens[256] == 0) {
-        strm->msg = (z_const char *)"invalid code -- missing end-of-block";
-        state->mode = BAD;
-        break;
-      }
-
-      /* build code tables -- note: do not change the lenbits or distbits
-         values here (9 and 6) without reading the comments in inftrees.h
-         concerning the ENOUGH constants, which depend on those values */
-      state->next = state->codes;
-      state->lencode = (const code FAR *)(state->next);
-      state->lenbits = 9;
-      ret = inflate_table9(LENS, state->lens, state->nlen, &(state->next),
-                           &(state->lenbits), state->work);
-      if (ret) {
-        strm->msg = (z_const char *)"invalid literal/lengths set";
-        state->mode = BAD;
-        break;
-      }
-      state->distcode = (const code FAR *)(state->next);
-      state->distbits = 6;
-      ret = inflate_table9(DISTS, state->lens + state->nlen, state->ndist,
-                           &(state->next), &(state->distbits), state->work);
-      if (ret) {
-        strm->msg = (z_const char *)"invalid distances set";
-        state->mode = BAD;
-        break;
-      }
-      Tracev((stderr, "inflate:       codes ok\n"));
-      state->mode = LEN_;
-      if (flush == Z_TREES)
-        goto inf_leave;
-      /* fallthrough */
-    case LEN_:
-      state->mode = LEN;
-      /* fallthrough */
-    case LEN:
-      state->back = 0;
-      for (;;) {
-        here = state->lencode[BITS(state->lenbits)];
-        if ((unsigned)(here.bits) <= bits)
-          break;
-        PULLBYTE();
-      }
-      if (here.op && (here.op & 0xf0) == 0) {
-        last = here;
-        for (;;) {
-          here = state->lencode[last.val +
-                                (BITS(last.bits + last.op) >> last.bits)];
-          if ((unsigned)(last.bits + here.bits) <= bits)
-            break;
-          PULLBYTE();
-        }
-        DROPBITS(last.bits);
-        state->back += last.bits;
-      }
-      DROPBITS(here.bits);
-      state->back += here.bits;
-      state->length = (unsigned)here.val;
-      if ((int)(here.op) == 0) {
-        Tracevv((stderr,
-                 here.val >= 0x20 && here.val < 0x7f
-                     ? "inflate:         literal '%c'\n"
-                     : "inflate:         literal 0x%02x\n",
-                 here.val));
-        state->mode = LIT;
-        break;
-      }
-      if (here.op & 32) {
-        Tracevv((stderr, "inflate:         end of block\n"));
-        state->back = -1;
-        state->mode = TYPE;
-        break;
-      }
-      if (here.op & 64) {
-        strm->msg = (z_const char *)"invalid literal/length code";
-        state->mode = BAD;
-        break;
-      }
-      state->extra = (unsigned)(here.op) & 31;
-      state->mode = LENEXT;
-      /* fallthrough */
-    case LENEXT:
-      if (state->extra) {
-        NEEDBITS(state->extra);
-        state->length += BITS(state->extra);
-        DROPBITS(state->extra);
-        state->back += state->extra;
-      }
-      Tracevv((stderr, "inflate:         length %u\n", state->length));
-      state->was = state->length;
-      state->mode = DIST;
-      /* fallthrough */
-    case DIST:
-      for (;;) {
-        here = state->distcode[BITS(state->distbits)];
-        if ((unsigned)(here.bits) <= bits)
-          break;
-        PULLBYTE();
-      }
-      if ((here.op & 0xf0) == 0) {
-        last = here;
-        for (;;) {
-          here = state->distcode[last.val +
-                                 (BITS(last.bits + last.op) >> last.bits)];
-          if ((unsigned)(last.bits + here.bits) <= bits)
-            break;
-          PULLBYTE();
-        }
-        DROPBITS(last.bits);
-        state->back += last.bits;
-      }
-      DROPBITS(here.bits);
-      state->back += here.bits;
-      if (here.op & 64) {
-        strm->msg = (z_const char *)"invalid distance code";
-        state->mode = BAD;
-        break;
-      }
-      state->offset = (unsigned)here.val;
-      state->extra = (unsigned)(here.op) & 15;
-      state->mode = DISTEXT;
-      /* fallthrough */
-    case DISTEXT:
-      if (state->extra) {
-        NEEDBITS(state->extra);
-        state->offset += BITS(state->extra);
-        DROPBITS(state->extra);
-        state->back += state->extra;
-      }
-#ifdef INFLATE_STRICT
-      if (state->offset > state->dmax) {
-        strm->msg = (z_const char *)"invalid distance too far back";
-        state->mode = BAD;
-        break;
-      }
-#endif
-      Tracevv((stderr, "inflate:         distance %u\n", state->offset));
-      state->mode = MATCH;
-      /* fallthrough */
-    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->whave) {
-          if (state->sane) {
-            strm->msg = (z_const char *)"invalid distance too far back";
-            state->mode = BAD;
-            break;
-          }
-#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
-          Trace((stderr, "inflate9.c too far\n"));
-          copy -= state->whave;
-          if (copy > state->length)
-            copy = state->length;
-          if (copy > left)
-            copy = left;
-          left -= copy;
-          state->length -= copy;
-          do {
-            *put++ = 0;
-          } while (--copy);
-          if (state->length == 0)
-            state->mode = LEN;
-          break;
-#endif
-        }
-        if (copy > state->wnext) {
-          copy -= state->wnext;
-          from = state->window + (state->wsize - copy);
-        } else
-          from = state->window + (state->wnext - 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 DONE:
-      ret = Z_STREAM_END;
-      goto inf_leave;
-    case BAD:
-      ret = Z_DATA_ERROR;
-      goto inf_leave;
-    default:
-      return Z_STREAM_ERROR;
-    }
-
-  /*
-    Return from inflate9(), updating the total counts and the check value.
-    If there was no progress during the inflate9() call, return a buffer
-    error.  Call updatewindow() to create and/or update the window state.
-    Note: a memory error from inflate9() is non-recoverable.
-  */
-inf_leave:
-  RESTORE();
-  if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
-                       (state->mode < DONE || flush != Z_FINISH)))
-    if (updatewindow(strm, strm->next_out, out - strm->avail_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;
-  strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
-                    (state->mode == TYPE ? 128 : 0) +
-                    (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
-  if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
-    ret = Z_BUF_ERROR;
-  return ret;
-}
-
-int ZEXPORT inflate9End(z_streamp strm) {
-  struct inflate_state FAR *state;
-  if (inflateStateCheck(strm))
-    return Z_STREAM_ERROR;
-  state = (struct inflate_state FAR *)strm->state;
-  if (state->window != Z_NULL)
-    ZFREE(strm, state->window);
-  ZFREE(strm, strm->state);
-  strm->state = Z_NULL;
-  Tracev((stderr, "inflate: end\n"));
-  return Z_OK;
-}