NCBI C++ ToolKit
decompress.c
Go to the documentation of this file.

Go to the SVN repository for this file.

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.8 of 13 July 2019
12  Copyright (C) 1996-2019 Julian Seward <jseward@acm.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 void makeMaps_d ( DState* s )
28 {
29  Int32 i;
30  s->nInUse = 0;
31  for (i = 0; i < 256; i++)
32  if (s->inUse[i]) {
33  s->seqToUnseq[s->nInUse] = i;
34  s->nInUse++;
35  }
36 }
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 /*---------------------------------------------------*/
107 {
108  UChar uc;
109  Int32 retVal;
110  Int32 minLen, maxLen;
111  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  if (s->state == BZ_X_MAGIC_1) {
140  /*initialise the save area*/
141  s->save_i = 0;
142  s->save_j = 0;
143  s->save_t = 0;
144  s->save_alphaSize = 0;
145  s->save_nGroups = 0;
146  s->save_nSelectors = 0;
147  s->save_EOB = 0;
148  s->save_groupNo = 0;
149  s->save_groupPos = 0;
150  s->save_nextSym = 0;
151  s->save_nblockMAX = 0;
152  s->save_nblock = 0;
153  s->save_es = 0;
154  s->save_N = 0;
155  s->save_curr = 0;
156  s->save_zt = 0;
157  s->save_zn = 0;
158  s->save_zvec = 0;
159  s->save_zj = 0;
160  s->save_gSel = 0;
161  s->save_gMinlen = 0;
162  s->save_gLimit = NULL;
163  s->save_gBase = NULL;
164  s->save_gPerm = NULL;
165  }
166 
167  /*restore from the save area*/
168  i = s->save_i;
169  j = s->save_j;
170  t = s->save_t;
171  alphaSize = s->save_alphaSize;
172  nGroups = s->save_nGroups;
173  nSelectors = s->save_nSelectors;
174  EOB = s->save_EOB;
175  groupNo = s->save_groupNo;
176  groupPos = s->save_groupPos;
177  nextSym = s->save_nextSym;
178  nblockMAX = s->save_nblockMAX;
179  nblock = s->save_nblock;
180  es = s->save_es;
181  N = s->save_N;
182  curr = s->save_curr;
183  zt = s->save_zt;
184  zn = s->save_zn;
185  zvec = s->save_zvec;
186  zj = s->save_zj;
187  gSel = s->save_gSel;
188  gMinlen = s->save_gMinlen;
189  gLimit = s->save_gLimit;
190  gBase = s->save_gBase;
191  gPerm = s->save_gPerm;
192 
193  retVal = BZ_OK;
194 
195  switch (s->state) {
196 
197  GET_UCHAR(BZ_X_MAGIC_1, uc);
198  if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC);
199 
200  GET_UCHAR(BZ_X_MAGIC_2, uc);
201  if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC);
202 
204  if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC);
205 
207  if (s->blockSize100k < (BZ_HDR_0 + 1) ||
209  s->blockSize100k -= BZ_HDR_0;
210 
211  if (s->smallDecompress) {
212  s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
213  s->ll4 = BZALLOC(
214  ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)
215  );
216  if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
217  } else {
218  s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
219  if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
220  }
221 
223 
224  if (uc == 0x17) goto endhdr_2;
225  if (uc != 0x31) RETURN(BZ_DATA_ERROR);
227  if (uc != 0x41) RETURN(BZ_DATA_ERROR);
229  if (uc != 0x59) RETURN(BZ_DATA_ERROR);
231  if (uc != 0x26) RETURN(BZ_DATA_ERROR);
233  if (uc != 0x53) RETURN(BZ_DATA_ERROR);
235  if (uc != 0x59) RETURN(BZ_DATA_ERROR);
236 
237  s->currBlockNo++;
238  if (s->verbosity >= 2)
239  VPrintf1 ( "\n [%d: huff+mtf ", s->currBlockNo );
240 
241  s->storedBlockCRC = 0;
242  GET_UCHAR(BZ_X_BCRC_1, uc);
243  s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
244  GET_UCHAR(BZ_X_BCRC_2, uc);
245  s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
246  GET_UCHAR(BZ_X_BCRC_3, uc);
247  s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
248  GET_UCHAR(BZ_X_BCRC_4, uc);
249  s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
250 
252 
253  s->origPtr = 0;
255  s->origPtr = (s->origPtr << 8) | ((Int32)uc);
257  s->origPtr = (s->origPtr << 8) | ((Int32)uc);
259  s->origPtr = (s->origPtr << 8) | ((Int32)uc);
260 
261  if (s->origPtr < 0)
263  if (s->origPtr > 10 + 100000*s->blockSize100k)
265 
266  /*--- Receive the mapping table ---*/
267  for (i = 0; i < 16; i++) {
268  GET_BIT(BZ_X_MAPPING_1, uc);
269  if (uc == 1)
270  s->inUse16[i] = True; else
271  s->inUse16[i] = False;
272  }
273 
274  for (i = 0; i < 256; i++) s->inUse[i] = False;
275 
276  for (i = 0; i < 16; i++)
277  if (s->inUse16[i])
278  for (j = 0; j < 16; j++) {
279  GET_BIT(BZ_X_MAPPING_2, uc);
280  if (uc == 1) s->inUse[i * 16 + j] = True;
281  }
282  makeMaps_d ( s );
283  if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
284  alphaSize = s->nInUse+2;
285 
286  /*--- Now the selectors ---*/
287  GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
288  if (nGroups < 2 || nGroups > BZ_N_GROUPS) RETURN(BZ_DATA_ERROR);
289  GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
290  if (nSelectors < 1) RETURN(BZ_DATA_ERROR);
291  for (i = 0; i < nSelectors; i++) {
292  j = 0;
293  while (True) {
295  if (uc == 0) break;
296  j++;
297  if (j >= nGroups) RETURN(BZ_DATA_ERROR);
298  }
299  /* Having more than BZ_MAX_SELECTORS doesn't make much sense
300  since they will never be used, but some implementations might
301  "round up" the number of selectors, so just ignore those. */
302  if (i < BZ_MAX_SELECTORS)
303  s->selectorMtf[i] = j;
304  }
305  if (nSelectors > BZ_MAX_SELECTORS)
306  nSelectors = BZ_MAX_SELECTORS;
307 
308  /*--- Undo the MTF values for the selectors. ---*/
309  {
310  UChar pos[BZ_N_GROUPS], tmp, v;
311  for (v = 0; v < nGroups; v++) pos[v] = v;
312 
313  for (i = 0; i < nSelectors; i++) {
314  v = s->selectorMtf[i];
315  tmp = pos[v];
316  while (v > 0) { pos[v] = pos[v-1]; v--; }
317  pos[0] = tmp;
318  s->selector[i] = tmp;
319  }
320  }
321 
322  /*--- Now the coding tables ---*/
323  for (t = 0; t < nGroups; t++) {
324  GET_BITS(BZ_X_CODING_1, curr, 5);
325  for (i = 0; i < alphaSize; i++) {
326  while (True) {
327  if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
328  GET_BIT(BZ_X_CODING_2, uc);
329  if (uc == 0) break;
330  GET_BIT(BZ_X_CODING_3, uc);
331  if (uc == 0) curr++; else curr--;
332  }
333  s->len[t][i] = curr;
334  }
335  }
336 
337  /*--- Create the Huffman decoding tables ---*/
338  for (t = 0; t < nGroups; t++) {
339  minLen = 32;
340  maxLen = 0;
341  for (i = 0; i < alphaSize; i++) {
342  if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
343  if (s->len[t][i] < minLen) minLen = s->len[t][i];
344  }
346  &(s->limit[t][0]),
347  &(s->base[t][0]),
348  &(s->perm[t][0]),
349  &(s->len[t][0]),
350  minLen, maxLen, alphaSize
351  );
352  s->minLens[t] = minLen;
353  }
354 
355  /*--- Now the MTF values ---*/
356 
357  EOB = s->nInUse+1;
358  nblockMAX = 100000 * s->blockSize100k;
359  groupNo = -1;
360  groupPos = 0;
361 
362  for (i = 0; i <= 255; i++) s->unzftab[i] = 0;
363 
364  /*-- MTF init --*/
365  {
366  Int32 ii, jj, kk;
367  kk = MTFA_SIZE-1;
368  for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
369  for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
370  s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
371  kk--;
372  }
373  s->mtfbase[ii] = kk + 1;
374  }
375  }
376  /*-- end MTF init --*/
377 
378  nblock = 0;
379  GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);
380 
381  while (True) {
382 
383  if (nextSym == EOB) break;
384 
385  if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
386 
387  es = -1;
388  N = 1;
389  do {
390  /* Check that N doesn't get too big, so that es doesn't
391  go negative. The maximum value that can be
392  RUNA/RUNB encoded is equal to the block size (post
393  the initial RLE), viz, 900k, so bounding N at 2
394  million should guard against overflow without
395  rejecting any legitimate inputs. */
396  if (N >= 2*1024*1024) RETURN(BZ_DATA_ERROR);
397  if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
398  if (nextSym == BZ_RUNB) es = es + (1+1) * N;
399  N = N * 2;
400  GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
401  }
402  while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
403 
404  es++;
405  uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
406  s->unzftab[uc] += es;
407 
408  if (s->smallDecompress)
409  while (es > 0) {
410  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
411  s->ll16[nblock] = (UInt16)uc;
412  nblock++;
413  es--;
414  }
415  else
416  while (es > 0) {
417  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
418  s->tt[nblock] = (UInt32)uc;
419  nblock++;
420  es--;
421  };
422 
423  continue;
424 
425  } else {
426 
427  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
428 
429  /*-- uc = MTF ( nextSym-1 ) --*/
430  {
431  Int32 ii, jj, kk, pp, lno, off;
432  UInt32 nn;
433  nn = (UInt32)(nextSym - 1);
434 
435  if (nn < MTFL_SIZE) {
436  /* avoid general-case expense */
437  pp = s->mtfbase[0];
438  uc = s->mtfa[pp+nn];
439  while (nn > 3) {
440  Int32 z = pp+nn;
441  s->mtfa[(z) ] = s->mtfa[(z)-1];
442  s->mtfa[(z)-1] = s->mtfa[(z)-2];
443  s->mtfa[(z)-2] = s->mtfa[(z)-3];
444  s->mtfa[(z)-3] = s->mtfa[(z)-4];
445  nn -= 4;
446  }
447  while (nn > 0) {
448  s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
449  };
450  s->mtfa[pp] = uc;
451  } else {
452  /* general case */
453  lno = nn / MTFL_SIZE;
454  off = nn % MTFL_SIZE;
455  pp = s->mtfbase[lno] + off;
456  uc = s->mtfa[pp];
457  while (pp > s->mtfbase[lno]) {
458  s->mtfa[pp] = s->mtfa[pp-1]; pp--;
459  };
460  s->mtfbase[lno]++;
461  while (lno > 0) {
462  s->mtfbase[lno]--;
463  s->mtfa[s->mtfbase[lno]]
464  = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
465  lno--;
466  }
467  s->mtfbase[0]--;
468  s->mtfa[s->mtfbase[0]] = uc;
469  if (s->mtfbase[0] == 0) {
470  kk = MTFA_SIZE-1;
471  for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
472  for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
473  s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
474  kk--;
475  }
476  s->mtfbase[ii] = kk + 1;
477  }
478  }
479  }
480  }
481  /*-- end uc = MTF ( nextSym-1 ) --*/
482 
483  s->unzftab[s->seqToUnseq[uc]]++;
484  if (s->smallDecompress)
485  s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
486  s->tt[nblock] = (UInt32)(s->seqToUnseq[uc]);
487  nblock++;
488 
489  GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
490  continue;
491  }
492  }
493 
494  /* Now we know what nblock is, we can do a better sanity
495  check on s->origPtr.
496  */
497  if (s->origPtr < 0 || s->origPtr >= nblock)
499 
500  /*-- Set up cftab to facilitate generation of T^(-1) --*/
501  /* Check: unzftab entries in range. */
502  for (i = 0; i <= 255; i++) {
503  if (s->unzftab[i] < 0 || s->unzftab[i] > nblock)
505  }
506  /* Actually generate cftab. */
507  s->cftab[0] = 0;
508  for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
509  for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
510  /* Check: cftab entries in range. */
511  for (i = 0; i <= 256; i++) {
512  if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
513  /* s->cftab[i] can legitimately be == nblock */
515  }
516  }
517  /* Check: cftab entries non-descending. */
518  for (i = 1; i <= 256; i++) {
519  if (s->cftab[i-1] > s->cftab[i]) {
521  }
522  }
523 
524  s->state_out_len = 0;
525  s->state_out_ch = 0;
527  s->state = BZ_X_OUTPUT;
528  if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );
529 
530  if (s->smallDecompress) {
531 
532  /*-- Make a copy of cftab, used in generation of T --*/
533  for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
534 
535  /*-- compute the T vector --*/
536  for (i = 0; i < nblock; i++) {
537  uc = (UChar)(s->ll16[i]);
538  SET_LL(i, s->cftabCopy[uc]);
539  s->cftabCopy[uc]++;
540  }
541 
542  /*-- Compute T^(-1) by pointer reversal on T --*/
543  i = s->origPtr;
544  j = GET_LL(i);
545  do {
546  Int32 tmp = GET_LL(j);
547  SET_LL(j, i);
548  i = j;
549  j = tmp;
550  }
551  while (i != s->origPtr);
552 
553  s->tPos = s->origPtr;
554  s->nblock_used = 0;
555  if (s->blockRandomised) {
557  BZ_GET_SMALL(s->k0); s->nblock_used++;
559  } else {
560  BZ_GET_SMALL(s->k0); s->nblock_used++;
561  }
562 
563  } else {
564 
565  /*-- compute the T^(-1) vector --*/
566  for (i = 0; i < nblock; i++) {
567  uc = (UChar)(s->tt[i] & 0xff);
568  s->tt[s->cftab[uc]] |= (i << 8);
569  s->cftab[uc]++;
570  }
571 
572  s->tPos = s->tt[s->origPtr] >> 8;
573  s->nblock_used = 0;
574  if (s->blockRandomised) {
576  BZ_GET_FAST(s->k0); s->nblock_used++;
578  } else {
579  BZ_GET_FAST(s->k0); s->nblock_used++;
580  }
581 
582  }
583 
584  RETURN(BZ_OK);
585 
586 
587 
588  endhdr_2:
589 
591  if (uc != 0x72) RETURN(BZ_DATA_ERROR);
593  if (uc != 0x45) RETURN(BZ_DATA_ERROR);
595  if (uc != 0x38) RETURN(BZ_DATA_ERROR);
597  if (uc != 0x50) RETURN(BZ_DATA_ERROR);
599  if (uc != 0x90) RETURN(BZ_DATA_ERROR);
600 
601  s->storedCombinedCRC = 0;
602  GET_UCHAR(BZ_X_CCRC_1, uc);
603  s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
604  GET_UCHAR(BZ_X_CCRC_2, uc);
605  s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
606  GET_UCHAR(BZ_X_CCRC_3, uc);
607  s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
608  GET_UCHAR(BZ_X_CCRC_4, uc);
609  s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
610 
611  s->state = BZ_X_IDLE;
613 
614  default: AssertH ( False, 4001 );
615  }
616 
617  AssertH ( False, 4002 );
618 
619  save_state_and_return:
620 
621  s->save_i = i;
622  s->save_j = j;
623  s->save_t = t;
624  s->save_alphaSize = alphaSize;
625  s->save_nGroups = nGroups;
626  s->save_nSelectors = nSelectors;
627  s->save_EOB = EOB;
628  s->save_groupNo = groupNo;
629  s->save_groupPos = groupPos;
630  s->save_nextSym = nextSym;
631  s->save_nblockMAX = nblockMAX;
632  s->save_nblock = nblock;
633  s->save_es = es;
634  s->save_N = N;
635  s->save_curr = curr;
636  s->save_zt = zt;
637  s->save_zn = zn;
638  s->save_zvec = zvec;
639  s->save_zj = zj;
640  s->save_gSel = gSel;
641  s->save_gMinlen = gMinlen;
642  s->save_gLimit = gLimit;
643  s->save_gBase = gBase;
644  s->save_gPerm = gPerm;
645 
646  return retVal;
647 }
648 
649 
650 /*-------------------------------------------------------------*/
651 /*--- end decompress.c ---*/
652 /*-------------------------------------------------------------*/
#define False
Definition: bzip2.c:170
unsigned int UInt32
Definition: bzip2.c:165
unsigned char UChar
Definition: bzip2.c:163
unsigned short UInt16
Definition: bzip2.c:167
#define True
Definition: bzip2.c:169
int Int32
Definition: bzip2.c:164
#define BZ_HDR_Z
Definition: bzip2recover.c:75
#define BZ_HDR_B
Definition: bzip2recover.c:74
#define BZ_HDR_h
Definition: bzip2recover.c:76
#define BZ_HDR_0
Definition: bzip2recover.c:77
#define BZ_MEM_ERROR
Definition: bzlib.h:40
#define BZ_DATA_ERROR_MAGIC
Definition: bzlib.h:42
#define BZ_OK
Definition: bzlib.h:33
#define BZ_DATA_ERROR
Definition: bzlib.h:41
#define BZ_STREAM_END
Definition: bzlib.h:37
#define BZ_X_MTF_4
#define BZ_X_IDLE
#define BZ_N_GROUPS
#define BZ_X_ENDHDR_5
#define BZ_GET_FAST(cccc)
#define BZ_X_MTF_5
#define BZ_X_SELECTOR_1
#define BZ_X_MTF_3
#define BZ_X_ORIGPTR_3
#define BZ_X_MAGIC_1
#define SET_LL(i, n)
#define BZ_MAX_SELECTORS
#define BZ_X_BLKHDR_1
#define BZALLOC(nnn)
#define GET_LL(i)
#define BZ_X_BLKHDR_2
#define MTFL_SIZE
#define BZ_RAND_UPD_MASK
#define BZ_X_MAPPING_1
#define BZ_X_ORIGPTR_1
#define BZ_X_RANDBIT
#define BZ_X_ORIGPTR_2
#define BZ_X_MAGIC_3
#define BZ_RAND_MASK
#define BZ_X_MTF_6
#define BZ_X_BLKHDR_5
#define BZ_GET_SMALL(cccc)
#define BZ_X_CODING_2
#define BZ_X_ENDHDR_4
#define BZ_X_BCRC_1
#define BZ_X_MAGIC_2
#define BZ_X_CCRC_2
#define BZ_X_CODING_3
#define BZ_X_ENDHDR_2
#define BZ_X_MAGIC_4
#define BZ_RAND_INIT_MASK
#define BZ_RUNA
#define BZ_X_MTF_1
#define MTFA_SIZE
#define BZ_X_SELECTOR_2
void BZ2_hbCreateDecodeTables(Int32 *, Int32 *, Int32 *, UChar *, Int32, Int32, Int32)
Definition: huffman.c:170
#define BZ_X_MTF_2
#define BZ_X_BLKHDR_6
#define BZ_X_BCRC_4
#define BZ_X_CODING_1
#define BZ_X_ENDHDR_3
#define AssertH(cond, errcode)
Definition: bzlib_private.h:59
#define BZ_X_BLKHDR_4
#define BZ_X_BLKHDR_3
#define BZ_X_CCRC_3
#define BZ_INITIALISE_CRC(crcVar)
#define BZ_X_CCRC_1
#define BZ_X_ENDHDR_6
#define BZ_X_OUTPUT
#define VPrintf0(zf)
Definition: bzlib_private.h:73
#define BZ_X_BCRC_2
#define BZ_X_BCRC_3
#define BZ_X_CCRC_4
#define BZ_X_MAPPING_2
#define BZ_RUNB
#define BZ_X_SELECTOR_3
#define VPrintf1(zf, za1)
Definition: bzlib_private.h:75
#define GET_UCHAR(lll, uuu)
Definition: decompress.c:67
#define RETURN(rrr)
Definition: decompress.c:40
Int32 BZ2_decompress(DState *s)
Definition: decompress.c:106
#define GET_MTF_VAL(label1, label2, lval)
Definition: decompress.c:74
static void makeMaps_d(DState *s)
Definition: decompress.c:27
#define GET_BIT(lll, uuu)
Definition: decompress.c:70
#define GET_BITS(lll, vvv, nnn)
Definition: decompress.c:43
static char tmp[3200]
Definition: utf8.c:42
#define NULL
Definition: ncbistd.hpp:225
for(len=0;yy_str[len];++len)
int i
EIPRangeType t
Definition: ncbi_localip.c:101
UInt32 calculatedBlockCRC
Int32 save_zn
bz_stream * strm
Bool smallDecompress
UChar selector[(2+(900000/50))]
Int32 save_nextSym
UChar len[6][258]
Int32 save_alphaSize
Int32 perm[6][258]
Int32 save_t
UInt32 storedBlockCRC
UChar selectorMtf[(2+(900000/50))]
Int32 save_zt
UInt32 storedCombinedCRC
Int32 * save_gLimit
Int32 save_nblock
Int32 save_i
Int32 origPtr
Int32 save_j
Int32 save_gMinlen
Int32 save_EOB
Int32 state_out_len
Int32 currBlockNo
UInt32 * tt
Int32 nblock_used
Int32 state
Int32 save_nGroups
Int32 unzftab[256]
Int32 cftab[257]
Int32 verbosity
Int32 limit[6][258]
Int32 save_nSelectors
Int32 base[6][258]
UChar * ll4
UChar mtfa[4096]
UInt32 tPos
Int32 save_zvec
UChar seqToUnseq[256]
Int32 minLens[6]
UInt16 * ll16
Int32 * save_gPerm
UChar state_out_ch
Int32 k0
Int32 save_gSel
Bool inUse[256]
Int32 save_curr
Int32 save_N
Int32 mtfbase[256/16]
Int32 save_groupPos
Int32 save_zj
Int32 save_groupNo
Int32 nInUse
Bool inUse16[16]
Int32 blockSize100k
Int32 save_nblockMAX
Int32 * save_gBase
Bool blockRandomised
Int32 save_es
Int32 cftabCopy[257]
#define N
Definition: crc32.c:57
Modified on Wed Jun 19 17:02:08 2024 by modify_doxy.py rev. 669887