wpkg test coverage results

Coverage test results of the Windows Packager by Made to Order Software Corporation.

LCOV - code coverage report
Current view: top level - bzip2 - decompress.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 308 349 88.3 %
Date: 2013-07-16 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : 
       2             : /*-------------------------------------------------------------*/
       3             : /*--- Decompression machinery                               ---*/
       4             : /*---                                          decompress.c ---*/
       5             : /*-------------------------------------------------------------*/
       6             : 
       7             : /* ------------------------------------------------------------------
       8             :    This file is part of bzip2/libbzip2, a program and library for
       9             :    lossless, block-sorting data compression.
      10             : 
      11             :    bzip2/libbzip2 version 1.0.6 of 6 September 2010
      12             :    Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
      13             : 
      14             :    Please read the WARNING, DISCLAIMER and PATENTS sections in the 
      15             :    README file.
      16             : 
      17             :    This program is released under the terms of the license contained
      18             :    in the file LICENSE.
      19             :    ------------------------------------------------------------------ */
      20             : 
      21             : 
      22             : #include "bzlib_private.h"
      23             : 
      24             : 
      25             : /*---------------------------------------------------*/
      26             : static
      27        2704 : void makeMaps_d ( DState* s )
      28             : {
      29             :    Int32 i;
      30        2704 :    s->nInUse = 0;
      31      694928 :    for (i = 0; i < 256; i++)
      32      692224 :       if (s->inUse[i]) {
      33      690954 :          s->seqToUnseq[s->nInUse] = i;
      34      690954 :          s->nInUse++;
      35             :       }
      36        2704 : }
      37             : 
      38             : 
      39             : /*---------------------------------------------------*/
      40             : #define RETURN(rrr)                               \
      41             :    { retVal = rrr; goto save_state_and_return; };
      42             : 
      43             : #define GET_BITS(lll,vvv,nnn)                     \
      44             :    case lll: s->state = lll;                      \
      45             :    while (True) {                                 \
      46             :       if (s->bsLive >= nnn) {                     \
      47             :          UInt32 v;                                \
      48             :          v = (s->bsBuff >>                        \
      49             :              (s->bsLive-nnn)) & ((1 << nnn)-1);   \
      50             :          s->bsLive -= nnn;                        \
      51             :          vvv = v;                                 \
      52             :          break;                                   \
      53             :       }                                           \
      54             :       if (s->strm->avail_in == 0) RETURN(BZ_OK);  \
      55             :       s->bsBuff                                   \
      56             :          = (s->bsBuff << 8) |                     \
      57             :            ((UInt32)                              \
      58             :               (*((UChar*)(s->strm->next_in))));   \
      59             :       s->bsLive += 8;                             \
      60             :       s->strm->next_in++;                         \
      61             :       s->strm->avail_in--;                        \
      62             :       s->strm->total_in_lo32++;                   \
      63             :       if (s->strm->total_in_lo32 == 0)            \
      64             :          s->strm->total_in_hi32++;                \
      65             :    }
      66             : 
      67             : #define GET_UCHAR(lll,uuu)                        \
      68             :    GET_BITS(lll,uuu,8)
      69             : 
      70             : #define GET_BIT(lll,uuu)                          \
      71             :    GET_BITS(lll,uuu,1)
      72             : 
      73             : /*---------------------------------------------------*/
      74             : #define GET_MTF_VAL(label1,label2,lval)           \
      75             : {                                                 \
      76             :    if (groupPos == 0) {                           \
      77             :       groupNo++;                                  \
      78             :       if (groupNo >= nSelectors)                  \
      79             :          RETURN(BZ_DATA_ERROR);                   \
      80             :       groupPos = BZ_G_SIZE;                       \
      81             :       gSel = s->selector[groupNo];                \
      82             :       gMinlen = s->minLens[gSel];                 \
      83             :       gLimit = &(s->limit[gSel][0]);              \
      84             :       gPerm = &(s->perm[gSel][0]);                \
      85             :       gBase = &(s->base[gSel][0]);                \
      86             :    }                                              \
      87             :    groupPos--;                                    \
      88             :    zn = gMinlen;                                  \
      89             :    GET_BITS(label1, zvec, zn);                    \
      90             :    while (1) {                                    \
      91             :       if (zn > 20 /* the longest code */)         \
      92             :          RETURN(BZ_DATA_ERROR);                   \
      93             :       if (zvec <= gLimit[zn]) break;              \
      94             :       zn++;                                       \
      95             :       GET_BIT(label2, zj);                        \
      96             :       zvec = (zvec << 1) | zj;                    \
      97             :    };                                             \
      98             :    if (zvec - gBase[zn] < 0                       \
      99             :        || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE)  \
     100             :       RETURN(BZ_DATA_ERROR);                      \
     101             :    lval = gPerm[zvec - gBase[zn]];                \
     102             : }
     103             : 
     104             : 
     105             : /*---------------------------------------------------*/
     106        7083 : Int32 BZ2_decompress ( DState* s )
     107             : {
     108             :    UChar      uc;
     109             :    Int32      retVal;
     110             :    Int32      minLen, maxLen;
     111        7083 :    bz_stream* strm = s->strm;
     112             : 
     113             :    /* stuff that needs to be saved/restored */
     114             :    Int32  i;
     115             :    Int32  j;
     116             :    Int32  t;
     117             :    Int32  alphaSize;
     118             :    Int32  nGroups;
     119             :    Int32  nSelectors;
     120             :    Int32  EOB;
     121             :    Int32  groupNo;
     122             :    Int32  groupPos;
     123             :    Int32  nextSym;
     124             :    Int32  nblockMAX;
     125             :    Int32  nblock;
     126             :    Int32  es;
     127             :    Int32  N;
     128             :    Int32  curr;
     129             :    Int32  zt;
     130             :    Int32  zn; 
     131             :    Int32  zvec;
     132             :    Int32  zj;
     133             :    Int32  gSel;
     134             :    Int32  gMinlen;
     135             :    Int32* gLimit;
     136             :    Int32* gBase;
     137             :    Int32* gPerm;
     138             : 
     139        7083 :    if (s->state == BZ_X_MAGIC_1) {
     140             :       /*initialise the save area*/
     141        2610 :       s->save_i           = 0;
     142        2610 :       s->save_j           = 0;
     143        2610 :       s->save_t           = 0;
     144        2610 :       s->save_alphaSize   = 0;
     145        2610 :       s->save_nGroups     = 0;
     146        2610 :       s->save_nSelectors  = 0;
     147        2610 :       s->save_EOB         = 0;
     148        2610 :       s->save_groupNo     = 0;
     149        2610 :       s->save_groupPos    = 0;
     150        2610 :       s->save_nextSym     = 0;
     151        2610 :       s->save_nblockMAX   = 0;
     152        2610 :       s->save_nblock      = 0;
     153        2610 :       s->save_es          = 0;
     154        2610 :       s->save_N           = 0;
     155        2610 :       s->save_curr        = 0;
     156        2610 :       s->save_zt          = 0;
     157        2610 :       s->save_zn          = 0;
     158        2610 :       s->save_zvec        = 0;
     159        2610 :       s->save_zj          = 0;
     160        2610 :       s->save_gSel        = 0;
     161        2610 :       s->save_gMinlen     = 0;
     162        2610 :       s->save_gLimit      = NULL;
     163        2610 :       s->save_gBase       = NULL;
     164        2610 :       s->save_gPerm       = NULL;
     165             :    }
     166             : 
     167             :    /*restore from the save area*/
     168        7083 :    i           = s->save_i;
     169        7083 :    j           = s->save_j;
     170        7083 :    t           = s->save_t;
     171        7083 :    alphaSize   = s->save_alphaSize;
     172        7083 :    nGroups     = s->save_nGroups;
     173        7083 :    nSelectors  = s->save_nSelectors;
     174        7083 :    EOB         = s->save_EOB;
     175        7083 :    groupNo     = s->save_groupNo;
     176        7083 :    groupPos    = s->save_groupPos;
     177        7083 :    nextSym     = s->save_nextSym;
     178        7083 :    nblockMAX   = s->save_nblockMAX;
     179        7083 :    nblock      = s->save_nblock;
     180        7083 :    es          = s->save_es;
     181        7083 :    N           = s->save_N;
     182        7083 :    curr        = s->save_curr;
     183        7083 :    zt          = s->save_zt;
     184        7083 :    zn          = s->save_zn; 
     185        7083 :    zvec        = s->save_zvec;
     186        7083 :    zj          = s->save_zj;
     187        7083 :    gSel        = s->save_gSel;
     188        7083 :    gMinlen     = s->save_gMinlen;
     189        7083 :    gLimit      = s->save_gLimit;
     190        7083 :    gBase       = s->save_gBase;
     191        7083 :    gPerm       = s->save_gPerm;
     192             : 
     193        7083 :    retVal = BZ_OK;
     194             : 
     195        7083 :    switch (s->state) {
     196             : 
     197        5220 :       GET_UCHAR(BZ_X_MAGIC_1, uc);
     198        2610 :       if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC);
     199             : 
     200        5220 :       GET_UCHAR(BZ_X_MAGIC_2, uc);
     201        2610 :       if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC);
     202             : 
     203        5220 :       GET_UCHAR(BZ_X_MAGIC_3, uc)
     204        2610 :       if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC);
     205             : 
     206        5220 :       GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
     207        2610 :       if (s->blockSize100k < (BZ_HDR_0 + 1) || 
     208           0 :           s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
     209        2610 :       s->blockSize100k -= BZ_HDR_0;
     210             : 
     211        2610 :       if (s->smallDecompress) {
     212           0 :          s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
     213           0 :          s->ll4  = BZALLOC( 
     214             :                       ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar) 
     215             :                    );
     216           0 :          if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
     217             :       } else {
     218        2610 :          s->tt  = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
     219        2610 :          if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
     220             :       }
     221             : 
     222       10628 :       GET_UCHAR(BZ_X_BLKHDR_1, uc);
     223             : 
     224        5314 :       if (uc == 0x17) goto endhdr_2;
     225        2704 :       if (uc != 0x31) RETURN(BZ_DATA_ERROR);
     226        5408 :       GET_UCHAR(BZ_X_BLKHDR_2, uc);
     227        2704 :       if (uc != 0x41) RETURN(BZ_DATA_ERROR);
     228        5408 :       GET_UCHAR(BZ_X_BLKHDR_3, uc);
     229        2704 :       if (uc != 0x59) RETURN(BZ_DATA_ERROR);
     230        5408 :       GET_UCHAR(BZ_X_BLKHDR_4, uc);
     231        2704 :       if (uc != 0x26) RETURN(BZ_DATA_ERROR);
     232        5408 :       GET_UCHAR(BZ_X_BLKHDR_5, uc);
     233        2704 :       if (uc != 0x53) RETURN(BZ_DATA_ERROR);
     234        5408 :       GET_UCHAR(BZ_X_BLKHDR_6, uc);
     235        2704 :       if (uc != 0x59) RETURN(BZ_DATA_ERROR);
     236             : 
     237        2704 :       s->currBlockNo++;
     238        2704 :       if (s->verbosity >= 2)
     239           0 :          VPrintf1 ( "\n    [%d: huff+mtf ", s->currBlockNo );
     240             :  
     241        2704 :       s->storedBlockCRC = 0;
     242        5408 :       GET_UCHAR(BZ_X_BCRC_1, uc);
     243        2704 :       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
     244        5408 :       GET_UCHAR(BZ_X_BCRC_2, uc);
     245        2704 :       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
     246        5408 :       GET_UCHAR(BZ_X_BCRC_3, uc);
     247        2704 :       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
     248        5408 :       GET_UCHAR(BZ_X_BCRC_4, uc);
     249        2704 :       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
     250             : 
     251        5314 :       GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1);
     252             : 
     253        2704 :       s->origPtr = 0;
     254        5408 :       GET_UCHAR(BZ_X_ORIGPTR_1, uc);
     255        2704 :       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
     256        5408 :       GET_UCHAR(BZ_X_ORIGPTR_2, uc);
     257        2704 :       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
     258        5408 :       GET_UCHAR(BZ_X_ORIGPTR_3, uc);
     259        2704 :       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
     260             : 
     261        2704 :       if (s->origPtr < 0)
     262           0 :          RETURN(BZ_DATA_ERROR);
     263        2704 :       if (s->origPtr > 10 + 100000*s->blockSize100k) 
     264           0 :          RETURN(BZ_DATA_ERROR);
     265             : 
     266             :       /*--- Receive the mapping table ---*/
     267       45968 :       for (i = 0; i < 16; i++) {
     268       48672 :          GET_BIT(BZ_X_MAPPING_1, uc);
     269       43264 :          if (uc == 1) 
     270       43253 :             s->inUse16[i] = True; else 
     271          11 :             s->inUse16[i] = False;
     272             :       }
     273             : 
     274      694928 :       for (i = 0; i < 256; i++) s->inUse[i] = False;
     275             : 
     276       45968 :       for (i = 0; i < 16; i++)
     277       43264 :          if (s->inUse16[i])
     278      735301 :             for (j = 0; j < 16; j++) {
     279      778554 :                GET_BIT(BZ_X_MAPPING_2, uc);
     280      692048 :                if (uc == 1) s->inUse[i * 16 + j] = True;
     281             :             }
     282        2704 :       makeMaps_d ( s );
     283        2704 :       if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
     284        2704 :       alphaSize = s->nInUse+2;
     285             : 
     286             :       /*--- Now the selectors ---*/
     287        2798 :       GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
     288        2704 :       if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR);
     289        8112 :       GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
     290        2704 :       if (nSelectors < 1) RETURN(BZ_DATA_ERROR);
     291     3839620 :       for (i = 0; i < nSelectors; i++) {
     292     3836916 :          j = 0;
     293             :          while (True) {
     294    14627455 :             GET_BIT(BZ_X_SELECTOR_3, uc);
     295    13002619 :             if (uc == 0) break;
     296     9165703 :             j++;
     297     9165703 :             if (j >= nGroups) RETURN(BZ_DATA_ERROR);
     298     9165703 :          }
     299     3836916 :          s->selectorMtf[i] = j;
     300             :       }
     301             : 
     302             :       /*--- Undo the MTF values for the selectors. ---*/
     303             :       {
     304             :          UChar pos[BZ_N_GROUPS], tmp, v;
     305       18847 :          for (v = 0; v < nGroups; v++) pos[v] = v;
     306             :    
     307     3839620 :          for (i = 0; i < nSelectors; i++) {
     308     3836916 :             v = s->selectorMtf[i];
     309     3836916 :             tmp = pos[v];
     310    13002619 :             while (v > 0) { pos[v] = pos[v-1]; v--; }
     311     3836916 :             pos[0] = tmp;
     312     3836916 :             s->selector[i] = tmp;
     313             :          }
     314             :       }
     315             : 
     316             :       /*--- Now the coding tables ---*/
     317       18847 :       for (t = 0; t < nGroups; t++) {
     318       26179 :          GET_BITS(BZ_X_CODING_1, curr, 5);
     319     4178080 :          for (i = 0; i < alphaSize; i++) {
     320             :             while (True) {
     321     5890770 :                if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
     322     6628130 :                GET_BIT(BZ_X_CODING_2, uc);
     323     5890770 :                if (uc == 0) break;
     324     1943962 :                GET_BIT(BZ_X_CODING_3, uc);
     325     1728833 :                if (uc == 0) curr++; else curr--;
     326     1728833 :             }
     327     4161937 :             s->len[t][i] = curr;
     328             :          }
     329             :       }
     330             : 
     331             :       /*--- Create the Huffman decoding tables ---*/
     332       18847 :       for (t = 0; t < nGroups; t++) {
     333       16143 :          minLen = 32;
     334       16143 :          maxLen = 0;
     335     4178080 :          for (i = 0; i < alphaSize; i++) {
     336     4161937 :             if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
     337     4161937 :             if (s->len[t][i] < minLen) minLen = s->len[t][i];
     338             :          }
     339       16143 :          BZ2_hbCreateDecodeTables ( 
     340       32286 :             &(s->limit[t][0]), 
     341       32286 :             &(s->base[t][0]), 
     342       32286 :             &(s->perm[t][0]), 
     343       32286 :             &(s->len[t][0]),
     344             :             minLen, maxLen, alphaSize
     345             :          );
     346       16143 :          s->minLens[t] = minLen;
     347             :       }
     348             : 
     349             :       /*--- Now the MTF values ---*/
     350             : 
     351        2704 :       EOB      = s->nInUse+1;
     352        2704 :       nblockMAX = 100000 * s->blockSize100k;
     353        2704 :       groupNo  = -1;
     354        2704 :       groupPos = 0;
     355             : 
     356      694928 :       for (i = 0; i <= 255; i++) s->unzftab[i] = 0;
     357             : 
     358             :       /*-- MTF init --*/
     359             :       {
     360             :          Int32 ii, jj, kk;
     361        2704 :          kk = MTFA_SIZE-1;
     362       45968 :          for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
     363      735488 :             for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
     364      692224 :                s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
     365      692224 :                kk--;
     366             :             }
     367       43264 :             s->mtfbase[ii] = kk + 1;
     368             :          }
     369             :       }
     370             :       /*-- end MTF init --*/
     371             : 
     372        2704 :       nblock = 0;
     373        8056 :       GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);
     374             : 
     375             :       while (True) {
     376             : 
     377   191780641 :          if (nextSym == EOB) break;
     378             : 
     379   191777937 :          if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
     380             : 
     381      758133 :             es = -1;
     382      758133 :             N = 1;
     383             :             do {
     384             :                /* Check that N doesn't get too big, so that es doesn't
     385             :                   go negative.  The maximum value that can be
     386             :                   RUNA/RUNB encoded is equal to the block size (post
     387             :                   the initial RLE), viz, 900k, so bounding N at 2
     388             :                   million should guard against overflow without
     389             :                   rejecting any legitimate inputs. */
     390      758159 :                if (N >= 2*1024*1024) RETURN(BZ_DATA_ERROR);
     391      758159 :                if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
     392        2656 :                if (nextSym == BZ_RUNB) es = es + (1+1) * N;
     393      758159 :                N = N * 2;
     394     2247804 :                GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
     395             :             }
     396      758159 :                while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
     397             : 
     398      758133 :             es++;
     399      758133 :             uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
     400      758133 :             s->unzftab[uc] += es;
     401             : 
     402      758133 :             if (s->smallDecompress)
     403           0 :                while (es > 0) {
     404           0 :                   if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
     405           0 :                   s->ll16[nblock] = (UInt16)uc;
     406           0 :                   nblock++;
     407           0 :                   es--;
     408             :                }
     409             :             else
     410     1518974 :                while (es > 0) {
     411      760841 :                   if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
     412      760841 :                   s->tt[nblock] = (UInt32)uc;
     413      760841 :                   nblock++;
     414      760841 :                   es--;
     415             :                };
     416             : 
     417      758133 :             continue;
     418             : 
     419             :          } else {
     420             : 
     421   191019804 :             if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
     422             : 
     423             :             /*-- uc = MTF ( nextSym-1 ) --*/
     424             :             {
     425             :                Int32 ii, jj, kk, pp, lno, off;
     426             :                UInt32 nn;
     427   191019804 :                nn = (UInt32)(nextSym - 1);
     428             : 
     429   191019804 :                if (nn < MTFL_SIZE) {
     430             :                   /* avoid general-case expense */
     431    11295129 :                   pp = s->mtfbase[0];
     432    11295129 :                   uc = s->mtfa[pp+nn];
     433    29352559 :                   while (nn > 3) {
     434    18057430 :                      Int32 z = pp+nn;
     435    18057430 :                      s->mtfa[(z)  ] = s->mtfa[(z)-1];
     436    18057430 :                      s->mtfa[(z)-1] = s->mtfa[(z)-2];
     437    18057430 :                      s->mtfa[(z)-2] = s->mtfa[(z)-3];
     438    18057430 :                      s->mtfa[(z)-3] = s->mtfa[(z)-4];
     439    18057430 :                      nn -= 4;
     440             :                   }
     441    29345969 :                   while (nn > 0) { 
     442    18050840 :                      s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--; 
     443             :                   };
     444    11295129 :                   s->mtfa[pp] = uc;
     445             :                } else { 
     446             :                   /* general case */
     447   179724675 :                   lno = nn / MTFL_SIZE;
     448   179724675 :                   off = nn % MTFL_SIZE;
     449   179724675 :                   pp = s->mtfbase[lno] + off;
     450   179724675 :                   uc = s->mtfa[pp];
     451  1527392000 :                   while (pp > s->mtfbase[lno]) { 
     452  1347667325 :                      s->mtfa[pp] = s->mtfa[pp-1]; pp--; 
     453             :                   };
     454   179724675 :                   s->mtfbase[lno]++;
     455  1616576090 :                   while (lno > 0) {
     456  1436851415 :                      s->mtfbase[lno]--;
     457  1436851415 :                      s->mtfa[s->mtfbase[lno]] 
     458  1436851415 :                         = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
     459  1436851415 :                      lno--;
     460             :                   }
     461   179724675 :                   s->mtfbase[0]--;
     462   179724675 :                   s->mtfa[s->mtfbase[0]] = uc;
     463   179724675 :                   if (s->mtfbase[0] == 0) {
     464       45483 :                      kk = MTFA_SIZE-1;
     465      773211 :                      for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
     466    12371376 :                         for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
     467    11643648 :                            s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
     468    11643648 :                            kk--;
     469             :                         }
     470      727728 :                         s->mtfbase[ii] = kk + 1;
     471             :                      }
     472             :                   }
     473             :                }
     474             :             }
     475             :             /*-- end uc = MTF ( nextSym-1 ) --*/
     476             : 
     477   191019804 :             s->unzftab[s->seqToUnseq[uc]]++;
     478   191019804 :             if (s->smallDecompress)
     479           0 :                s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
     480   191019804 :                s->tt[nblock]   = (UInt32)(s->seqToUnseq[uc]);
     481   191019804 :             nblock++;
     482             : 
     483   565602231 :             GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
     484   191019804 :             continue;
     485             :          }
     486   191777937 :       }
     487             : 
     488             :       /* Now we know what nblock is, we can do a better sanity
     489             :          check on s->origPtr.
     490             :       */
     491        2704 :       if (s->origPtr < 0 || s->origPtr >= nblock)
     492           0 :          RETURN(BZ_DATA_ERROR);
     493             : 
     494             :       /*-- Set up cftab to facilitate generation of T^(-1) --*/
     495             :       /* Check: unzftab entries in range. */
     496      694928 :       for (i = 0; i <= 255; i++) {
     497      692224 :          if (s->unzftab[i] < 0 || s->unzftab[i] > nblock)
     498           0 :             RETURN(BZ_DATA_ERROR);
     499             :       }
     500             :       /* Actually generate cftab. */
     501        2704 :       s->cftab[0] = 0;
     502      694928 :       for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
     503      694928 :       for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
     504             :       /* Check: cftab entries in range. */
     505      697632 :       for (i = 0; i <= 256; i++) {
     506      694928 :          if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
     507             :             /* s->cftab[i] can legitimately be == nblock */
     508           0 :             RETURN(BZ_DATA_ERROR);
     509             :          }
     510             :       }
     511             :       /* Check: cftab entries non-descending. */
     512      694928 :       for (i = 1; i <= 256; i++) {
     513      692224 :          if (s->cftab[i-1] > s->cftab[i]) {
     514           0 :             RETURN(BZ_DATA_ERROR);
     515             :          }
     516             :       }
     517             : 
     518        2704 :       s->state_out_len = 0;
     519        2704 :       s->state_out_ch  = 0;
     520        2704 :       BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
     521        2704 :       s->state = BZ_X_OUTPUT;
     522        2704 :       if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );
     523             : 
     524        2704 :       if (s->smallDecompress) {
     525             : 
     526             :          /*-- Make a copy of cftab, used in generation of T --*/
     527           0 :          for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
     528             : 
     529             :          /*-- compute the T vector --*/
     530           0 :          for (i = 0; i < nblock; i++) {
     531           0 :             uc = (UChar)(s->ll16[i]);
     532           0 :             SET_LL(i, s->cftabCopy[uc]);
     533           0 :             s->cftabCopy[uc]++;
     534             :          }
     535             : 
     536             :          /*-- Compute T^(-1) by pointer reversal on T --*/
     537           0 :          i = s->origPtr;
     538           0 :          j = GET_LL(i);
     539             :          do {
     540           0 :             Int32 tmp = GET_LL(j);
     541           0 :             SET_LL(j, i);
     542           0 :             i = j;
     543           0 :             j = tmp;
     544             :          }
     545           0 :             while (i != s->origPtr);
     546             : 
     547           0 :          s->tPos = s->origPtr;
     548           0 :          s->nblock_used = 0;
     549           0 :          if (s->blockRandomised) {
     550           0 :             BZ_RAND_INIT_MASK;
     551           0 :             BZ_GET_SMALL(s->k0); s->nblock_used++;
     552           0 :             BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; 
     553             :          } else {
     554           0 :             BZ_GET_SMALL(s->k0); s->nblock_used++;
     555             :          }
     556             : 
     557             :       } else {
     558             : 
     559             :          /*-- compute the T^(-1) vector --*/
     560   191783349 :          for (i = 0; i < nblock; i++) {
     561   191780645 :             uc = (UChar)(s->tt[i] & 0xff);
     562   191780645 :             s->tt[s->cftab[uc]] |= (i << 8);
     563   191780645 :             s->cftab[uc]++;
     564             :          }
     565             : 
     566        2704 :          s->tPos = s->tt[s->origPtr] >> 8;
     567        2704 :          s->nblock_used = 0;
     568        2704 :          if (s->blockRandomised) {
     569           0 :             BZ_RAND_INIT_MASK;
     570           0 :             BZ_GET_FAST(s->k0); s->nblock_used++;
     571           0 :             BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; 
     572             :          } else {
     573        2704 :             BZ_GET_FAST(s->k0); s->nblock_used++;
     574             :          }
     575             : 
     576             :       }
     577             : 
     578        2704 :       RETURN(BZ_OK);
     579             : 
     580             : 
     581             : 
     582             :     endhdr_2:
     583             : 
     584        5220 :       GET_UCHAR(BZ_X_ENDHDR_2, uc);
     585        2610 :       if (uc != 0x72) RETURN(BZ_DATA_ERROR);
     586        5220 :       GET_UCHAR(BZ_X_ENDHDR_3, uc);
     587        2610 :       if (uc != 0x45) RETURN(BZ_DATA_ERROR);
     588        5220 :       GET_UCHAR(BZ_X_ENDHDR_4, uc);
     589        2610 :       if (uc != 0x38) RETURN(BZ_DATA_ERROR);
     590        5220 :       GET_UCHAR(BZ_X_ENDHDR_5, uc);
     591        2610 :       if (uc != 0x50) RETURN(BZ_DATA_ERROR);
     592        5220 :       GET_UCHAR(BZ_X_ENDHDR_6, uc);
     593        2610 :       if (uc != 0x90) RETURN(BZ_DATA_ERROR);
     594             : 
     595        2610 :       s->storedCombinedCRC = 0;
     596        5220 :       GET_UCHAR(BZ_X_CCRC_1, uc);
     597        2610 :       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
     598        5220 :       GET_UCHAR(BZ_X_CCRC_2, uc);
     599        2610 :       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
     600        5220 :       GET_UCHAR(BZ_X_CCRC_3, uc);
     601        2610 :       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
     602        5220 :       GET_UCHAR(BZ_X_CCRC_4, uc);
     603        2610 :       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
     604             : 
     605        2610 :       s->state = BZ_X_IDLE;
     606        2610 :       RETURN(BZ_STREAM_END);
     607             : 
     608           0 :       default: AssertH ( False, 4001 );
     609             :    }
     610             : 
     611           0 :    AssertH ( False, 4002 );
     612             : 
     613             :    save_state_and_return:
     614             : 
     615        7083 :    s->save_i           = i;
     616        7083 :    s->save_j           = j;
     617        7083 :    s->save_t           = t;
     618        7083 :    s->save_alphaSize   = alphaSize;
     619        7083 :    s->save_nGroups     = nGroups;
     620        7083 :    s->save_nSelectors  = nSelectors;
     621        7083 :    s->save_EOB         = EOB;
     622        7083 :    s->save_groupNo     = groupNo;
     623        7083 :    s->save_groupPos    = groupPos;
     624        7083 :    s->save_nextSym     = nextSym;
     625        7083 :    s->save_nblockMAX   = nblockMAX;
     626        7083 :    s->save_nblock      = nblock;
     627        7083 :    s->save_es          = es;
     628        7083 :    s->save_N           = N;
     629        7083 :    s->save_curr        = curr;
     630        7083 :    s->save_zt          = zt;
     631        7083 :    s->save_zn          = zn;
     632        7083 :    s->save_zvec        = zvec;
     633        7083 :    s->save_zj          = zj;
     634        7083 :    s->save_gSel        = gSel;
     635        7083 :    s->save_gMinlen     = gMinlen;
     636        7083 :    s->save_gLimit      = gLimit;
     637        7083 :    s->save_gBase       = gBase;
     638        7083 :    s->save_gPerm       = gPerm;
     639             : 
     640        7083 :    return retVal;   
     641             : }
     642             : 
     643             : 
     644             : /*-------------------------------------------------------------*/
     645             : /*--- end                                      decompress.c ---*/
     646             : /*-------------------------------------------------------------*/

Generated by: LCOV version 1.9

The wpkg tool is an open source tool created by Made to Order Software Corporation.