Parolin 0.7.9 6796
Console (soon DLLs) to do a tar like job
Loading...
Searching...
No Matches
bzlib_private.h
Go to the documentation of this file.
1
2/*-------------------------------------------------------------*/
3/*--- Private header file for the library. ---*/
4/*--- bzlib_private.h ---*/
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#ifndef _BZLIB_PRIVATE_H
23#define _BZLIB_PRIVATE_H
24
25#include <stdlib.h>
26
27#ifndef BZ_NO_STDIO
28#include <stdio.h>
29#include <ctype.h>
30#include <string.h>
31#endif
32
33#include "bzlib.h"
34
35
36
37/*-- General stuff. --*/
38
39#define BZ_VERSION "1.0.8, 13-Jul-2019"
40
41typedef char Char;
42typedef unsigned char Bool;
43typedef unsigned char UChar;
44typedef int Int32;
45typedef unsigned int UInt32;
46typedef short Int16;
47typedef unsigned short UInt16;
48
49#define True ((Bool)1)
50#define False ((Bool)0)
51
52#ifndef __GNUC__
53#define __inline__ /* */
54#endif
55
56#ifndef BZ_NO_STDIO
57
58extern void BZ2_bz__AssertH__fail ( int errcode );
59#define AssertH(cond,errcode) \
60 { if (!(cond)) BZ2_bz__AssertH__fail ( errcode ); }
61
62#if BZ_DEBUG
63#define AssertD(cond,msg) \
64 { if (!(cond)) { \
65 fprintf ( stderr, \
66 "\n\nlibbzip2(debug build): internal error\n\t%s\n", msg );\
67 exit(1); \
68 }}
69#else
70#define AssertD(cond,msg) /* */
71#endif
72
73#define VPrintf0(zf) \
74 fprintf(stderr,zf)
75#define VPrintf1(zf,za1) \
76 fprintf(stderr,zf,za1)
77#define VPrintf2(zf,za1,za2) \
78 fprintf(stderr,zf,za1,za2)
79#define VPrintf3(zf,za1,za2,za3) \
80 fprintf(stderr,zf,za1,za2,za3)
81#define VPrintf4(zf,za1,za2,za3,za4) \
82 fprintf(stderr,zf,za1,za2,za3,za4)
83#define VPrintf5(zf,za1,za2,za3,za4,za5) \
84 fprintf(stderr,zf,za1,za2,za3,za4,za5)
85
86#else
87
88extern void bz_internal_error ( int errcode );
89#define AssertH(cond,errcode) \
90 { if (!(cond)) bz_internal_error ( errcode ); }
91#define AssertD(cond,msg) do { } while (0)
92#define VPrintf0(zf) do { } while (0)
93#define VPrintf1(zf,za1) do { } while (0)
94#define VPrintf2(zf,za1,za2) do { } while (0)
95#define VPrintf3(zf,za1,za2,za3) do { } while (0)
96#define VPrintf4(zf,za1,za2,za3,za4) do { } while (0)
97#define VPrintf5(zf,za1,za2,za3,za4,za5) do { } while (0)
98
99#endif
100
101
102#define BZALLOC(nnn) (strm->bzalloc)(strm->opaque,(nnn),1)
103#define BZFREE(ppp) (strm->bzfree)(strm->opaque,(ppp))
104
105
106/*-- Header bytes. --*/
107
108#define BZ_HDR_B 0x42 /* 'B' */
109#define BZ_HDR_Z 0x5a /* 'Z' */
110#define BZ_HDR_h 0x68 /* 'h' */
111#define BZ_HDR_0 0x30 /* '0' */
112
113/*-- Constants for the back end. --*/
114
115#define BZ_MAX_ALPHA_SIZE 258
116#define BZ_MAX_CODE_LEN 23
117
118#define BZ_RUNA 0
119#define BZ_RUNB 1
120
121#define BZ_N_GROUPS 6
122#define BZ_G_SIZE 50
123#define BZ_N_ITERS 4
124
125#define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE))
126
127
128
129/*-- Stuff for randomising repetitive blocks. --*/
130
131extern Int32 BZ2_rNums[512];
132
133#define BZ_RAND_DECLS \
134 Int32 rNToGo; \
135 Int32 rTPos \
136
137#define BZ_RAND_INIT_MASK \
138 s->rNToGo = 0; \
139 s->rTPos = 0 \
140
141#define BZ_RAND_MASK ((s->rNToGo == 1) ? 1 : 0)
142
143#define BZ_RAND_UPD_MASK \
144 if (s->rNToGo == 0) { \
145 s->rNToGo = BZ2_rNums[s->rTPos]; \
146 s->rTPos++; \
147 if (s->rTPos == 512) s->rTPos = 0; \
148 } \
149 s->rNToGo--;
150
151
152
153/*-- Stuff for doing CRCs. --*/
154
155extern UInt32 BZ2_crc32Table[256];
156
157#define BZ_INITIALISE_CRC(crcVar) \
158{ \
159 crcVar = 0xffffffffL; \
160}
161
162#define BZ_FINALISE_CRC(crcVar) \
163{ \
164 crcVar = ~(crcVar); \
165}
166
167#define BZ_UPDATE_CRC(crcVar,cha) \
168{ \
169 crcVar = (crcVar << 8) ^ \
170 BZ2_crc32Table[(crcVar >> 24) ^ \
171 ((UChar)cha)]; \
172}
173
174
175
176/*-- States and modes for compression. --*/
177
178#define BZ_M_IDLE 1
179#define BZ_M_RUNNING 2
180#define BZ_M_FLUSHING 3
181#define BZ_M_FINISHING 4
182
183#define BZ_S_OUTPUT 1
184#define BZ_S_INPUT 2
185
186#define BZ_N_RADIX 2
187#define BZ_N_QSORT 12
188#define BZ_N_SHELL 18
189#define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2)
190
191
192
193
194/*-- Structure holding all the compression-side stuff. --*/
195
196typedef
197 struct {
198 /* pointer back to the struct bz_stream */
199 bz_stream* strm;
200
201 /* mode this stream is in, and whether inputting */
202 /* or outputting data */
203 Int32 mode;
204 Int32 state;
205
206 /* remembers avail_in when flush/finish requested */
207 UInt32 avail_in_expect;
208
209 /* for doing the block sorting */
210 UInt32* arr1;
211 UInt32* arr2;
212 UInt32* ftab;
213 Int32 origPtr;
214
215 /* aliases for arr1 and arr2 */
216 UInt32* ptr;
217 UChar* block;
218 UInt16* mtfv;
219 UChar* zbits;
220
221 /* for deciding when to use the fallback sorting algorithm */
222 Int32 workFactor;
223
224 /* run-length-encoding of the input */
225 UInt32 state_in_ch;
226 Int32 state_in_len;
227 BZ_RAND_DECLS;
228
229 /* input and output limits and current posns */
230 Int32 nblock;
231 Int32 nblockMAX;
232 Int32 numZ;
233 Int32 state_out_pos;
234
235 /* map of bytes used in block */
236 Int32 nInUse;
237 Bool inUse[256];
238 UChar unseqToSeq[256];
239
240 /* the buffer for bit stream creation */
241 UInt32 bsBuff;
242 Int32 bsLive;
243
244 /* block and combined CRCs */
245 UInt32 blockCRC;
246 UInt32 combinedCRC;
247
248 /* misc administratium */
249 Int32 verbosity;
250 Int32 blockNo;
251 Int32 blockSize100k;
252
253 /* stuff for coding the MTF values */
254 Int32 nMTF;
255 Int32 mtfFreq [BZ_MAX_ALPHA_SIZE];
256 UChar selector [BZ_MAX_SELECTORS];
257 UChar selectorMtf[BZ_MAX_SELECTORS];
258
259 UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
260 Int32 code [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
261 Int32 rfreq [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
262 /* second dimension: only 3 needed; 4 makes index calculations faster */
263 UInt32 len_pack[BZ_MAX_ALPHA_SIZE][4];
264
265 }
266 EState;
267
268
269
270/*-- externs for compression. --*/
271
272extern void
273BZ2_blockSort ( EState* );
274
275extern void
276BZ2_compressBlock ( EState*, Bool );
277
278extern void
279BZ2_bsInitWrite ( EState* );
280
281extern void
282BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 );
283
284extern void
285BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
286
287
288
289/*-- states for decompression. --*/
290
291#define BZ_X_IDLE 1
292#define BZ_X_OUTPUT 2
293
294#define BZ_X_MAGIC_1 10
295#define BZ_X_MAGIC_2 11
296#define BZ_X_MAGIC_3 12
297#define BZ_X_MAGIC_4 13
298#define BZ_X_BLKHDR_1 14
299#define BZ_X_BLKHDR_2 15
300#define BZ_X_BLKHDR_3 16
301#define BZ_X_BLKHDR_4 17
302#define BZ_X_BLKHDR_5 18
303#define BZ_X_BLKHDR_6 19
304#define BZ_X_BCRC_1 20
305#define BZ_X_BCRC_2 21
306#define BZ_X_BCRC_3 22
307#define BZ_X_BCRC_4 23
308#define BZ_X_RANDBIT 24
309#define BZ_X_ORIGPTR_1 25
310#define BZ_X_ORIGPTR_2 26
311#define BZ_X_ORIGPTR_3 27
312#define BZ_X_MAPPING_1 28
313#define BZ_X_MAPPING_2 29
314#define BZ_X_SELECTOR_1 30
315#define BZ_X_SELECTOR_2 31
316#define BZ_X_SELECTOR_3 32
317#define BZ_X_CODING_1 33
318#define BZ_X_CODING_2 34
319#define BZ_X_CODING_3 35
320#define BZ_X_MTF_1 36
321#define BZ_X_MTF_2 37
322#define BZ_X_MTF_3 38
323#define BZ_X_MTF_4 39
324#define BZ_X_MTF_5 40
325#define BZ_X_MTF_6 41
326#define BZ_X_ENDHDR_2 42
327#define BZ_X_ENDHDR_3 43
328#define BZ_X_ENDHDR_4 44
329#define BZ_X_ENDHDR_5 45
330#define BZ_X_ENDHDR_6 46
331#define BZ_X_CCRC_1 47
332#define BZ_X_CCRC_2 48
333#define BZ_X_CCRC_3 49
334#define BZ_X_CCRC_4 50
335
336
337
338/*-- Constants for the fast MTF decoder. --*/
339
340#define MTFA_SIZE 4096
341#define MTFL_SIZE 16
342
343
344
345/*-- Structure holding all the decompression-side stuff. --*/
346
347typedef
348 struct {
349 /* pointer back to the struct bz_stream */
350 bz_stream* strm;
351
352 /* state indicator for this stream */
353 Int32 state;
354
355 /* for doing the final run-length decoding */
356 UChar state_out_ch;
357 Int32 state_out_len;
358 Bool blockRandomised;
359 BZ_RAND_DECLS;
360
361 /* the buffer for bit stream reading */
362 UInt32 bsBuff;
363 Int32 bsLive;
364
365 /* misc administratium */
366 Int32 blockSize100k;
367 Bool smallDecompress;
368 Int32 currBlockNo;
369 Int32 verbosity;
370
371 /* for undoing the Burrows-Wheeler transform */
372 Int32 origPtr;
373 UInt32 tPos;
374 Int32 k0;
375 Int32 unzftab[256];
376 Int32 nblock_used;
377 Int32 cftab[257];
378 Int32 cftabCopy[257];
379
380 /* for undoing the Burrows-Wheeler transform (FAST) */
381 UInt32 *tt;
382
383 /* for undoing the Burrows-Wheeler transform (SMALL) */
384 UInt16 *ll16;
385 UChar *ll4;
386
387 /* stored and calculated CRCs */
388 UInt32 storedBlockCRC;
389 UInt32 storedCombinedCRC;
390 UInt32 calculatedBlockCRC;
391 UInt32 calculatedCombinedCRC;
392
393 /* map of bytes used in block */
394 Int32 nInUse;
395 Bool inUse[256];
396 Bool inUse16[16];
397 UChar seqToUnseq[256];
398
399 /* for decoding the MTF values */
400 UChar mtfa [MTFA_SIZE];
401 Int32 mtfbase[256 / MTFL_SIZE];
402 UChar selector [BZ_MAX_SELECTORS];
403 UChar selectorMtf[BZ_MAX_SELECTORS];
404 UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
405
406 Int32 limit [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
407 Int32 base [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
408 Int32 perm [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
409 Int32 minLens[BZ_N_GROUPS];
410
411 /* save area for scalars in the main decompress code */
412 Int32 save_i;
413 Int32 save_j;
414 Int32 save_t;
415 Int32 save_alphaSize;
416 Int32 save_nGroups;
417 Int32 save_nSelectors;
418 Int32 save_EOB;
419 Int32 save_groupNo;
420 Int32 save_groupPos;
421 Int32 save_nextSym;
422 Int32 save_nblockMAX;
423 Int32 save_nblock;
424 Int32 save_es;
425 Int32 save_N;
426 Int32 save_curr;
427 Int32 save_zt;
428 Int32 save_zn;
429 Int32 save_zvec;
430 Int32 save_zj;
431 Int32 save_gSel;
432 Int32 save_gMinlen;
433 Int32* save_gLimit;
434 Int32* save_gBase;
435 Int32* save_gPerm;
436
437 }
438 DState;
439
440
441
442/*-- Macros for decompression. --*/
443
444#define BZ_GET_FAST(cccc) \
445 /* c_tPos is unsigned, hence test < 0 is pointless. */ \
446 if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \
447 s->tPos = s->tt[s->tPos]; \
448 cccc = (UChar)(s->tPos & 0xff); \
449 s->tPos >>= 8;
450
451#define BZ_GET_FAST_C(cccc) \
452 /* c_tPos is unsigned, hence test < 0 is pointless. */ \
453 if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return True; \
454 c_tPos = c_tt[c_tPos]; \
455 cccc = (UChar)(c_tPos & 0xff); \
456 c_tPos >>= 8;
457
458#define SET_LL4(i,n) \
459 { if (((i) & 0x1) == 0) \
460 s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0xf0) | (n); else \
461 s->ll4[(i) >> 1] = (s->ll4[(i) >> 1] & 0x0f) | ((n) << 4); \
462 }
463
464#define GET_LL4(i) \
465 ((((UInt32)(s->ll4[(i) >> 1])) >> (((i) << 2) & 0x4)) & 0xF)
466
467#define SET_LL(i,n) \
468 { s->ll16[i] = (UInt16)(n & 0x0000ffff); \
469 SET_LL4(i, n >> 16); \
470 }
471
472#define GET_LL(i) \
473 (((UInt32)s->ll16[i]) | (GET_LL4(i) << 16))
474
475#define BZ_GET_SMALL(cccc) \
476 /* c_tPos is unsigned, hence test < 0 is pointless. */ \
477 if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k) return True; \
478 cccc = BZ2_indexIntoF ( s->tPos, s->cftab ); \
479 s->tPos = GET_LL(s->tPos);
480
481
482/*-- externs for decompression. --*/
483
484extern Int32
485BZ2_indexIntoF ( Int32, Int32* );
486
487extern Int32
488BZ2_decompress ( DState* );
489
490extern void
491BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
492 Int32, Int32, Int32 );
493
494
495#endif
496
497
498/*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/
499
500#ifdef BZ_NO_STDIO
501#ifndef NULL
502#define NULL 0
503#endif
504#endif
505
506
507/*-------------------------------------------------------------*/
508/*--- end bzlib_private.h ---*/
509/*-------------------------------------------------------------*/
blockSize100k
Int32 blockSize100k
Definition bzip2.c.old.c:186
workFactor
Int32 workFactor
Definition bzip2.c.old.c:211
verbosity
Int32 verbosity
Definition bzip2.c.old.c:183
DState
Definition bzlib_private.h:348
EState
Definition bzlib_private.h:197
bz_stream
Definition bzlib.h:49
code
Definition inftrees.h:24
block
Definition tar.h:373
BZ_N_GROUPS
#define BZ_N_GROUPS
Definition bzlib_private.h:121
BZ2_rNums
Int32 BZ2_rNums[512]
Definition randtable.c:26
Bool
unsigned char Bool
Definition bzlib_private.h:42
BZ2_compressBlock
void BZ2_compressBlock(EState *, Bool)
Definition compress.c:602
BZ_MAX_SELECTORS
#define BZ_MAX_SELECTORS
Definition bzlib_private.h:125
Int16
short Int16
Definition bzlib_private.h:46
MTFL_SIZE
#define MTFL_SIZE
Definition bzlib_private.h:341
UInt32
unsigned int UInt32
Definition bzlib_private.h:45
UChar
unsigned char UChar
Definition bzlib_private.h:43
Char
char Char
Definition bzlib_private.h:41
BZ2_indexIntoF
Int32 BZ2_indexIntoF(Int32, Int32 *)
Definition bzlib.c:814
BZ2_crc32Table
UInt32 BZ2_crc32Table[256]
Definition crctable.c:31
MTFA_SIZE
#define MTFA_SIZE
Definition bzlib_private.h:340
BZ2_hbAssignCodes
void BZ2_hbAssignCodes(Int32 *, UChar *, Int32, Int32, Int32)
Definition huffman.c:152
BZ2_hbCreateDecodeTables
void BZ2_hbCreateDecodeTables(Int32 *, Int32 *, Int32 *, UChar *, Int32, Int32, Int32)
Definition huffman.c:170
BZ2_bsInitWrite
void BZ2_bsInitWrite(EState *)
Definition compress.c:37
UInt16
unsigned short UInt16
Definition bzlib_private.h:47
BZ2_bz__AssertH__fail
void BZ2_bz__AssertH__fail(int errcode)
Definition bzlib.c:45
BZ2_decompress
Int32 BZ2_decompress(DState *)
Definition decompress.c:106
BZ2_blockSort
void BZ2_blockSort(EState *)
Definition blocksort.c:1031
Int32
int Int32
Definition bzlib_private.h:44
BZ_MAX_ALPHA_SIZE
#define BZ_MAX_ALPHA_SIZE
Definition bzlib_private.h:115
BZ2_hbMakeCodeLengths
void BZ2_hbMakeCodeLengths(UChar *, Int32 *, Int32, Int32)
Definition huffman.c:63
bzlib.h
BZ_RAND_DECLS
#define BZ_RAND_DECLS
Definition bzlib_private.h:133
len
static uint32_t const uint8_t uint32_t len
Definition memcmplen.h:44
limit
static uint32_t const uint8_t uint32_t uint32_t limit
Definition memcmplen.h:45
Generated by doxygen 1.12.0