Inflater.java 22 KB
Newer Older
Tom Tromey committed
1 2 3 4 5 6 7 8 9
/* Inflater.java - Decompress a data stream
   Copyright (C) 1999, 2000, 2001, 2003, 2005  Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
10

Tom Tromey committed
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */

package java.util.zip;

/* Written using on-line Java Platform 1.2 API Specification
 * and JCL book.
 * Believed complete and correct.
 */

/**
46
 * Inflater is used to decompress data that has been compressed according
Tom Tromey committed
47 48 49 50 51 52 53
 * to the "deflate" standard described in rfc1950.
 *
 * The usage is as following.  First you have to set some input with
 * <code>setInput()</code>, then inflate() it.  If inflate doesn't
 * inflate any bytes there may be three reasons:
 * <ul>
 * <li>needsInput() returns true because the input buffer is empty.
54
 * You have to provide more input with <code>setInput()</code>.
Tom Tromey committed
55 56
 * NOTE: needsInput() also returns true when, the stream is finished.
 * </li>
57
 * <li>needsDictionary() returns true, you have to provide a preset
Tom Tromey committed
58 59 60 61 62 63 64 65 66 67 68 69 70 71
 *     dictionary with <code>setDictionary()</code>.</li>
 * <li>finished() returns true, the inflater has finished.</li>
 * </ul>
 * Once the first output byte is produced, a dictionary will not be
 * needed at a later stage.
 *
 * @author John Leuner, Jochen Hoenicke
 * @author Tom Tromey
 * @date May 17, 1999
 * @since JDK 1.1
 */
public class Inflater
{
  /* Copy lengths for literal codes 257..285 */
72 73
  private static final int CPLENS[] =
  {
Tom Tromey committed
74 75 76
    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
  };
77 78 79 80

  /* Extra bits for literal codes 257..285 */
  private static final int CPLEXT[] =
  {
Tom Tromey committed
81 82 83 84 85 86 87 88 89 90
    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
    3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
  };

  /* Copy offsets for distance codes 0..29 */
  private static final int CPDIST[] = {
    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
  };
91

Tom Tromey committed
92 93 94
  /* Extra bits for distance codes */
  private static final int CPDEXT[] = {
    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
95
    7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
Tom Tromey committed
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
    12, 12, 13, 13
  };

  /* This are the state in which the inflater can be.  */
  private static final int DECODE_HEADER           = 0;
  private static final int DECODE_DICT             = 1;
  private static final int DECODE_BLOCKS           = 2;
  private static final int DECODE_STORED_LEN1      = 3;
  private static final int DECODE_STORED_LEN2      = 4;
  private static final int DECODE_STORED           = 5;
  private static final int DECODE_DYN_HEADER       = 6;
  private static final int DECODE_HUFFMAN          = 7;
  private static final int DECODE_HUFFMAN_LENBITS  = 8;
  private static final int DECODE_HUFFMAN_DIST     = 9;
  private static final int DECODE_HUFFMAN_DISTBITS = 10;
  private static final int DECODE_CHKSUM           = 11;
  private static final int FINISHED                = 12;

  /** This variable contains the current state. */
  private int mode;

  /**
   * The adler checksum of the dictionary or of the decompressed
   * stream, as it is written in the header resp. footer of the
   * compressed stream.  <br>
   *
   * Only valid if mode is DECODE_DICT or DECODE_CHKSUM.
   */
  private int readAdler;
125
  /**
Tom Tromey committed
126 127
   * The number of bits needed to complete the current state.  This
   * is valid, if mode is DECODE_DICT, DECODE_CHKSUM,
128
   * DECODE_HUFFMAN_LENBITS or DECODE_HUFFMAN_DISTBITS.
Tom Tromey committed
129 130 131 132 133 134 135
   */
  private int neededBits;
  private int repLength, repDist;
  private int uncomprLen;
  /**
   * True, if the last block flag was set in the last block of the
   * inflated stream.  This means that the stream ends after the
136
   * current block.
Tom Tromey committed
137 138 139 140 141 142
   */
  private boolean isLastBlock;

  /**
   * The total number of inflated bytes.
   */
143
  private long totalOut;
Tom Tromey committed
144 145
  /**
   * The total number of bytes set with setInput().  This is not the
146
   * value returned by getTotalIn(), since this also includes the
Tom Tromey committed
147 148
   * unprocessed input.
   */
149
  private long totalIn;
Tom Tromey committed
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
  /**
   * This variable stores the nowrap flag that was given to the constructor.
   * True means, that the inflated stream doesn't contain a header nor the
   * checksum in the footer.
   */
  private boolean nowrap;

  private StreamManipulator input;
  private OutputWindow outputWindow;
  private InflaterDynHeader dynHeader;
  private InflaterHuffmanTree litlenTree, distTree;
  private Adler32 adler;

  /**
   * Creates a new inflater.
   */
  public Inflater ()
  {
    this (false);
  }

  /**
   * Creates a new inflater.
   * @param nowrap true if no header and checksum field appears in the
   * stream.  This is used for GZIPed input.  For compatibility with
   * Sun JDK you should provide one byte of input more than needed in
   * this case.
   */
  public Inflater (boolean nowrap)
  {
    this.nowrap = nowrap;
    this.adler = new Adler32();
    input = new StreamManipulator();
    outputWindow = new OutputWindow();
    mode = nowrap ? DECODE_BLOCKS : DECODE_HEADER;
  }

  /**
   * Finalizes this object.
   */
  protected void finalize ()
  {
    /* Exists only for compatibility */
  }

  /**
   * Frees all objects allocated by the inflater.  There's no reason
   * to call this, since you can just rely on garbage collection (even
   * for the Sun implementation).  Exists only for compatibility
   * with Sun's JDK, where the compressor allocates native memory.
   * If you call any method (even reset) afterwards the behaviour is
201
   * <i>undefined</i>.
Tom Tromey committed
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
   */
  public void end ()
  {
    outputWindow = null;
    input = null;
    dynHeader = null;
    litlenTree = null;
    distTree = null;
    adler = null;
  }

  /**
   * Returns true, if the inflater has finished.  This means, that no
   * input is needed and no output can be produced.
   */
217
  public boolean finished()
Tom Tromey committed
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
  {
    return mode == FINISHED && outputWindow.getAvailable() == 0;
  }

  /**
   * Gets the adler checksum.  This is either the checksum of all
   * uncompressed bytes returned by inflate(), or if needsDictionary()
   * returns true (and thus no output was yet produced) this is the
   * adler checksum of the expected dictionary.
   * @returns the adler checksum.
   */
  public int getAdler()
  {
    return needsDictionary() ? readAdler : (int) adler.getValue();
  }
233

Tom Tromey committed
234 235 236
  /**
   * Gets the number of unprocessed input.  Useful, if the end of the
   * stream is reached and you want to further process the bytes after
237
   * the deflate stream.
Tom Tromey committed
238 239 240 241 242 243
   * @return the number of bytes of the input which were not processed.
   */
  public int getRemaining()
  {
    return input.getAvailableBytes();
  }
244

Tom Tromey committed
245 246 247 248 249 250
  /**
   * Gets the total number of processed compressed input bytes.
   * @return the total number of bytes of processed input bytes.
   */
  public int getTotalIn()
  {
251 252 253 254 255 256 257 258 259 260
    return (int) (totalIn - getRemaining());
  }

  /**
   * Gets the total number of processed compressed input bytes.
   * @return the total number of bytes of processed input bytes.
   * @since 1.5
   */
  public long getBytesRead()
  {
Tom Tromey committed
261 262 263 264 265 266 267 268 269
    return totalIn - getRemaining();
  }

  /**
   * Gets the total number of output bytes returned by inflate().
   * @return the total number of output bytes.
   */
  public int getTotalOut()
  {
270 271 272 273 274 275 276 277 278 279
    return (int) totalOut;
  }

  /**
   * Gets the total number of output bytes returned by inflate().
   * @return the total number of output bytes.
   * @since 1.5
   */
  public long getBytesWritten()
  {
Tom Tromey committed
280 281 282 283 284 285
    return totalOut;
  }

  /**
   * Inflates the compressed stream to the output buffer.  If this
   * returns 0, you should check, whether needsDictionary(),
286
   * needsInput() or finished() returns true, to determine why no
Tom Tromey committed
287 288 289
   * further output is produced.
   * @param buf the output buffer.
   * @return the number of bytes written to the buffer, 0 if no further
290
   * output can be produced.
Tom Tromey committed
291 292 293 294 295 296 297 298 299 300 301
   * @exception DataFormatException if deflated stream is invalid.
   * @exception IllegalArgumentException if buf has length 0.
   */
  public int inflate (byte[] buf) throws DataFormatException
  {
    return inflate (buf, 0, buf.length);
  }

  /**
   * Inflates the compressed stream to the output buffer.  If this
   * returns 0, you should check, whether needsDictionary(),
302
   * needsInput() or finished() returns true, to determine why no
Tom Tromey committed
303 304 305 306 307
   * further output is produced.
   * @param buf the output buffer.
   * @param off the offset into buffer where the output should start.
   * @param len the maximum length of the output.
   * @return the number of bytes written to the buffer, 0 if no further
308
   * output can be produced.
Tom Tromey committed
309 310 311 312 313 314 315 316 317
   * @exception DataFormatException if deflated stream is invalid.
   * @exception IndexOutOfBoundsException if the off and/or len are wrong.
   */
  public int inflate (byte[] buf, int off, int len) throws DataFormatException
  {
    /* Check for correct buff, off, len triple */
    if (0 > off || off > off + len || off + len > buf.length)
      throw new ArrayIndexOutOfBoundsException();
    int count = 0;
318
    for (;;)
Tom Tromey committed
319
      {
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
        if (outputWindow.getAvailable() == 0)
          {
            if (!decode())
              break;
          }
        else if (len > 0)
          {
            int more = outputWindow.copyOutput(buf, off, len);
            adler.update(buf, off, more);
            off += more;
            count += more;
            totalOut += more;
            len -= more;
          }
        else
          break;
Tom Tromey committed
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
      }
    return count;
  }

  /**
   * Returns true, if a preset dictionary is needed to inflate the input.
   */
  public boolean needsDictionary ()
  {
    return mode == DECODE_DICT && neededBits == 0;
  }

  /**
   * Returns true, if the input buffer is empty.
   * You should then call setInput(). <br>
   *
   * <em>NOTE</em>: This method also returns true when the stream is finished.
   */
354
  public boolean needsInput ()
Tom Tromey committed
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
  {
    return input.needsInput ();
  }

  /**
   * Resets the inflater so that a new stream can be decompressed.  All
   * pending input and output will be discarded.
   */
  public void reset ()
  {
    mode = nowrap ? DECODE_BLOCKS : DECODE_HEADER;
    totalIn = totalOut = 0;
    input.reset();
    outputWindow.reset();
    dynHeader = null;
    litlenTree = null;
    distTree = null;
    isLastBlock = false;
    adler.reset();
  }

  /**
   * Sets the preset dictionary.  This should only be called, if
   * needsDictionary() returns true and it should set the same
   * dictionary, that was used for deflating.  The getAdler()
   * function returns the checksum of the dictionary needed.
   * @param buffer the dictionary.
   * @exception IllegalStateException if no dictionary is needed.
   * @exception IllegalArgumentException if the dictionary checksum is
384
   * wrong.
Tom Tromey committed
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
   */
  public void setDictionary (byte[] buffer)
  {
    setDictionary(buffer, 0, buffer.length);
  }

  /**
   * Sets the preset dictionary.  This should only be called, if
   * needsDictionary() returns true and it should set the same
   * dictionary, that was used for deflating.  The getAdler()
   * function returns the checksum of the dictionary needed.
   * @param buffer the dictionary.
   * @param off the offset into buffer where the dictionary starts.
   * @param len the length of the dictionary.
   * @exception IllegalStateException if no dictionary is needed.
   * @exception IllegalArgumentException if the dictionary checksum is
401
   * wrong.
Tom Tromey committed
402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
   * @exception IndexOutOfBoundsException if the off and/or len are wrong.
   */
  public void setDictionary (byte[] buffer, int off, int len)
  {
    if (!needsDictionary())
      throw new IllegalStateException();

    adler.update(buffer, off, len);
    if ((int) adler.getValue() != readAdler)
      throw new IllegalArgumentException("Wrong adler checksum");
    adler.reset();
    outputWindow.copyDict(buffer, off, len);
    mode = DECODE_BLOCKS;
  }

  /**
   * Sets the input.  This should only be called, if needsInput()
   * returns true.
   * @param buf the input.
   * @exception IllegalStateException if no input is needed.
   */
423
  public void setInput (byte[] buf)
Tom Tromey committed
424 425 426 427 428 429 430 431 432
  {
    setInput (buf, 0, buf.length);
  }

  /**
   * Sets the input.  This should only be called, if needsInput()
   * returns true.
   * @param buf the input.
   * @param off the offset into buffer where the input starts.
433
   * @param len the length of the input.
Tom Tromey committed
434 435 436
   * @exception IllegalStateException if no input is needed.
   * @exception IndexOutOfBoundsException if the off and/or len are wrong.
   */
437
  public void setInput (byte[] buf, int off, int len)
Tom Tromey committed
438 439 440 441 442 443 444
  {
    input.setInput (buf, off, len);
    totalIn += len;
  }

  /**
   * Decodes the deflate header.
445
   * @return false if more input is needed.
Tom Tromey committed
446 447 448 449 450 451 452 453
   * @exception DataFormatException if header is invalid.
   */
  private boolean decodeHeader () throws DataFormatException
  {
    int header = input.peekBits(16);
    if (header < 0)
      return false;
    input.dropBits(16);
454

Tom Tromey committed
455 456 457 458
    /* The header is written in "wrong" byte order */
    header = ((header << 8) | (header >> 8)) & 0xffff;
    if (header % 31 != 0)
      throw new DataFormatException("Header checksum illegal");
459

Tom Tromey committed
460 461 462
    if ((header & 0x0f00) != (Deflater.DEFLATED << 8))
      throw new DataFormatException("Compression Method unknown");

463
    /* Maximum size of the backwards window in bits.
Tom Tromey committed
464 465 466 467 468
     * We currently ignore this, but we could use it to make the
     * inflater window more space efficient. On the other hand the
     * full window (15 bits) is needed most times, anyway.
     int max_wbits = ((header & 0x7000) >> 12) + 8;
     */
469

Tom Tromey committed
470 471
    if ((header & 0x0020) == 0) // Dictionary flag?
      {
472
        mode = DECODE_BLOCKS;
Tom Tromey committed
473 474 475
      }
    else
      {
476 477
        mode = DECODE_DICT;
        neededBits = 32;
Tom Tromey committed
478 479 480
      }
    return true;
  }
481

Tom Tromey committed
482 483
  /**
   * Decodes the dictionary checksum after the deflate header.
484
   * @return false if more input is needed.
Tom Tromey committed
485 486 487 488 489
   */
  private boolean decodeDict ()
  {
    while (neededBits > 0)
      {
490 491 492 493 494 495
        int dictByte = input.peekBits(8);
        if (dictByte < 0)
          return false;
        input.dropBits(8);
        readAdler = (readAdler << 8) | dictByte;
        neededBits -= 8;
Tom Tromey committed
496 497 498 499 500 501 502 503
      }
    return false;
  }

  /**
   * Decodes the huffman encoded symbols in the input stream.
   * @return false if more input is needed, true if output window is
   * full or the current block ends.
504
   * @exception DataFormatException if deflated stream is invalid.
Tom Tromey committed
505 506 507 508 509 510
   */
  private boolean decodeHuffman () throws DataFormatException
  {
    int free = outputWindow.getFreeSpace();
    while (free >= 258)
      {
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
        int symbol;
        switch (mode)
          {
          case DECODE_HUFFMAN:
            /* This is the inner loop so it is optimized a bit */
            while (((symbol = litlenTree.getSymbol(input)) & ~0xff) == 0)
              {
                outputWindow.write(symbol);
                if (--free < 258)
                  return true;
              }
            if (symbol < 257)
              {
                if (symbol < 0)
                  return false;
                else
                  {
                    /* symbol == 256: end of block */
                    distTree = null;
                    litlenTree = null;
                    mode = DECODE_BLOCKS;
                    return true;
                  }
              }

            try
              {
                repLength = CPLENS[symbol - 257];
                neededBits = CPLEXT[symbol - 257];
              }
            catch (ArrayIndexOutOfBoundsException ex)
              {
                throw new DataFormatException("Illegal rep length code");
              }
            /* fall through */
          case DECODE_HUFFMAN_LENBITS:
            if (neededBits > 0)
              {
                mode = DECODE_HUFFMAN_LENBITS;
                int i = input.peekBits(neededBits);
                if (i < 0)
                  return false;
                input.dropBits(neededBits);
                repLength += i;
              }
            mode = DECODE_HUFFMAN_DIST;
            /* fall through */
          case DECODE_HUFFMAN_DIST:
            symbol = distTree.getSymbol(input);
            if (symbol < 0)
              return false;
            try
              {
                repDist = CPDIST[symbol];
                neededBits = CPDEXT[symbol];
              }
            catch (ArrayIndexOutOfBoundsException ex)
              {
                throw new DataFormatException("Illegal rep dist code");
              }
            /* fall through */
          case DECODE_HUFFMAN_DISTBITS:
            if (neededBits > 0)
              {
                mode = DECODE_HUFFMAN_DISTBITS;
                int i = input.peekBits(neededBits);
                if (i < 0)
                  return false;
                input.dropBits(neededBits);
                repDist += i;
              }
            outputWindow.repeat(repLength, repDist);
            free -= repLength;
            mode = DECODE_HUFFMAN;
            break;
          default:
            throw new IllegalStateException();
          }
Tom Tromey committed
589 590 591 592 593 594
      }
    return true;
  }

  /**
   * Decodes the adler checksum after the deflate stream.
595
   * @return false if more input is needed.
Tom Tromey committed
596 597 598 599 600 601
   * @exception DataFormatException if checksum doesn't match.
   */
  private boolean decodeChksum () throws DataFormatException
  {
    while (neededBits > 0)
      {
602 603 604 605 606 607
        int chkByte = input.peekBits(8);
        if (chkByte < 0)
          return false;
        input.dropBits(8);
        readAdler = (readAdler << 8) | chkByte;
        neededBits -= 8;
Tom Tromey committed
608 609 610
      }
    if ((int) adler.getValue() != readAdler)
      throw new DataFormatException("Adler chksum doesn't match: "
611 612
                                    +Integer.toHexString((int)adler.getValue())
                                    +" vs. "+Integer.toHexString(readAdler));
Tom Tromey committed
613 614 615 616 617 618
    mode = FINISHED;
    return false;
  }

  /**
   * Decodes the deflated stream.
619
   * @return false if more input is needed, or if finished.
Tom Tromey committed
620 621 622 623
   * @exception DataFormatException if deflated stream is invalid.
   */
  private boolean decode () throws DataFormatException
  {
624
    switch (mode)
Tom Tromey committed
625 626
      {
      case DECODE_HEADER:
627
        return decodeHeader();
Tom Tromey committed
628
      case DECODE_DICT:
629
        return decodeDict();
Tom Tromey committed
630
      case DECODE_CHKSUM:
631
        return decodeChksum();
Tom Tromey committed
632 633

      case DECODE_BLOCKS:
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
        if (isLastBlock)
          {
            if (nowrap)
              {
                mode = FINISHED;
                return false;
              }
            else
              {
                input.skipToByteBoundary();
                neededBits = 32;
                mode = DECODE_CHKSUM;
                return true;
              }
          }

        int type = input.peekBits(3);
        if (type < 0)
          return false;
        input.dropBits(3);

        if ((type & 1) != 0)
          isLastBlock = true;
        switch (type >> 1)
          {
          case DeflaterConstants.STORED_BLOCK:
            input.skipToByteBoundary();
            mode = DECODE_STORED_LEN1;
            break;
          case DeflaterConstants.STATIC_TREES:
            litlenTree = InflaterHuffmanTree.defLitLenTree;
            distTree = InflaterHuffmanTree.defDistTree;
            mode = DECODE_HUFFMAN;
            break;
          case DeflaterConstants.DYN_TREES:
            dynHeader = new InflaterDynHeader();
            mode = DECODE_DYN_HEADER;
            break;
          default:
            throw new DataFormatException("Unknown block type "+type);
          }
        return true;
Tom Tromey committed
676 677

      case DECODE_STORED_LEN1:
678 679 680 681 682 683 684
        {
          if ((uncomprLen = input.peekBits(16)) < 0)
            return false;
          input.dropBits(16);
          mode = DECODE_STORED_LEN2;
        }
        /* fall through */
Tom Tromey committed
685
      case DECODE_STORED_LEN2:
686 687 688 689 690 691 692 693 694 695
        {
          int nlen = input.peekBits(16);
          if (nlen < 0)
            return false;
          input.dropBits(16);
          if (nlen != (uncomprLen ^ 0xffff))
            throw new DataFormatException("broken uncompressed block");
          mode = DECODE_STORED;
        }
        /* fall through */
Tom Tromey committed
696
      case DECODE_STORED:
697 698 699 700 701 702 703 704 705 706
        {
          int more = outputWindow.copyStored(input, uncomprLen);
          uncomprLen -= more;
          if (uncomprLen == 0)
            {
              mode = DECODE_BLOCKS;
              return true;
            }
          return !input.needsInput();
        }
Tom Tromey committed
707 708

      case DECODE_DYN_HEADER:
709 710 711 712 713 714
        if (!dynHeader.decode(input))
          return false;
        litlenTree = dynHeader.buildLitLenTree();
        distTree = dynHeader.buildDistTree();
        mode = DECODE_HUFFMAN;
        /* fall through */
Tom Tromey committed
715 716 717 718
      case DECODE_HUFFMAN:
      case DECODE_HUFFMAN_LENBITS:
      case DECODE_HUFFMAN_DIST:
      case DECODE_HUFFMAN_DISTBITS:
719
        return decodeHuffman();
Tom Tromey committed
720
      case FINISHED:
721
        return false;
Tom Tromey committed
722
      default:
723 724
        throw new IllegalStateException();
      }
Tom Tromey committed
725 726
  }
}