Clover coverage report - Ant Coverage
Coverage timestamp: Tue Apr 8 2003 20:43:55 EST
file stats: LOC: 879   Methods: 32
NCLOC: 676   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
CBZip2InputStream.java 80.1% 80.3% 68.8% 79.6%
 1   
 /*
 2   
  * The Apache Software License, Version 1.1
 3   
  *
 4   
  * Copyright (c) 2001-2002 The Apache Software Foundation.  All rights
 5   
  * reserved.
 6   
  *
 7   
  * Redistribution and use in source and binary forms, with or without
 8   
  * modification, are permitted provided that the following conditions
 9   
  * are met:
 10   
  *
 11   
  * 1. Redistributions of source code must retain the above copyright
 12   
  *    notice, this list of conditions and the following disclaimer.
 13   
  *
 14   
  * 2. Redistributions in binary form must reproduce the above copyright
 15   
  *    notice, this list of conditions and the following disclaimer in
 16   
  *    the documentation and/or other materials provided with the
 17   
  *    distribution.
 18   
  *
 19   
  * 3. The end-user documentation included with the redistribution, if
 20   
  *    any, must include the following acknowlegement:
 21   
  *       "This product includes software developed by the
 22   
  *        Apache Software Foundation (http://www.apache.org/)."
 23   
  *    Alternately, this acknowlegement may appear in the software itself,
 24   
  *    if and wherever such third-party acknowlegements normally appear.
 25   
  *
 26   
  * 4. The names "Ant" and "Apache Software
 27   
  *    Foundation" must not be used to endorse or promote products derived
 28   
  *    from this software without prior written permission. For written
 29   
  *    permission, please contact apache@apache.org.
 30   
  *
 31   
  * 5. Products derived from this software may not be called "Apache"
 32   
  *    nor may "Apache" appear in their names without prior written
 33   
  *    permission of the Apache Group.
 34   
  *
 35   
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 36   
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 37   
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 38   
  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 39   
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 40   
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 41   
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 42   
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 43   
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 44   
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 45   
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 46   
  * SUCH DAMAGE.
 47   
  * ====================================================================
 48   
  *
 49   
  * This software consists of voluntary contributions made by many
 50   
  * individuals on behalf of the Apache Software Foundation.  For more
 51   
  * information on the Apache Software Foundation, please see
 52   
  * <http://www.apache.org/>.
 53   
  */
 54   
 
 55   
 /*
 56   
  * This package is based on the work done by Keiron Liddle, Aftex Software
 57   
  * <keiron@aftexsw.com> to whom the Ant project is very grateful for his
 58   
  * great code.
 59   
  */
 60   
 package org.apache.tools.bzip2;
 61   
 
 62   
 import java.io.InputStream;
 63   
 import java.io.IOException;
 64   
 
 65   
 /**
 66   
  * An input stream that decompresses from the BZip2 format (without the file
 67   
  * header chars) to be read as any other stream.
 68   
  *
 69   
  * @author <a href="mailto:keiron@aftexsw.com">Keiron Liddle</a>
 70   
  */
 71   
 public class CBZip2InputStream extends InputStream implements BZip2Constants {
 72  0
     private static void cadvise() {
 73  0
         System.out.println("CRC Error");
 74   
         //throw new CCoruptionError();
 75   
     }
 76   
 
 77  0
     private static void badBGLengths() {
 78  0
         cadvise();
 79   
     }
 80   
 
 81  0
     private static void bitStreamEOF() {
 82  0
         cadvise();
 83   
     }
 84   
 
 85  0
     private static void compressedStreamEOF() {
 86  0
         cadvise();
 87   
     }
 88   
 
 89  7
     private void makeMaps() {
 90  7
         int i;
 91  7
         nInUse = 0;
 92  7
         for (i = 0; i < 256; i++) {
 93  1792
             if (inUse[i]) {
 94  1591
                 seqToUnseq[nInUse] = (char) i;
 95  1591
                 unseqToSeq[i] = (char) nInUse;
 96  1591
                 nInUse++;
 97   
             }
 98   
         }
 99   
     }
 100   
 
 101   
     /*
 102   
       index of the last char in the block, so
 103   
       the block size == last + 1.
 104   
     */
 105   
     private int  last;
 106   
 
 107   
     /*
 108   
       index in zptr[] of original string after sorting.
 109   
     */
 110   
     private int  origPtr;
 111   
 
 112   
     /*
 113   
       always: in the range 0 .. 9.
 114   
       The current block size is 100000 * this number.
 115   
     */
 116   
     private int blockSize100k;
 117   
 
 118   
     private boolean blockRandomised;
 119   
 
 120   
     private int bytesIn;
 121   
     private int bytesOut;
 122   
     private int bsBuff;
 123   
     private int bsLive;
 124   
     private CRC mCrc = new CRC();
 125   
 
 126   
     private boolean[] inUse = new boolean[256];
 127   
     private int nInUse;
 128   
 
 129   
     private char[] seqToUnseq = new char[256];
 130   
     private char[] unseqToSeq = new char[256];
 131   
 
 132   
     private char[] selector = new char[MAX_SELECTORS];
 133   
     private char[] selectorMtf = new char[MAX_SELECTORS];
 134   
 
 135   
     private int[] tt;
 136   
     private char[] ll8;
 137   
 
 138   
     /*
 139   
       freq table collected to save a pass over the data
 140   
       during decompression.
 141   
     */
 142   
     private int unzftab[] = new int[256];
 143   
 
 144   
     private int limit[][] = new int[N_GROUPS][MAX_ALPHA_SIZE];
 145   
     private int base[][] = new int[N_GROUPS][MAX_ALPHA_SIZE];
 146   
     private int perm[][] = new int[N_GROUPS][MAX_ALPHA_SIZE];
 147   
     private int minLens[] = new int[N_GROUPS];
 148   
 
 149   
     private InputStream bsStream;
 150   
 
 151   
     private boolean streamEnd = false;
 152   
 
 153   
     private int currentChar = -1;
 154   
 
 155   
     private static final int START_BLOCK_STATE = 1;
 156   
     private static final int RAND_PART_A_STATE = 2;
 157   
     private static final int RAND_PART_B_STATE = 3;
 158   
     private static final int RAND_PART_C_STATE = 4;
 159   
     private static final int NO_RAND_PART_A_STATE = 5;
 160   
     private static final int NO_RAND_PART_B_STATE = 6;
 161   
     private static final int NO_RAND_PART_C_STATE = 7;
 162   
 
 163   
     private int currentState = START_BLOCK_STATE;
 164   
 
 165   
     private int storedBlockCRC, storedCombinedCRC;
 166   
     private int computedBlockCRC, computedCombinedCRC;
 167   
 
 168   
     int i2, count, chPrev, ch2;
 169   
     int i, tPos;
 170   
     int rNToGo = 0;
 171   
     int rTPos  = 0;
 172   
     int j2;
 173   
     char z;
 174   
 
 175  4
     public CBZip2InputStream(InputStream zStream) {
 176  4
         ll8 = null;
 177  4
         tt = null;
 178  4
         bsSetStream(zStream);
 179  4
         initialize();
 180  4
         initBlock();
 181  4
         setupBlock();
 182   
     }
 183   
 
 184  3246082
     public int read() {
 185  3246082
         if (streamEnd) {
 186  2
             return -1;
 187   
         } else {
 188  3246080
             int retChar = currentChar;
 189  3246080
             switch(currentState) {
 190   
             case START_BLOCK_STATE:
 191  0
                 break;
 192   
             case RAND_PART_A_STATE:
 193  0
                 break;
 194   
             case RAND_PART_B_STATE:
 195  0
                 setupRandPartB();
 196  0
                 break;
 197   
             case RAND_PART_C_STATE:
 198  0
                 setupRandPartC();
 199  0
                 break;
 200   
             case NO_RAND_PART_A_STATE:
 201  0
                 break;
 202   
             case NO_RAND_PART_B_STATE:
 203  2780705
                 setupNoRandPartB();
 204  2780705
                 break;
 205   
             case NO_RAND_PART_C_STATE:
 206  465375
                 setupNoRandPartC();
 207  465375
                 break;
 208   
             default:
 209  0
                 break;
 210   
             }
 211  3246080
             return retChar;
 212   
         }
 213   
     }
 214   
 
 215  4
     private void initialize() {
 216  4
         char magic3, magic4;
 217  4
         magic3 = bsGetUChar();
 218  4
         magic4 = bsGetUChar();
 219  4
         if (magic3 != 'h' || magic4 < '1' || magic4 > '9') {
 220  0
             bsFinishedWithStream();
 221  0
             streamEnd = true;
 222  0
             return;
 223   
         }
 224   
 
 225  4
         setDecompressStructureSizes(magic4 - '0');
 226  4
         computedCombinedCRC = 0;
 227   
     }
 228   
 
 229  11
     private void initBlock() {
 230  11
         char magic1, magic2, magic3, magic4;
 231  11
         char magic5, magic6;
 232  11
         magic1 = bsGetUChar();
 233  11
         magic2 = bsGetUChar();
 234  11
         magic3 = bsGetUChar();
 235  11
         magic4 = bsGetUChar();
 236  11
         magic5 = bsGetUChar();
 237  11
         magic6 = bsGetUChar();
 238  11
         if (magic1 == 0x17 && magic2 == 0x72 && magic3 == 0x45
 239   
             && magic4 == 0x38 && magic5 == 0x50 && magic6 == 0x90) {
 240  4
             complete();
 241  4
             return;
 242   
         }
 243   
 
 244  7
         if (magic1 != 0x31 || magic2 != 0x41 || magic3 != 0x59
 245   
             || magic4 != 0x26 || magic5 != 0x53 || magic6 != 0x59) {
 246  0
             badBlockHeader();
 247  0
             streamEnd = true;
 248  0
             return;
 249   
         }
 250   
 
 251  7
         storedBlockCRC = bsGetInt32();
 252   
 
 253  7
         if (bsR(1) == 1) {
 254  0
             blockRandomised = true;
 255   
         } else {
 256  7
             blockRandomised = false;
 257   
         }
 258   
 
 259   
         //        currBlockNo++;
 260  7
         getAndMoveToFrontDecode();
 261   
 
 262  7
         mCrc.initialiseCRC();
 263  7
         currentState = START_BLOCK_STATE;
 264   
     }
 265   
 
 266  7
     private void endBlock() {
 267  7
         computedBlockCRC = mCrc.getFinalCRC();
 268   
         /* A bad CRC is considered a fatal error. */
 269  7
         if (storedBlockCRC != computedBlockCRC) {
 270  0
             crcError();
 271   
         }
 272   
 
 273  7
         computedCombinedCRC = (computedCombinedCRC << 1)
 274   
             | (computedCombinedCRC >>> 31);
 275  7
         computedCombinedCRC ^= computedBlockCRC;
 276   
     }
 277   
 
 278  4
     private void complete() {
 279  4
         storedCombinedCRC = bsGetInt32();
 280  4
         if (storedCombinedCRC != computedCombinedCRC) {
 281  0
             crcError();
 282   
         }
 283   
 
 284  4
         bsFinishedWithStream();
 285  4
         streamEnd = true;
 286   
     }
 287   
 
 288  0
     private static void blockOverrun() {
 289  0
         cadvise();
 290   
     }
 291   
 
 292  0
     private static void badBlockHeader() {
 293  0
         cadvise();
 294   
     }
 295   
 
 296  0
     private static void crcError() {
 297  0
         cadvise();
 298   
     }
 299   
 
 300  4
     private void bsFinishedWithStream() {
 301  4
         try {
 302  4
             if (this.bsStream != null) {
 303  4
                 if (this.bsStream != System.in) {
 304  4
                     this.bsStream.close();
 305  4
                     this.bsStream= null;
 306   
                 }
 307   
             }
 308   
         } catch (IOException ioe) {
 309   
         }
 310   
     }
 311   
 
 312  4
     private void bsSetStream(InputStream f) {
 313  4
         bsStream = f;
 314  4
         bsLive = 0;
 315  4
         bsBuff = 0;
 316  4
         bytesOut = 0;
 317  4
         bytesIn = 0;
 318   
     }
 319   
 
 320  217727
     private int bsR(int n) {
 321  217727
         int v;
 322   
         {
 323  217727
             while (bsLive < n) {
 324  37780
                 int zzi;
 325  37780
                 char thech = 0;
 326  37780
                 try {
 327  37780
                     thech = (char) bsStream.read();
 328   
                 } catch (IOException e) {
 329  0
                     compressedStreamEOF();
 330   
                 }
 331  37780
                 if (thech == -1) {
 332  0
                     compressedStreamEOF();
 333   
                 }
 334  37780
                 zzi = thech;
 335  37780
                 bsBuff = (bsBuff << 8) | (zzi & 0xff);
 336  37780
                 bsLive += 8;
 337   
             }
 338   
         }
 339   
 
 340  217727
         v = (bsBuff >> (bsLive - n)) & ((1 << n) - 1);
 341  217727
         bsLive -= n;
 342  217727
         return v;
 343   
     }
 344   
 
 345  74
     private char bsGetUChar() {
 346  74
         return (char) bsR(8);
 347   
     }
 348   
 
 349  11
     private int bsGetint() {
 350  11
         int u = 0;
 351  11
         u = (u << 8) | bsR(8);
 352  11
         u = (u << 8) | bsR(8);
 353  11
         u = (u << 8) | bsR(8);
 354  11
         u = (u << 8) | bsR(8);
 355  11
         return u;
 356   
     }
 357   
 
 358  7
     private int bsGetIntVS(int numBits) {
 359  7
         return (int) bsR(numBits);
 360   
     }
 361   
 
 362  11
     private int bsGetInt32() {
 363  11
         return (int) bsGetint();
 364   
     }
 365   
 
 366  40
     private void hbCreateDecodeTables(int[] limit, int[] base,
 367   
                                       int[] perm, char[] length,
 368   
                                       int minLen, int maxLen, int alphaSize) {
 369  40
         int pp, i, j, vec;
 370   
 
 371  40
         pp = 0;
 372  40
         for (i = minLen; i <= maxLen; i++) {
 373  190
             for (j = 0; j < alphaSize; j++) {
 374  43191
                 if (length[j] == i) {
 375  9516
                     perm[pp] = j;
 376  9516
                     pp++;
 377   
                 }
 378   
             }
 379   
         };
 380   
 
 381  40
         for (i = 0; i < MAX_CODE_LEN; i++) {
 382  920
             base[i] = 0;
 383   
         }
 384  40
         for (i = 0; i < alphaSize; i++) {
 385  9516
             base[length[i] + 1]++;
 386   
         }
 387   
 
 388  40
         for (i = 1; i < MAX_CODE_LEN; i++) {
 389  880
             base[i] += base[i - 1];
 390   
         }
 391   
 
 392  40
         for (i = 0; i < MAX_CODE_LEN; i++) {
 393  920
             limit[i] = 0;
 394   
         }
 395  40
         vec = 0;
 396   
 
 397  40
         for (i = minLen; i <= maxLen; i++) {
 398  190
             vec += (base[i + 1] - base[i]);
 399  190
             limit[i] = vec - 1;
 400  190
             vec <<= 1;
 401   
         }
 402  40
         for (i = minLen + 1; i <= maxLen; i++) {
 403  150
             base[i] = ((limit[i - 1] + 1) << 1) - base[i];
 404   
         }
 405   
     }
 406   
 
 407  7
     private void recvDecodingTables() {
 408  7
         char len[][] = new char[N_GROUPS][MAX_ALPHA_SIZE];
 409  7
         int i, j, t, nGroups, nSelectors, alphaSize;
 410  7
         int minLen, maxLen;
 411  7
         boolean[] inUse16 = new boolean[16];
 412   
 
 413   
         /* Receive the mapping table */
 414  7
         for (i = 0; i < 16; i++) {
 415  112
             if (bsR(1) == 1) {
 416  105
                 inUse16[i] = true;
 417   
             } else {
 418  7
                 inUse16[i] = false;
 419   
             }
 420   
         }
 421   
 
 422  7
         for (i = 0; i < 256; i++) {
 423  1792
             inUse[i] = false;
 424   
         }
 425   
 
 426  7
         for (i = 0; i < 16; i++) {
 427  112
             if (inUse16[i]) {
 428  105
                 for (j = 0; j < 16; j++) {
 429  1680
                     if (bsR(1) == 1) {
 430  1591
                         inUse[i * 16 + j] = true;
 431   
                     }
 432   
                 }
 433   
             }
 434   
         }
 435   
 
 436  7
         makeMaps();
 437  7
         alphaSize = nInUse + 2;
 438   
 
 439   
         /* Now the selectors */
 440  7
         nGroups = bsR(3);
 441  7
         nSelectors = bsR(15);
 442  7
         for (i = 0; i < nSelectors; i++) {
 443  3903
             j = 0;
 444  3903
             while (bsR(1) == 1) {
 445  784
                 j++;
 446   
             }
 447  3903
             selectorMtf[i] = (char) j;
 448   
         }
 449   
 
 450   
         /* Undo the MTF values for the selectors. */
 451   
         {
 452  7
             char[] pos = new char[N_GROUPS];
 453  7
             char tmp, v;
 454  7
             for (v = 0; v < nGroups; v++) {
 455  40
                 pos[v] = v;
 456   
             }
 457   
 
 458  7
             for (i = 0; i < nSelectors; i++) {
 459  3903
                 v = selectorMtf[i];
 460  3903
                 tmp = pos[v];
 461  3903
                 while (v > 0) {
 462  784
                     pos[v] = pos[v - 1];
 463  784
                     v--;
 464   
                 }
 465  3903
                 pos[0] = tmp;
 466  3903
                 selector[i] = tmp;
 467   
             }
 468   
         }
 469   
 
 470   
         /* Now the coding tables */
 471  7
         for (t = 0; t < nGroups; t++) {
 472  40
             int curr = bsR(5);
 473  40
             for (i = 0; i < alphaSize; i++) {
 474  9516
                 while (bsR(1) == 1) {
 475  3279
                     if (bsR(1) == 0) {
 476  1686
                         curr++;
 477   
                     } else {
 478  1593
                         curr--;
 479   
                     }
 480   
                 }
 481  9516
                 len[t][i] = (char) curr;
 482   
             }
 483   
         }
 484   
 
 485   
         /* Create the Huffman decoding tables */
 486  7
         for (t = 0; t < nGroups; t++) {
 487  40
             minLen = 32;
 488  40
             maxLen = 0;
 489  40
             for (i = 0; i < alphaSize; i++) {
 490  9516
                 if (len[t][i] > maxLen) {
 491  109
                     maxLen = len[t][i];
 492   
                 }
 493  9516
                 if (len[t][i] < minLen) {
 494  73
                     minLen = len[t][i];
 495   
                 }
 496   
             }
 497  40
             hbCreateDecodeTables(limit[t], base[t], perm[t], len[t], minLen,
 498   
                                  maxLen, alphaSize);
 499  40
             minLens[t] = minLen;
 500   
         }
 501   
     }
 502   
 
 503  7
     private void getAndMoveToFrontDecode() {
 504  7
         char[] yy = new char[256];
 505  7
         int i, j, nextSym, limitLast;
 506  7
         int EOB, groupNo, groupPos;
 507   
 
 508  7
         limitLast = baseBlockSize * blockSize100k;
 509  7
         origPtr = bsGetIntVS(24);
 510   
 
 511  7
         recvDecodingTables();
 512  7
         EOB = nInUse + 1;
 513  7
         groupNo = -1;
 514  7
         groupPos = 0;
 515   
 
 516   
         /*
 517   
           Setting up the unzftab entries here is not strictly
 518   
           necessary, but it does save having to do it later
 519   
           in a separate pass, and so saves a block's worth of
 520   
           cache misses.
 521   
         */
 522  7
         for (i = 0; i <= 255; i++) {
 523  1792
             unzftab[i] = 0;
 524   
         }
 525   
 
 526  7
         for (i = 0; i <= 255; i++) {
 527  1792
             yy[i] = (char) i;
 528   
         }
 529   
 
 530  7
         last = -1;
 531   
 
 532   
         {
 533  7
             int zt, zn, zvec, zj;
 534  7
             if (groupPos == 0) {
 535  7
                 groupNo++;
 536  7
                 groupPos = G_SIZE;
 537   
             }
 538  7
             groupPos--;
 539  7
             zt = selector[groupNo];
 540  7
             zn = minLens[zt];
 541  7
             zvec = bsR(zn);
 542  7
             while (zvec > limit[zt][zn]) {
 543  46
                 zn++;
 544   
                 {
 545   
                     {
 546  46
                         while (bsLive < 1) {
 547  5
                             int zzi;
 548  5
                             char thech = 0;
 549  5
                             try {
 550  5
                                 thech = (char) bsStream.read();
 551   
                             } catch (IOException e) {
 552  0
                                 compressedStreamEOF();
 553   
                             }
 554  5
                             if (thech == -1) {
 555  0
                                 compressedStreamEOF();
 556   
                             }
 557  5
                             zzi = thech;
 558  5
                             bsBuff = (bsBuff << 8) | (zzi & 0xff);
 559  5
                             bsLive += 8;
 560   
                         }
 561   
                     }
 562  46
                     zj = (bsBuff >> (bsLive - 1)) & 1;
 563  46
                     bsLive--;
 564   
                 }
 565  46
                 zvec = (zvec << 1) | zj;
 566   
             }
 567  7
             nextSym = perm[zt][zvec - base[zt][zn]];
 568   
         }
 569   
 
 570  7
         while (true) {
 571   
 
 572  74428
             if (nextSym == EOB) {
 573  7
                 break;
 574   
             }
 575   
 
 576  74421
             if (nextSym == RUNA || nextSym == RUNB) {
 577  29062
                 char ch;
 578  29062
                 int s = -1;
 579  29062
                 int N = 1;
 580  29062
                 do {
 581  149622
                     if (nextSym == RUNA) {
 582  20404
                         s = s + (0 + 1) * N;
 583  129218
                     } else if (nextSym == RUNB) {
 584  129218
                         s = s + (1 + 1) * N;
 585   
                            }
 586  149622
                     N = N * 2;
 587   
                     {
 588  149622
                         int zt, zn, zvec, zj;
 589  149622
                         if (groupPos == 0) {
 590  3010
                             groupNo++;
 591  3010
                             groupPos = G_SIZE;
 592   
                         }
 593  149622
                         groupPos--;
 594  149622
                         zt = selector[groupNo];
 595  149622
                         zn = minLens[zt];
 596  149622
                         zvec = bsR(zn);
 597  149622
                         while (zvec > limit[zt][zn]) {
 598  249801
                             zn++;
 599   
                             {
 600   
                                 {
 601  249801
                                     while (bsLive < 1) {
 602  31241
                                         int zzi;
 603  31241
                                         char thech = 0;
 604  31241
                                         try {
 605  31241
                                             thech = (char) bsStream.read();
 606   
                                         } catch (IOException e) {
 607  0
                                             compressedStreamEOF();
 608   
                                         }
 609  31241
                                         if (thech == -1) {
 610  0
                                             compressedStreamEOF();
 611   
                                         }
 612  31241
                                         zzi = thech;
 613  31241
                                         bsBuff = (bsBuff << 8) | (zzi & 0xff);
 614  31241
                                         bsLive += 8;
 615   
                                     }
 616   
                                 }
 617  249801
                                 zj = (bsBuff >> (bsLive - 1)) & 1;
 618  249801
                                 bsLive--;
 619   
                             }
 620  249801
                             zvec = (zvec << 1) | zj;
 621   
                         };
 622  149622
                         nextSym = perm[zt][zvec - base[zt][zn]];
 623   
                     }
 624  149622
                 } while (nextSym == RUNA || nextSym == RUNB);
 625   
 
 626  29062
                 s++;
 627  29062
                 ch = seqToUnseq[yy[0]];
 628  29062
                 unzftab[ch] += s;
 629   
 
 630  29062
                 while (s > 0) {
 631  2739953
                     last++;
 632  2739953
                     ll8[last] = ch;
 633  2739953
                     s--;
 634   
                 };
 635   
 
 636  29062
                 if (last >= limitLast) {
 637  0
                     blockOverrun();
 638   
                 }
 639  29062
                 continue;
 640   
             } else {
 641  45359
                 char tmp;
 642  45359
                 last++;
 643  45359
                 if (last >= limitLast) {
 644  0
                     blockOverrun();
 645   
                 }
 646   
 
 647  45359
                 tmp = yy[nextSym - 1];
 648  45359
                 unzftab[seqToUnseq[tmp]]++;
 649  45359
                 ll8[last] = seqToUnseq[tmp];
 650   
 
 651   
                 /*
 652   
                   This loop is hammered during decompression,
 653   
                   hence the unrolling.
 654   
 
 655   
                   for (j = nextSym-1; j > 0; j--) yy[j] = yy[j-1];
 656   
                 */
 657   
 
 658  45359
                 j = nextSym - 1;
 659  45359
                 for (; j > 3; j -= 4) {
 660  1236137
                     yy[j]     = yy[j - 1];
 661  1236137
                     yy[j - 1] = yy[j - 2];
 662  1236137
                     yy[j - 2] = yy[j - 3];
 663  1236137
                     yy[j - 3] = yy[j - 4];
 664   
                 }
 665  45359
                 for (; j > 0; j--) {
 666  66968
                     yy[j] = yy[j - 1];
 667   
                 }
 668   
 
 669  45359
                 yy[0] = tmp;
 670   
                 {
 671  45359
                     int zt, zn, zvec, zj;
 672  45359
                     if (groupPos == 0) {
 673  886
                         groupNo++;
 674  886
                         groupPos = G_SIZE;
 675   
                     }
 676  45359
                     groupPos--;
 677  45359
                     zt = selector[groupNo];
 678  45359
                     zn = minLens[zt];
 679  45359
                     zvec = bsR(zn);
 680  45359
                     while (zvec > limit[zt][zn]) {
 681  37072
                         zn++;
 682   
                         {
 683   
                             {
 684  37072
                                 while (bsLive < 1) {
 685  4784
                                     int zzi;
 686  4784
                                     char thech = 0;
 687  4784
                                     try {
 688  4784
                                         thech = (char) bsStream.read();
 689   
                                     } catch (IOException e) {
 690  0
                                         compressedStreamEOF();
 691   
                                     }
 692  4784
                                     zzi = thech;
 693  4784
                                     bsBuff = (bsBuff << 8) | (zzi & 0xff);
 694  4784
                                     bsLive += 8;
 695   
                                 }
 696   
                             }
 697  37072
                             zj = (bsBuff >> (bsLive - 1)) & 1;
 698  37072
                             bsLive--;
 699   
                         }
 700  37072
                         zvec = (zvec << 1) | zj;
 701   
                     };
 702  45359
                     nextSym = perm[zt][zvec - base[zt][zn]];
 703   
                 }
 704  45359
                 continue;
 705   
             }
 706   
         }
 707   
     }
 708   
 
 709  11
     private void setupBlock() {
 710  11
         int[] cftab = new int[257];
 711  11
         char ch;
 712   
 
 713  11
         cftab[0] = 0;
 714  11
         for (i = 1; i <= 256; i++) {
 715  2816
             cftab[i] = unzftab[i - 1];
 716   
         }
 717  11
         for (i = 1; i <= 256; i++) {
 718  2816
             cftab[i] += cftab[i - 1];
 719   
         }
 720   
 
 721  11
         for (i = 0; i <= last; i++) {
 722  2870681
             ch = (char) ll8[i];
 723  2870681
             tt[cftab[ch]] = i;
 724  2870681
             cftab[ch]++;
 725   
         }
 726  11
         cftab = null;
 727   
 
 728  11
         tPos = tt[origPtr];
 729   
 
 730  11
         count = 0;
 731  11
         i2 = 0;
 732  11
         ch2 = 256;   /* not a char and not EOF */
 733   
 
 734  11
         if (blockRandomised) {
 735  0
             rNToGo = 0;
 736  0
             rTPos = 0;
 737  0
             setupRandPartA();
 738   
         } else {
 739  11
             setupNoRandPartA();
 740   
         }
 741   
     }
 742   
 
 743  0
     private void setupRandPartA() {
 744  0
         if (i2 <= last) {
 745  0
             chPrev = ch2;
 746  0
             ch2 = ll8[tPos];
 747  0
             tPos = tt[tPos];
 748  0
             if (rNToGo == 0) {
 749  0
                 rNToGo = rNums[rTPos];
 750  0
                 rTPos++;
 751  0
                 if (rTPos == 512) {
 752  0
                     rTPos = 0;
 753   
                 }
 754   
             }
 755  0
             rNToGo--;
 756  0
             ch2 ^= (int) ((rNToGo == 1) ? 1 : 0);
 757  0
             i2++;
 758   
 
 759  0
             currentChar = ch2;
 760  0
             currentState = RAND_PART_B_STATE;
 761  0
             mCrc.updateCRC(ch2);
 762   
         } else {
 763  0
             endBlock();
 764  0
             initBlock();
 765  0
             setupBlock();
 766   
         }
 767   
     }
 768   
 
 769  2780716
     private void setupNoRandPartA() {
 770  2780716
         if (i2 <= last) {
 771  2780709
             chPrev = ch2;
 772  2780709
             ch2 = ll8[tPos];
 773  2780709
             tPos = tt[tPos];
 774  2780709
             i2++;
 775   
 
 776  2780709
             currentChar = ch2;
 777  2780709
             currentState = NO_RAND_PART_B_STATE;
 778  2780709
             mCrc.updateCRC(ch2);
 779   
         } else {
 780  7
             endBlock();
 781  7
             initBlock();
 782  7
             setupBlock();
 783   
         }
 784   
     }
 785   
 
 786  0
     private void setupRandPartB() {
 787  0
         if (ch2 != chPrev) {
 788  0
             currentState = RAND_PART_A_STATE;
 789  0
             count = 1;
 790  0
             setupRandPartA();
 791   
         } else {
 792  0
             count++;
 793  0
             if (count >= 4) {
 794  0
                 z = ll8[tPos];
 795  0
                 tPos = tt[tPos];
 796  0
                 if (rNToGo == 0) {
 797  0
                     rNToGo = rNums[rTPos];
 798  0
                     rTPos++;
 799  0
                     if (rTPos == 512) {
 800  0
                         rTPos = 0;
 801   
                     }
 802   
                 }
 803  0
                 rNToGo--;
 804  0
                 z ^= ((rNToGo == 1) ? 1 : 0);
 805  0
                 j2 = 0;
 806  0
                 currentState = RAND_PART_C_STATE;
 807  0
                 setupRandPartC();
 808   
             } else {
 809  0
                 currentState = RAND_PART_A_STATE;
 810  0
                 setupRandPartA();
 811   
             }
 812   
         }
 813   
     }
 814   
 
 815  0
     private void setupRandPartC() {
 816  0
         if (j2 < (int) z) {
 817  0
             currentChar = ch2;
 818  0
             mCrc.updateCRC(ch2);
 819  0
             j2++;
 820   
         } else {
 821  0
             currentState = RAND_PART_A_STATE;
 822  0
             i2++;
 823  0
             count = 0;
 824  0
             setupRandPartA();
 825   
         }
 826   
     }
 827   
 
 828  2780705
     private void setupNoRandPartB() {
 829  2780705
         if (ch2 != chPrev) {
 830  2737792
             currentState = NO_RAND_PART_A_STATE;
 831  2737792
             count = 1;
 832  2737792
             setupNoRandPartA();
 833   
         } else {
 834  42913
             count++;
 835  42913
             if (count >= 4) {
 836  4607
                 z = ll8[tPos];
 837  4607
                 tPos = tt[tPos];
 838  4607
                 currentState = NO_RAND_PART_C_STATE;
 839  4607
                 j2 = 0;
 840  4607
                 setupNoRandPartC();
 841   
             } else {
 842  38306
                 currentState = NO_RAND_PART_A_STATE;
 843  38306
                 setupNoRandPartA();
 844   
             }
 845   
         }
 846   
     }
 847   
 
 848  469982
     private void setupNoRandPartC() {
 849  469982
         if (j2 < (int) z) {
 850  465375
             currentChar = ch2;
 851  465375
             mCrc.updateCRC(ch2);
 852  465375
             j2++;
 853   
         } else {
 854  4607
             currentState = NO_RAND_PART_A_STATE;
 855  4607
             i2++;
 856  4607
             count = 0;
 857  4607
             setupNoRandPartA();
 858   
         }
 859   
     }
 860   
 
 861  4
     private void setDecompressStructureSizes(int newSize100k) {
 862  4
         if (!(0 <= newSize100k && newSize100k <= 9 && 0 <= blockSize100k
 863   
                && blockSize100k <= 9)) {
 864   
             // throw new IOException("Invalid block size");
 865   
         }
 866   
 
 867  4
         blockSize100k = newSize100k;
 868   
 
 869  4
         if (newSize100k == 0) {
 870  0
             return;
 871   
         }
 872   
 
 873  4
         int n = baseBlockSize * newSize100k;
 874  4
         ll8 = new char[n];
 875  4
         tt = new int[n];
 876   
     }
 877   
 }
 878   
 
 879