ReactOS  0.4.13-dev-99-g7e18b6d
decompress.c
Go to the documentation of 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.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 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 
206  GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
207  if (s->blockSize100k < (BZ_HDR_0 + 1) ||
208  s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
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 
251  GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1);
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 > 6) 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  s->selectorMtf[i] = j;
300  }
301 
302  /*--- Undo the MTF values for the selectors. ---*/
303  {
304  UChar pos[BZ_N_GROUPS], tmp, v;
305  for (v = 0; v < nGroups; v++) pos[v] = v;
306 
307  for (i = 0; i < nSelectors; i++) {
308  v = s->selectorMtf[i];
309  tmp = pos[v];
310  while (v > 0) { pos[v] = pos[v-1]; v--; }
311  pos[0] = tmp;
312  s->selector[i] = tmp;
313  }
314  }
315 
316  /*--- Now the coding tables ---*/
317  for (t = 0; t < nGroups; t++) {
318  GET_BITS(BZ_X_CODING_1, curr, 5);
319  for (i = 0; i < alphaSize; i++) {
320  while (True) {
321  if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
322  GET_BIT(BZ_X_CODING_2, uc);
323  if (uc == 0) break;
324  GET_BIT(BZ_X_CODING_3, uc);
325  if (uc == 0) curr++; else curr--;
326  }
327  s->len[t][i] = curr;
328  }
329  }
330 
331  /*--- Create the Huffman decoding tables ---*/
332  for (t = 0; t < nGroups; t++) {
333  minLen = 32;
334  maxLen = 0;
335  for (i = 0; i < alphaSize; i++) {
336  if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
337  if (s->len[t][i] < minLen) minLen = s->len[t][i];
338  }
340  &(s->limit[t][0]),
341  &(s->base[t][0]),
342  &(s->perm[t][0]),
343  &(s->len[t][0]),
344  minLen, maxLen, alphaSize
345  );
346  s->minLens[t] = minLen;
347  }
348 
349  /*--- Now the MTF values ---*/
350 
351  EOB = s->nInUse+1;
352  nblockMAX = 100000 * s->blockSize100k;
353  groupNo = -1;
354  groupPos = 0;
355 
356  for (i = 0; i <= 255; i++) s->unzftab[i] = 0;
357 
358  /*-- MTF init --*/
359  {
360  Int32 ii, jj, kk;
361  kk = MTFA_SIZE-1;
362  for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
363  for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
364  s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
365  kk--;
366  }
367  s->mtfbase[ii] = kk + 1;
368  }
369  }
370  /*-- end MTF init --*/
371 
372  nblock = 0;
373  GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);
374 
375  while (True) {
376 
377  if (nextSym == EOB) break;
378 
379  if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
380 
381  es = -1;
382  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  if (N >= 2*1024*1024) RETURN(BZ_DATA_ERROR);
391  if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
392  if (nextSym == BZ_RUNB) es = es + (1+1) * N;
393  N = N * 2;
394  GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
395  }
396  while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
397 
398  es++;
399  uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
400  s->unzftab[uc] += es;
401 
402  if (s->smallDecompress)
403  while (es > 0) {
404  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
405  s->ll16[nblock] = (UInt16)uc;
406  nblock++;
407  es--;
408  }
409  else
410  while (es > 0) {
411  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
412  s->tt[nblock] = (UInt32)uc;
413  nblock++;
414  es--;
415  };
416 
417  continue;
418 
419  } else {
420 
421  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  nn = (UInt32)(nextSym - 1);
428 
429  if (nn < MTFL_SIZE) {
430  /* avoid general-case expense */
431  pp = s->mtfbase[0];
432  uc = s->mtfa[pp+nn];
433  while (nn > 3) {
434  Int32 z = pp+nn;
435  s->mtfa[(z) ] = s->mtfa[(z)-1];
436  s->mtfa[(z)-1] = s->mtfa[(z)-2];
437  s->mtfa[(z)-2] = s->mtfa[(z)-3];
438  s->mtfa[(z)-3] = s->mtfa[(z)-4];
439  nn -= 4;
440  }
441  while (nn > 0) {
442  s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
443  };
444  s->mtfa[pp] = uc;
445  } else {
446  /* general case */
447  lno = nn / MTFL_SIZE;
448  off = nn % MTFL_SIZE;
449  pp = s->mtfbase[lno] + off;
450  uc = s->mtfa[pp];
451  while (pp > s->mtfbase[lno]) {
452  s->mtfa[pp] = s->mtfa[pp-1]; pp--;
453  };
454  s->mtfbase[lno]++;
455  while (lno > 0) {
456  s->mtfbase[lno]--;
457  s->mtfa[s->mtfbase[lno]]
458  = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
459  lno--;
460  }
461  s->mtfbase[0]--;
462  s->mtfa[s->mtfbase[0]] = uc;
463  if (s->mtfbase[0] == 0) {
464  kk = MTFA_SIZE-1;
465  for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
466  for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
467  s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
468  kk--;
469  }
470  s->mtfbase[ii] = kk + 1;
471  }
472  }
473  }
474  }
475  /*-- end uc = MTF ( nextSym-1 ) --*/
476 
477  s->unzftab[s->seqToUnseq[uc]]++;
478  if (s->smallDecompress)
479  s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
480  s->tt[nblock] = (UInt32)(s->seqToUnseq[uc]);
481  nblock++;
482 
483  GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
484  continue;
485  }
486  }
487 
488  /* Now we know what nblock is, we can do a better sanity
489  check on s->origPtr.
490  */
491  if (s->origPtr < 0 || s->origPtr >= nblock)
493 
494  /*-- Set up cftab to facilitate generation of T^(-1) --*/
495  /* Check: unzftab entries in range. */
496  for (i = 0; i <= 255; i++) {
497  if (s->unzftab[i] < 0 || s->unzftab[i] > nblock)
499  }
500  /* Actually generate cftab. */
501  s->cftab[0] = 0;
502  for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
503  for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
504  /* Check: cftab entries in range. */
505  for (i = 0; i <= 256; i++) {
506  if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
507  /* s->cftab[i] can legitimately be == nblock */
509  }
510  }
511  /* Check: cftab entries non-descending. */
512  for (i = 1; i <= 256; i++) {
513  if (s->cftab[i-1] > s->cftab[i]) {
515  }
516  }
517 
518  s->state_out_len = 0;
519  s->state_out_ch = 0;
520  BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
521  s->state = BZ_X_OUTPUT;
522  if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );
523 
524  if (s->smallDecompress) {
525 
526  /*-- Make a copy of cftab, used in generation of T --*/
527  for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
528 
529  /*-- compute the T vector --*/
530  for (i = 0; i < nblock; i++) {
531  uc = (UChar)(s->ll16[i]);
532  SET_LL(i, s->cftabCopy[uc]);
533  s->cftabCopy[uc]++;
534  }
535 
536  /*-- Compute T^(-1) by pointer reversal on T --*/
537  i = s->origPtr;
538  j = GET_LL(i);
539  do {
540  Int32 tmp = GET_LL(j);
541  SET_LL(j, i);
542  i = j;
543  j = tmp;
544  }
545  while (i != s->origPtr);
546 
547  s->tPos = s->origPtr;
548  s->nblock_used = 0;
549  if (s->blockRandomised) {
551  BZ_GET_SMALL(s->k0); s->nblock_used++;
553  } else {
554  BZ_GET_SMALL(s->k0); s->nblock_used++;
555  }
556 
557  } else {
558 
559  /*-- compute the T^(-1) vector --*/
560  for (i = 0; i < nblock; i++) {
561  uc = (UChar)(s->tt[i] & 0xff);
562  s->tt[s->cftab[uc]] |= (i << 8);
563  s->cftab[uc]++;
564  }
565 
566  s->tPos = s->tt[s->origPtr] >> 8;
567  s->nblock_used = 0;
568  if (s->blockRandomised) {
570  BZ_GET_FAST(s->k0); s->nblock_used++;
572  } else {
573  BZ_GET_FAST(s->k0); s->nblock_used++;
574  }
575 
576  }
577 
578  RETURN(BZ_OK);
579 
580 
581 
582  endhdr_2:
583 
585  if (uc != 0x72) RETURN(BZ_DATA_ERROR);
587  if (uc != 0x45) RETURN(BZ_DATA_ERROR);
589  if (uc != 0x38) RETURN(BZ_DATA_ERROR);
591  if (uc != 0x50) RETURN(BZ_DATA_ERROR);
593  if (uc != 0x90) RETURN(BZ_DATA_ERROR);
594 
595  s->storedCombinedCRC = 0;
596  GET_UCHAR(BZ_X_CCRC_1, uc);
597  s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
598  GET_UCHAR(BZ_X_CCRC_2, uc);
599  s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
600  GET_UCHAR(BZ_X_CCRC_3, uc);
601  s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
602  GET_UCHAR(BZ_X_CCRC_4, uc);
603  s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
604 
605  s->state = BZ_X_IDLE;
607 
608  default: AssertH ( False, 4001 );
609  }
610 
611  AssertH ( False, 4002 );
612 
613  save_state_and_return:
614 
615  s->save_i = i;
616  s->save_j = j;
617  s->save_t = t;
618  s->save_alphaSize = alphaSize;
619  s->save_nGroups = nGroups;
620  s->save_nSelectors = nSelectors;
621  s->save_EOB = EOB;
622  s->save_groupNo = groupNo;
623  s->save_groupPos = groupPos;
624  s->save_nextSym = nextSym;
625  s->save_nblockMAX = nblockMAX;
626  s->save_nblock = nblock;
627  s->save_es = es;
628  s->save_N = N;
629  s->save_curr = curr;
630  s->save_zt = zt;
631  s->save_zn = zn;
632  s->save_zvec = zvec;
633  s->save_zj = zj;
634  s->save_gSel = gSel;
635  s->save_gMinlen = gMinlen;
636  s->save_gLimit = gLimit;
637  s->save_gBase = gBase;
638  s->save_gPerm = gPerm;
639 
640  return retVal;
641 }
642 
643 
644 /*-------------------------------------------------------------*/
645 /*--- end decompress.c ---*/
646 /*-------------------------------------------------------------*/
#define MTFA_SIZE
#define BZ_X_CCRC_3
#define BZ_MEM_ERROR
Definition: bzlib.h:40
#define BZ_X_CODING_1
#define BZ_X_ENDHDR_2
#define GET_BIT(lll, uuu)
Definition: decompress.c:70
#define SET_LL(i, n)
#define BZ_X_MAGIC_4
#define BZ_X_MAGIC_1
DWORD UInt32
Definition: chm_lib.c:106
#define BZ_RAND_INIT_MASK
#define BZ_X_BCRC_1
#define BZ_DATA_ERROR_MAGIC
Definition: bzlib.h:42
#define BZ_GET_FAST(cccc)
#define BZ_X_ORIGPTR_2
GLdouble GLdouble t
Definition: gl.h:2047
#define BZ_X_CCRC_4
#define VPrintf1(zf, za1)
Definition: bzlib_private.h:75
#define BZ_HDR_B
Definition: bzip2recover.c:74
#define GET_UCHAR(lll, uuu)
Definition: decompress.c:67
#define BZ_RAND_MASK
#define BZ_X_MTF_5
BYTE UChar
Definition: chm_lib.c:102
#define BZ_X_MAPPING_2
USHORT UInt16
Definition: chm_lib.c:104
#define BZ_X_CODING_2
#define BZ_X_RANDBIT
static void makeMaps_d(DState *s)
Definition: decompress.c:27
#define BZ_X_MAGIC_2
#define BZ_RUNB
#define BZ_HDR_h
Definition: bzip2recover.c:76
#define BZALLOC(nnn)
#define BZ_HDR_0
Definition: bzip2recover.c:77
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define UInt32
Definition: interfaces.hpp:73
#define BZ_X_BLKHDR_3
#define BZ_X_CCRC_1
#define AssertH(cond, errcode)
Definition: bzlib_private.h:59
Definition: bidi.c:97
#define BZ_X_ENDHDR_3
#define pp
Definition: hlsl.yy.c:978
#define BZ_HDR_Z
Definition: bzip2recover.c:75
GLdouble GLdouble z
Definition: glext.h:5874
smooth NULL
Definition: ftsmooth.c:416
#define GET_BITS(lll, vvv, nnn)
Definition: decompress.c:43
#define BZ_X_BLKHDR_2
#define BZ_X_CODING_3
#define BZ_X_BLKHDR_5
#define BZ_X_SELECTOR_3
#define BZ_OK
Definition: bzlib.h:33
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define BZ_X_OUTPUT
#define BZ_X_BCRC_2
#define True
Definition: types.h:24
#define False
Definition: types.h:25
#define BZ_STREAM_END
Definition: bzlib.h:37
#define BZ_X_SELECTOR_2
Int32 BZ2_decompress(DState *s)
Definition: decompress.c:106
#define BZ_X_CCRC_2
#define UInt16
Definition: interfaces.hpp:74
#define for
Definition: utility.h:88
#define BZ_X_BCRC_3
#define BZ_X_MTF_1
#define BZ_X_ORIGPTR_3
#define BZ_RAND_UPD_MASK
#define BZ_X_MTF_3
#define BZ_X_SELECTOR_1
GLdouble s
Definition: gl.h:2039
#define BZ_X_ENDHDR_4
#define BZ_RUNA
#define BZ_X_ENDHDR_6
#define BZ_N_GROUPS
#define VPrintf0(zf)
Definition: bzlib_private.h:73
#define BZ_X_BLKHDR_1
#define BZ_DATA_ERROR
Definition: bzlib.h:41
const GLdouble * v
Definition: gl.h:2040
#define BZ_X_BLKHDR_4
#define BZ_INITIALISE_CRC(crcVar)
#define BZ_X_BCRC_4
#define BZ_X_MAPPING_1
LONG Int32
Definition: chm_lib.c:105
#define BZ_X_MTF_4
#define BZ_X_MAGIC_3
#define BZ_X_MTF_6
#define GET_LL(i)
#define BZ_X_ORIGPTR_1
#define MTFL_SIZE
#define BZ_X_IDLE
#define es
Definition: i386-dis.c:431
#define BZ_X_BLKHDR_6
#define GET_MTF_VAL(label1, label2, lval)
Definition: decompress.c:74
void BZ2_hbCreateDecodeTables(Int32 *, Int32 *, Int32 *, UChar *, Int32, Int32, Int32)
Definition: huffman.c:170
#define RETURN(rrr)
Definition: decompress.c:40
#define BZ_GET_SMALL(cccc)
#define BZ_X_ENDHDR_5
#define BZ_X_MTF_2
off
Definition: i386-dis.c:3909