File: | obj/gnu/usr.bin/perl/cpan/Compress-Raw-Bzip2/bzlib.c |
Warning: | line 450, column 10 Value stored to 'progress' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | |
2 | /*-------------------------------------------------------------*/ |
3 | /*--- Library top-level functions. ---*/ |
4 | /*--- bzlib.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 | /* CHANGES |
22 | 0.9.0 -- original version. |
23 | 0.9.0a/b -- no changes in this file. |
24 | 0.9.0c -- made zero-length BZ_FLUSH work correctly in bzCompress(). |
25 | fixed bzWrite/bzRead to ignore zero-length requests. |
26 | fixed bzread to correctly handle read requests after EOF. |
27 | wrong parameter order in call to bzDecompressInit in |
28 | bzBuffToBuffDecompress. Fixed. |
29 | */ |
30 | |
31 | #include "bzlib_private.h" |
32 | |
33 | |
34 | /*---------------------------------------------------*/ |
35 | /*--- Compression stuff ---*/ |
36 | /*---------------------------------------------------*/ |
37 | |
38 | |
39 | /*---------------------------------------------------*/ |
40 | #ifndef BZ_NO_STDIO1 |
41 | void BZ2_bz__AssertH__fail ( int errcode ) |
42 | { |
43 | fprintf(stderr, |
44 | "\n\nbzip2/libbzip2: internal error number %d.\n" |
45 | "This is a bug in bzip2/libbzip2, %s.\n" |
46 | "Please report it to: bzip2-devel@sourceware.org. If this happened\n" |
47 | "when you were using some program which uses libbzip2 as a\n" |
48 | "component, you should also report this bug to the author(s)\n" |
49 | "of that program. Please make an effort to report this bug;\n" |
50 | "timely and accurate bug reports eventually lead to higher\n" |
51 | "quality software. Thanks.\n\n", |
52 | errcode, |
53 | BZ2_bzlibVersion() |
54 | ); |
55 | |
56 | if (errcode == 1007) { |
57 | fprintf(stderr, |
58 | "\n*** A special note about internal error number 1007 ***\n" |
59 | "\n" |
60 | "Experience suggests that a common cause of i.e. 1007\n" |
61 | "is unreliable memory or other hardware. The 1007 assertion\n" |
62 | "just happens to cross-check the results of huge numbers of\n" |
63 | "memory reads/writes, and so acts (unintendedly) as a stress\n" |
64 | "test of your memory system.\n" |
65 | "\n" |
66 | "I suggest the following: try compressing the file again,\n" |
67 | "possibly monitoring progress in detail with the -vv flag.\n" |
68 | "\n" |
69 | "* If the error cannot be reproduced, and/or happens at different\n" |
70 | " points in compression, you may have a flaky memory system.\n" |
71 | " Try a memory-test program. I have used Memtest86\n" |
72 | " (www.memtest86.com). At the time of writing it is free (GPLd).\n" |
73 | " Memtest86 tests memory much more thorougly than your BIOSs\n" |
74 | " power-on test, and may find failures that the BIOS doesn't.\n" |
75 | "\n" |
76 | "* If the error can be repeatably reproduced, this is a bug in\n" |
77 | " bzip2, and I would very much like to hear about it. Please\n" |
78 | " let me know, and, ideally, save a copy of the file causing the\n" |
79 | " problem -- without which I will be unable to investigate it.\n" |
80 | "\n" |
81 | ); |
82 | } |
83 | |
84 | exit(3); |
85 | } |
86 | #endif |
87 | |
88 | |
89 | /*---------------------------------------------------*/ |
90 | static |
91 | int bz_config_ok ( void ) |
92 | { |
93 | if (sizeof(int) != 4) return 0; |
94 | if (sizeof(short) != 2) return 0; |
95 | if (sizeof(char) != 1) return 0; |
96 | return 1; |
97 | } |
98 | |
99 | |
100 | /*---------------------------------------------------*/ |
101 | static |
102 | void* default_bzalloc ( void* opaque, Int32 items, Int32 size ) |
103 | { |
104 | void* v = malloc ( items * size ); |
105 | ((void)opaque); /* Silence unused parameter warning */ |
106 | |
107 | return v; |
108 | } |
109 | |
110 | static |
111 | void default_bzfree ( void* opaque, void* addr ) |
112 | { |
113 | ((void)opaque); /* Silence unused parameter warning */ |
114 | |
115 | if (addr != NULL((void *)0)) free ( addr ); |
116 | } |
117 | |
118 | |
119 | /*---------------------------------------------------*/ |
120 | static |
121 | void prepare_new_block ( EState* s ) |
122 | { |
123 | Int32 i; |
124 | s->nblock = 0; |
125 | s->numZ = 0; |
126 | s->state_out_pos = 0; |
127 | BZ_INITIALISE_CRC ( s->blockCRC ){ s->blockCRC = 0xffffffffL; }; |
128 | for (i = 0; i < 256; i++) s->inUse[i] = False((Bool)0); |
129 | s->blockNo++; |
130 | } |
131 | |
132 | |
133 | /*---------------------------------------------------*/ |
134 | static |
135 | void init_RL ( EState* s ) |
136 | { |
137 | s->state_in_ch = 256; |
138 | s->state_in_len = 0; |
139 | } |
140 | |
141 | |
142 | static |
143 | Bool isempty_RL ( EState* s ) |
144 | { |
145 | if (s->state_in_ch < 256 && s->state_in_len > 0) |
146 | return False((Bool)0); else |
147 | return True((Bool)1); |
148 | } |
149 | |
150 | |
151 | /*---------------------------------------------------*/ |
152 | int BZ_API(BZ2_bzCompressInit)BZ2_bzCompressInit |
153 | ( bz_stream* strm, |
154 | int blockSize100k, |
155 | int verbosity, |
156 | int workFactor ) |
157 | { |
158 | Int32 n; |
159 | EState* s; |
160 | |
161 | if (!bz_config_ok()) return BZ_CONFIG_ERROR(-9); |
162 | |
163 | if (strm == NULL((void *)0) || |
164 | blockSize100k < 1 || blockSize100k > 9 || |
165 | workFactor < 0 || workFactor > 250) |
166 | return BZ_PARAM_ERROR(-2); |
167 | |
168 | if (workFactor == 0) workFactor = 30; |
169 | if (strm->bzalloc == NULL((void *)0)) strm->bzalloc = default_bzalloc; |
170 | if (strm->bzfree == NULL((void *)0)) strm->bzfree = default_bzfree; |
171 | |
172 | s = (EState*) BZALLOC( sizeof(EState) )(strm->bzalloc)(strm->opaque,(sizeof(EState)),1); |
173 | if (s == NULL((void *)0)) return BZ_MEM_ERROR(-3); |
174 | s->strm = strm; |
175 | |
176 | s->arr1 = NULL((void *)0); |
177 | s->arr2 = NULL((void *)0); |
178 | s->ftab = NULL((void *)0); |
179 | |
180 | n = 100000 * blockSize100k; |
181 | s->arr1 = (UInt32*) BZALLOC( n * sizeof(UInt32) )(strm->bzalloc)(strm->opaque,(n * sizeof(UInt32)),1); |
182 | s->arr2 = (UInt32*) BZALLOC( (n+BZ_N_OVERSHOOT) * sizeof(UInt32) )(strm->bzalloc)(strm->opaque,((n+(2 + 12 + 18 + 2)) * sizeof (UInt32)),1); |
183 | s->ftab = (UInt32*) BZALLOC( 65537 * sizeof(UInt32) )(strm->bzalloc)(strm->opaque,(65537 * sizeof(UInt32)),1 ); |
184 | |
185 | if (s->arr1 == NULL((void *)0) || s->arr2 == NULL((void *)0) || s->ftab == NULL((void *)0)) { |
186 | if (s->arr1 != NULL((void *)0)) BZFREE(s->arr1)(strm->bzfree)(strm->opaque,(s->arr1)); |
187 | if (s->arr2 != NULL((void *)0)) BZFREE(s->arr2)(strm->bzfree)(strm->opaque,(s->arr2)); |
188 | if (s->ftab != NULL((void *)0)) BZFREE(s->ftab)(strm->bzfree)(strm->opaque,(s->ftab)); |
189 | if (s != NULL((void *)0)) BZFREE(s)(strm->bzfree)(strm->opaque,(s)); |
190 | return BZ_MEM_ERROR(-3); |
191 | } |
192 | |
193 | s->blockNo = 0; |
194 | s->state = BZ_S_INPUT2; |
195 | s->mode = BZ_M_RUNNING2; |
196 | s->combinedCRC = 0; |
197 | s->blockSize100k = blockSize100k; |
198 | s->nblockMAX = 100000 * blockSize100k - 19; |
199 | s->verbosity = verbosity; |
200 | s->workFactor = workFactor; |
201 | |
202 | s->block = (UChar*)s->arr2; |
203 | s->mtfv = (UInt16*)s->arr1; |
204 | s->zbits = NULL((void *)0); |
205 | s->ptr = (UInt32*)s->arr1; |
206 | |
207 | strm->state = s; |
208 | strm->total_in_lo32 = 0; |
209 | strm->total_in_hi32 = 0; |
210 | strm->total_out_lo32 = 0; |
211 | strm->total_out_hi32 = 0; |
212 | init_RL ( s ); |
213 | prepare_new_block ( s ); |
214 | return BZ_OK0; |
215 | } |
216 | |
217 | |
218 | /*---------------------------------------------------*/ |
219 | static |
220 | void add_pair_to_block ( EState* s ) |
221 | { |
222 | Int32 i; |
223 | UChar ch = (UChar)(s->state_in_ch); |
224 | for (i = 0; i < s->state_in_len; i++) { |
225 | BZ_UPDATE_CRC( s->blockCRC, ch ){ s->blockCRC = (s->blockCRC << 8) ^ BZ2_crc32Table [(s->blockCRC >> 24) ^ ((UChar)ch)]; }; |
226 | } |
227 | s->inUse[s->state_in_ch] = True((Bool)1); |
228 | switch (s->state_in_len) { |
229 | case 1: |
230 | s->block[s->nblock] = (UChar)ch; s->nblock++; |
231 | break; |
232 | case 2: |
233 | s->block[s->nblock] = (UChar)ch; s->nblock++; |
234 | s->block[s->nblock] = (UChar)ch; s->nblock++; |
235 | break; |
236 | case 3: |
237 | s->block[s->nblock] = (UChar)ch; s->nblock++; |
238 | s->block[s->nblock] = (UChar)ch; s->nblock++; |
239 | s->block[s->nblock] = (UChar)ch; s->nblock++; |
240 | break; |
241 | default: |
242 | s->inUse[s->state_in_len-4] = True((Bool)1); |
243 | s->block[s->nblock] = (UChar)ch; s->nblock++; |
244 | s->block[s->nblock] = (UChar)ch; s->nblock++; |
245 | s->block[s->nblock] = (UChar)ch; s->nblock++; |
246 | s->block[s->nblock] = (UChar)ch; s->nblock++; |
247 | s->block[s->nblock] = ((UChar)(s->state_in_len-4)); |
248 | s->nblock++; |
249 | break; |
250 | } |
251 | } |
252 | |
253 | |
254 | /*---------------------------------------------------*/ |
255 | static |
256 | void flush_RL ( EState* s ) |
257 | { |
258 | if (s->state_in_ch < 256) add_pair_to_block ( s ); |
259 | init_RL ( s ); |
260 | } |
261 | |
262 | |
263 | /*---------------------------------------------------*/ |
264 | #define ADD_CHAR_TO_BLOCK(zs,zchh0){ UInt32 zchh = (UInt32)(zchh0); if (zchh != zs->state_in_ch && zs->state_in_len == 1) { UChar ch = (UChar)(zs ->state_in_ch); { zs->blockCRC = (zs->blockCRC << 8) ^ BZ2_crc32Table[(zs->blockCRC >> 24) ^ ((UChar) ch)]; }; zs->inUse[zs->state_in_ch] = ((Bool)1); zs-> block[zs->nblock] = (UChar)ch; zs->nblock++; zs->state_in_ch = zchh; } else if (zchh != zs->state_in_ch || zs->state_in_len == 255) { if (zs->state_in_ch < 256) add_pair_to_block ( zs ); zs->state_in_ch = zchh; zs->state_in_len = 1; } else { zs->state_in_len++; } } \ |
265 | { \ |
266 | UInt32 zchh = (UInt32)(zchh0); \ |
267 | /*-- fast track the common case --*/ \ |
268 | if (zchh != zs->state_in_ch && \ |
269 | zs->state_in_len == 1) { \ |
270 | UChar ch = (UChar)(zs->state_in_ch); \ |
271 | BZ_UPDATE_CRC( zs->blockCRC, ch ){ zs->blockCRC = (zs->blockCRC << 8) ^ BZ2_crc32Table [(zs->blockCRC >> 24) ^ ((UChar)ch)]; }; \ |
272 | zs->inUse[zs->state_in_ch] = True((Bool)1); \ |
273 | zs->block[zs->nblock] = (UChar)ch; \ |
274 | zs->nblock++; \ |
275 | zs->state_in_ch = zchh; \ |
276 | } \ |
277 | else \ |
278 | /*-- general, uncommon cases --*/ \ |
279 | if (zchh != zs->state_in_ch || \ |
280 | zs->state_in_len == 255) { \ |
281 | if (zs->state_in_ch < 256) \ |
282 | add_pair_to_block ( zs ); \ |
283 | zs->state_in_ch = zchh; \ |
284 | zs->state_in_len = 1; \ |
285 | } else { \ |
286 | zs->state_in_len++; \ |
287 | } \ |
288 | } |
289 | |
290 | |
291 | /*---------------------------------------------------*/ |
292 | static |
293 | Bool copy_input_until_stop ( EState* s ) |
294 | { |
295 | Bool progress_in = False((Bool)0); |
296 | |
297 | if (s->mode == BZ_M_RUNNING2) { |
298 | |
299 | /*-- fast track the common case --*/ |
300 | while (True((Bool)1)) { |
301 | /*-- block full? --*/ |
302 | if (s->nblock >= s->nblockMAX) break; |
303 | /*-- no input? --*/ |
304 | if (s->strm->avail_in == 0) break; |
305 | progress_in = True((Bool)1); |
306 | ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) ){ UInt32 zchh = (UInt32)((UInt32)(*((UChar*)(s->strm->next_in )))); if (zchh != s->state_in_ch && s->state_in_len == 1) { UChar ch = (UChar)(s->state_in_ch); { s->blockCRC = (s->blockCRC << 8) ^ BZ2_crc32Table[(s->blockCRC >> 24) ^ ((UChar)ch)]; }; s->inUse[s->state_in_ch ] = ((Bool)1); s->block[s->nblock] = (UChar)ch; s->nblock ++; s->state_in_ch = zchh; } else if (zchh != s->state_in_ch || s->state_in_len == 255) { if (s->state_in_ch < 256 ) add_pair_to_block ( s ); s->state_in_ch = zchh; s->state_in_len = 1; } else { s->state_in_len++; } }; |
307 | s->strm->next_in++; |
308 | s->strm->avail_in--; |
309 | s->strm->total_in_lo32++; |
310 | if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; |
311 | } |
312 | |
313 | } else { |
314 | |
315 | /*-- general, uncommon case --*/ |
316 | while (True((Bool)1)) { |
317 | /*-- block full? --*/ |
318 | if (s->nblock >= s->nblockMAX) break; |
319 | /*-- no input? --*/ |
320 | if (s->strm->avail_in == 0) break; |
321 | /*-- flush/finish end? --*/ |
322 | if (s->avail_in_expect == 0) break; |
323 | progress_in = True((Bool)1); |
324 | ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) ){ UInt32 zchh = (UInt32)((UInt32)(*((UChar*)(s->strm->next_in )))); if (zchh != s->state_in_ch && s->state_in_len == 1) { UChar ch = (UChar)(s->state_in_ch); { s->blockCRC = (s->blockCRC << 8) ^ BZ2_crc32Table[(s->blockCRC >> 24) ^ ((UChar)ch)]; }; s->inUse[s->state_in_ch ] = ((Bool)1); s->block[s->nblock] = (UChar)ch; s->nblock ++; s->state_in_ch = zchh; } else if (zchh != s->state_in_ch || s->state_in_len == 255) { if (s->state_in_ch < 256 ) add_pair_to_block ( s ); s->state_in_ch = zchh; s->state_in_len = 1; } else { s->state_in_len++; } }; |
325 | s->strm->next_in++; |
326 | s->strm->avail_in--; |
327 | s->strm->total_in_lo32++; |
328 | if (s->strm->total_in_lo32 == 0) s->strm->total_in_hi32++; |
329 | s->avail_in_expect--; |
330 | } |
331 | } |
332 | return progress_in; |
333 | } |
334 | |
335 | |
336 | /*---------------------------------------------------*/ |
337 | static |
338 | Bool copy_output_until_stop ( EState* s ) |
339 | { |
340 | Bool progress_out = False((Bool)0); |
341 | |
342 | while (True((Bool)1)) { |
343 | |
344 | /*-- no output space? --*/ |
345 | if (s->strm->avail_out == 0) break; |
346 | |
347 | /*-- block done? --*/ |
348 | if (s->state_out_pos >= s->numZ) break; |
349 | |
350 | progress_out = True((Bool)1); |
351 | *(s->strm->next_out) = s->zbits[s->state_out_pos]; |
352 | s->state_out_pos++; |
353 | s->strm->avail_out--; |
354 | s->strm->next_out++; |
355 | s->strm->total_out_lo32++; |
356 | if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; |
357 | } |
358 | |
359 | return progress_out; |
360 | } |
361 | |
362 | |
363 | /*---------------------------------------------------*/ |
364 | static |
365 | Bool handle_compress ( bz_stream* strm ) |
366 | { |
367 | Bool progress_in = False((Bool)0); |
368 | Bool progress_out = False((Bool)0); |
369 | EState* s = (EState*) strm->state; |
370 | |
371 | while (True((Bool)1)) { |
372 | |
373 | if (s->state == BZ_S_OUTPUT1) { |
374 | progress_out |= copy_output_until_stop ( s ); |
375 | if (s->state_out_pos < s->numZ) break; |
376 | if (s->mode == BZ_M_FINISHING4 && |
377 | s->avail_in_expect == 0 && |
378 | isempty_RL(s)) break; |
379 | prepare_new_block ( s ); |
380 | s->state = BZ_S_INPUT2; |
381 | if (s->mode == BZ_M_FLUSHING3 && |
382 | s->avail_in_expect == 0 && |
383 | isempty_RL(s)) break; |
384 | } |
385 | |
386 | if (s->state == BZ_S_INPUT2) { |
387 | progress_in |= copy_input_until_stop ( s ); |
388 | if (s->mode != BZ_M_RUNNING2 && s->avail_in_expect == 0) { |
389 | flush_RL ( s ); |
390 | BZ2_compressBlock ( s, (Bool)(s->mode == BZ_M_FINISHING4) ); |
391 | s->state = BZ_S_OUTPUT1; |
392 | } |
393 | else |
394 | if (s->nblock >= s->nblockMAX) { |
395 | BZ2_compressBlock ( s, False((Bool)0) ); |
396 | s->state = BZ_S_OUTPUT1; |
397 | } |
398 | else |
399 | if (s->strm->avail_in == 0) { |
400 | break; |
401 | } |
402 | } |
403 | |
404 | } |
405 | |
406 | return progress_in || progress_out; |
407 | } |
408 | |
409 | |
410 | /*---------------------------------------------------*/ |
411 | int BZ_API(BZ2_bzCompress)BZ2_bzCompress ( bz_stream *strm, int action ) |
412 | { |
413 | Bool progress; |
414 | EState* s; |
415 | if (strm == NULL((void *)0)) return BZ_PARAM_ERROR(-2); |
416 | s = (EState*) strm->state; |
417 | if (s == NULL((void *)0)) return BZ_PARAM_ERROR(-2); |
418 | if (s->strm != strm) return BZ_PARAM_ERROR(-2); |
419 | |
420 | preswitch: |
421 | switch (s->mode) { |
422 | |
423 | case BZ_M_IDLE1: |
424 | return BZ_SEQUENCE_ERROR(-1); |
425 | |
426 | case BZ_M_RUNNING2: |
427 | if (action == BZ_RUN0) { |
428 | progress = handle_compress ( strm ); |
429 | return progress ? BZ_RUN_OK1 : BZ_PARAM_ERROR(-2); |
430 | } |
431 | else |
432 | if (action == BZ_FLUSH1) { |
433 | s->avail_in_expect = strm->avail_in; |
434 | s->mode = BZ_M_FLUSHING3; |
435 | goto preswitch; |
436 | } |
437 | else |
438 | if (action == BZ_FINISH2) { |
439 | s->avail_in_expect = strm->avail_in; |
440 | s->mode = BZ_M_FINISHING4; |
441 | goto preswitch; |
442 | } |
443 | else |
444 | return BZ_PARAM_ERROR(-2); |
445 | |
446 | case BZ_M_FLUSHING3: |
447 | if (action != BZ_FLUSH1) return BZ_SEQUENCE_ERROR(-1); |
448 | if (s->avail_in_expect != s->strm->avail_in) |
449 | return BZ_SEQUENCE_ERROR(-1); |
450 | progress = handle_compress ( strm ); |
Value stored to 'progress' is never read | |
451 | if (s->avail_in_expect > 0 || !isempty_RL(s) || |
452 | s->state_out_pos < s->numZ) return BZ_FLUSH_OK2; |
453 | s->mode = BZ_M_RUNNING2; |
454 | return BZ_RUN_OK1; |
455 | |
456 | case BZ_M_FINISHING4: |
457 | if (action != BZ_FINISH2) return BZ_SEQUENCE_ERROR(-1); |
458 | if (s->avail_in_expect != s->strm->avail_in) |
459 | return BZ_SEQUENCE_ERROR(-1); |
460 | progress = handle_compress ( strm ); |
461 | if (!progress) return BZ_SEQUENCE_ERROR(-1); |
462 | if (s->avail_in_expect > 0 || !isempty_RL(s) || |
463 | s->state_out_pos < s->numZ) return BZ_FINISH_OK3; |
464 | s->mode = BZ_M_IDLE1; |
465 | return BZ_STREAM_END4; |
466 | } |
467 | return BZ_OK0; /*--not reached--*/ |
468 | } |
469 | |
470 | |
471 | /*---------------------------------------------------*/ |
472 | int BZ_API(BZ2_bzCompressEnd)BZ2_bzCompressEnd ( bz_stream *strm ) |
473 | { |
474 | EState* s; |
475 | if (strm == NULL((void *)0)) return BZ_PARAM_ERROR(-2); |
476 | s = (EState*) strm->state; |
477 | if (s == NULL((void *)0)) return BZ_PARAM_ERROR(-2); |
478 | if (s->strm != strm) return BZ_PARAM_ERROR(-2); |
479 | |
480 | if (s->arr1 != NULL((void *)0)) BZFREE(s->arr1)(strm->bzfree)(strm->opaque,(s->arr1)); |
481 | if (s->arr2 != NULL((void *)0)) BZFREE(s->arr2)(strm->bzfree)(strm->opaque,(s->arr2)); |
482 | if (s->ftab != NULL((void *)0)) BZFREE(s->ftab)(strm->bzfree)(strm->opaque,(s->ftab)); |
483 | BZFREE(strm->state)(strm->bzfree)(strm->opaque,(strm->state)); |
484 | |
485 | strm->state = NULL((void *)0); |
486 | |
487 | return BZ_OK0; |
488 | } |
489 | |
490 | |
491 | /*---------------------------------------------------*/ |
492 | /*--- Decompression stuff ---*/ |
493 | /*---------------------------------------------------*/ |
494 | |
495 | /*---------------------------------------------------*/ |
496 | int BZ_API(BZ2_bzDecompressInit)BZ2_bzDecompressInit |
497 | ( bz_stream* strm, |
498 | int verbosity, |
499 | int small ) |
500 | { |
501 | DState* s; |
502 | |
503 | if (!bz_config_ok()) return BZ_CONFIG_ERROR(-9); |
504 | |
505 | if (strm == NULL((void *)0)) return BZ_PARAM_ERROR(-2); |
506 | if (small != 0 && small != 1) return BZ_PARAM_ERROR(-2); |
507 | if (verbosity < 0 || verbosity > 4) return BZ_PARAM_ERROR(-2); |
508 | |
509 | if (strm->bzalloc == NULL((void *)0)) strm->bzalloc = default_bzalloc; |
510 | if (strm->bzfree == NULL((void *)0)) strm->bzfree = default_bzfree; |
511 | |
512 | s = (DState*) BZALLOC( sizeof(DState) )(strm->bzalloc)(strm->opaque,(sizeof(DState)),1); |
513 | if (s == NULL((void *)0)) return BZ_MEM_ERROR(-3); |
514 | s->strm = strm; |
515 | strm->state = s; |
516 | s->state = BZ_X_MAGIC_110; |
517 | s->bsLive = 0; |
518 | s->bsBuff = 0; |
519 | s->calculatedCombinedCRC = 0; |
520 | strm->total_in_lo32 = 0; |
521 | strm->total_in_hi32 = 0; |
522 | strm->total_out_lo32 = 0; |
523 | strm->total_out_hi32 = 0; |
524 | s->smallDecompress = (Bool)small; |
525 | s->ll4 = NULL((void *)0); |
526 | s->ll16 = NULL((void *)0); |
527 | s->tt = NULL((void *)0); |
528 | s->currBlockNo = 0; |
529 | s->verbosity = verbosity; |
530 | |
531 | return BZ_OK0; |
532 | } |
533 | |
534 | |
535 | /*---------------------------------------------------*/ |
536 | /* Return True iff data corruption is discovered. |
537 | Returns False if there is no problem. |
538 | */ |
539 | static |
540 | Bool unRLE_obuf_to_output_FAST ( DState* s ) |
541 | { |
542 | UChar k1; |
543 | |
544 | if (s->blockRandomised) { |
545 | |
546 | while (True((Bool)1)) { |
547 | /* try to finish existing run */ |
548 | while (True((Bool)1)) { |
549 | if (s->strm->avail_out == 0) return False((Bool)0); |
550 | if (s->state_out_len == 0) break; |
551 | *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; |
552 | BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ){ s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ ((UChar)s->state_out_ch)]; }; |
553 | s->state_out_len--; |
554 | s->strm->next_out++; |
555 | s->strm->avail_out--; |
556 | s->strm->total_out_lo32++; |
557 | if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; |
558 | } |
559 | |
560 | /* can a new run be started? */ |
561 | if (s->nblock_used == s->save_nblock+1) return False((Bool)0); |
562 | |
563 | /* Only caused by corrupt data stream? */ |
564 | if (s->nblock_used > s->save_nblock+1) |
565 | return True((Bool)1); |
566 | |
567 | s->state_out_len = 1; |
568 | s->state_out_ch = s->k0; |
569 | BZ_GET_FAST(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); s->tPos = s->tt[s->tPos]; k1 = ( UChar)(s->tPos & 0xff); s->tPos >>= 8;; BZ_RAND_UPD_MASKif (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos ]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s ->rNToGo--;; |
570 | k1 ^= BZ_RAND_MASK((s->rNToGo == 1) ? 1 : 0); s->nblock_used++; |
571 | if (s->nblock_used == s->save_nblock+1) continue; |
572 | if (k1 != s->k0) { s->k0 = k1; continue; }; |
573 | |
574 | s->state_out_len = 2; |
575 | BZ_GET_FAST(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); s->tPos = s->tt[s->tPos]; k1 = ( UChar)(s->tPos & 0xff); s->tPos >>= 8;; BZ_RAND_UPD_MASKif (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos ]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s ->rNToGo--;; |
576 | k1 ^= BZ_RAND_MASK((s->rNToGo == 1) ? 1 : 0); s->nblock_used++; |
577 | if (s->nblock_used == s->save_nblock+1) continue; |
578 | if (k1 != s->k0) { s->k0 = k1; continue; }; |
579 | |
580 | s->state_out_len = 3; |
581 | BZ_GET_FAST(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); s->tPos = s->tt[s->tPos]; k1 = ( UChar)(s->tPos & 0xff); s->tPos >>= 8;; BZ_RAND_UPD_MASKif (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos ]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s ->rNToGo--;; |
582 | k1 ^= BZ_RAND_MASK((s->rNToGo == 1) ? 1 : 0); s->nblock_used++; |
583 | if (s->nblock_used == s->save_nblock+1) continue; |
584 | if (k1 != s->k0) { s->k0 = k1; continue; }; |
585 | |
586 | BZ_GET_FAST(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); s->tPos = s->tt[s->tPos]; k1 = ( UChar)(s->tPos & 0xff); s->tPos >>= 8;; BZ_RAND_UPD_MASKif (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos ]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s ->rNToGo--;; |
587 | k1 ^= BZ_RAND_MASK((s->rNToGo == 1) ? 1 : 0); s->nblock_used++; |
588 | s->state_out_len = ((Int32)k1) + 4; |
589 | BZ_GET_FAST(s->k0)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); s->tPos = s->tt[s->tPos]; s-> k0 = (UChar)(s->tPos & 0xff); s->tPos >>= 8;; BZ_RAND_UPD_MASKif (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos ]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s ->rNToGo--;; |
590 | s->k0 ^= BZ_RAND_MASK((s->rNToGo == 1) ? 1 : 0); s->nblock_used++; |
591 | } |
592 | |
593 | } else { |
594 | |
595 | /* restore */ |
596 | UInt32 c_calculatedBlockCRC = s->calculatedBlockCRC; |
597 | UChar c_state_out_ch = s->state_out_ch; |
598 | Int32 c_state_out_len = s->state_out_len; |
599 | Int32 c_nblock_used = s->nblock_used; |
600 | Int32 c_k0 = s->k0; |
601 | UInt32* c_tt = s->tt; |
602 | UInt32 c_tPos = s->tPos; |
603 | char* cs_next_out = s->strm->next_out; |
604 | unsigned int cs_avail_out = s->strm->avail_out; |
605 | Int32 ro_blockSize100k = s->blockSize100k; |
606 | /* end restore */ |
607 | |
608 | UInt32 avail_out_INIT = cs_avail_out; |
609 | Int32 s_save_nblockPP = s->save_nblock+1; |
610 | unsigned int total_out_lo32_old; |
611 | |
612 | while (True((Bool)1)) { |
613 | |
614 | /* try to finish existing run */ |
615 | if (c_state_out_len > 0) { |
616 | while (True((Bool)1)) { |
617 | if (cs_avail_out == 0) goto return_notr; |
618 | if (c_state_out_len == 1) break; |
619 | *( (UChar*)(cs_next_out) ) = c_state_out_ch; |
620 | BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch ){ c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^ BZ2_crc32Table [(c_calculatedBlockCRC >> 24) ^ ((UChar)c_state_out_ch) ]; }; |
621 | c_state_out_len--; |
622 | cs_next_out++; |
623 | cs_avail_out--; |
624 | } |
625 | s_state_out_len_eq_one: |
626 | { |
627 | if (cs_avail_out == 0) { |
628 | c_state_out_len = 1; goto return_notr; |
629 | }; |
630 | *( (UChar*)(cs_next_out) ) = c_state_out_ch; |
631 | BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch ){ c_calculatedBlockCRC = (c_calculatedBlockCRC << 8) ^ BZ2_crc32Table [(c_calculatedBlockCRC >> 24) ^ ((UChar)c_state_out_ch) ]; }; |
632 | cs_next_out++; |
633 | cs_avail_out--; |
634 | } |
635 | } |
636 | /* Only caused by corrupt data stream? */ |
637 | if (c_nblock_used > s_save_nblockPP) |
638 | return True((Bool)1); |
639 | |
640 | /* can a new run be started? */ |
641 | if (c_nblock_used == s_save_nblockPP) { |
642 | c_state_out_len = 0; goto return_notr; |
643 | }; |
644 | c_state_out_ch = c_k0; |
645 | BZ_GET_FAST_C(k1)if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return ((Bool)1); c_tPos = c_tt[c_tPos]; k1 = (UChar)(c_tPos & 0xff ); c_tPos >>= 8;; c_nblock_used++; |
646 | if (k1 != c_k0) { |
647 | c_k0 = k1; goto s_state_out_len_eq_one; |
648 | }; |
649 | if (c_nblock_used == s_save_nblockPP) |
650 | goto s_state_out_len_eq_one; |
651 | |
652 | c_state_out_len = 2; |
653 | BZ_GET_FAST_C(k1)if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return ((Bool)1); c_tPos = c_tt[c_tPos]; k1 = (UChar)(c_tPos & 0xff ); c_tPos >>= 8;; c_nblock_used++; |
654 | if (c_nblock_used == s_save_nblockPP) continue; |
655 | if (k1 != c_k0) { c_k0 = k1; continue; }; |
656 | |
657 | c_state_out_len = 3; |
658 | BZ_GET_FAST_C(k1)if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return ((Bool)1); c_tPos = c_tt[c_tPos]; k1 = (UChar)(c_tPos & 0xff ); c_tPos >>= 8;; c_nblock_used++; |
659 | if (c_nblock_used == s_save_nblockPP) continue; |
660 | if (k1 != c_k0) { c_k0 = k1; continue; }; |
661 | |
662 | BZ_GET_FAST_C(k1)if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return ((Bool)1); c_tPos = c_tt[c_tPos]; k1 = (UChar)(c_tPos & 0xff ); c_tPos >>= 8;; c_nblock_used++; |
663 | c_state_out_len = ((Int32)k1) + 4; |
664 | BZ_GET_FAST_C(c_k0)if (c_tPos >= (UInt32)100000 * (UInt32)ro_blockSize100k) return ((Bool)1); c_tPos = c_tt[c_tPos]; c_k0 = (UChar)(c_tPos & 0xff); c_tPos >>= 8;; c_nblock_used++; |
665 | } |
666 | |
667 | return_notr: |
668 | total_out_lo32_old = s->strm->total_out_lo32; |
669 | s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out); |
670 | if (s->strm->total_out_lo32 < total_out_lo32_old) |
671 | s->strm->total_out_hi32++; |
672 | |
673 | /* save */ |
674 | s->calculatedBlockCRC = c_calculatedBlockCRC; |
675 | s->state_out_ch = c_state_out_ch; |
676 | s->state_out_len = c_state_out_len; |
677 | s->nblock_used = c_nblock_used; |
678 | s->k0 = c_k0; |
679 | s->tt = c_tt; |
680 | s->tPos = c_tPos; |
681 | s->strm->next_out = cs_next_out; |
682 | s->strm->avail_out = cs_avail_out; |
683 | /* end save */ |
684 | } |
685 | return False((Bool)0); |
686 | } |
687 | |
688 | |
689 | |
690 | /*---------------------------------------------------*/ |
691 | #ifndef __cplusplus |
692 | __inline__ |
693 | #endif |
694 | Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab ) |
695 | { |
696 | Int32 nb, na, mid; |
697 | nb = 0; |
698 | na = 256; |
699 | do { |
700 | mid = (nb + na) >> 1; |
701 | if (indx >= cftab[mid]) nb = mid; else na = mid; |
702 | } |
703 | while (na - nb != 1); |
704 | return nb; |
705 | } |
706 | |
707 | |
708 | /*---------------------------------------------------*/ |
709 | /* Return True iff data corruption is discovered. |
710 | Returns False if there is no problem. |
711 | */ |
712 | static |
713 | Bool unRLE_obuf_to_output_SMALL ( DState* s ) |
714 | { |
715 | UChar k1; |
716 | |
717 | if (s->blockRandomised) { |
718 | |
719 | while (True((Bool)1)) { |
720 | /* try to finish existing run */ |
721 | while (True((Bool)1)) { |
722 | if (s->strm->avail_out == 0) return False((Bool)0); |
723 | if (s->state_out_len == 0) break; |
724 | *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; |
725 | BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ){ s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ ((UChar)s->state_out_ch)]; }; |
726 | s->state_out_len--; |
727 | s->strm->next_out++; |
728 | s->strm->avail_out--; |
729 | s->strm->total_out_lo32++; |
730 | if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; |
731 | } |
732 | |
733 | /* can a new run be started? */ |
734 | if (s->nblock_used == s->save_nblock+1) return False((Bool)0); |
735 | |
736 | /* Only caused by corrupt data stream? */ |
737 | if (s->nblock_used > s->save_nblock+1) |
738 | return True((Bool)1); |
739 | |
740 | s->state_out_len = 1; |
741 | s->state_out_ch = s->k0; |
742 | BZ_GET_SMALL(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32 )(s->ll4[(s->tPos) >> 1])) >> (((s->tPos ) << 2) & 0x4)) & 0xF) << 16));; BZ_RAND_UPD_MASKif (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos ]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s ->rNToGo--;; |
743 | k1 ^= BZ_RAND_MASK((s->rNToGo == 1) ? 1 : 0); s->nblock_used++; |
744 | if (s->nblock_used == s->save_nblock+1) continue; |
745 | if (k1 != s->k0) { s->k0 = k1; continue; }; |
746 | |
747 | s->state_out_len = 2; |
748 | BZ_GET_SMALL(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32 )(s->ll4[(s->tPos) >> 1])) >> (((s->tPos ) << 2) & 0x4)) & 0xF) << 16));; BZ_RAND_UPD_MASKif (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos ]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s ->rNToGo--;; |
749 | k1 ^= BZ_RAND_MASK((s->rNToGo == 1) ? 1 : 0); s->nblock_used++; |
750 | if (s->nblock_used == s->save_nblock+1) continue; |
751 | if (k1 != s->k0) { s->k0 = k1; continue; }; |
752 | |
753 | s->state_out_len = 3; |
754 | BZ_GET_SMALL(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32 )(s->ll4[(s->tPos) >> 1])) >> (((s->tPos ) << 2) & 0x4)) & 0xF) << 16));; BZ_RAND_UPD_MASKif (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos ]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s ->rNToGo--;; |
755 | k1 ^= BZ_RAND_MASK((s->rNToGo == 1) ? 1 : 0); s->nblock_used++; |
756 | if (s->nblock_used == s->save_nblock+1) continue; |
757 | if (k1 != s->k0) { s->k0 = k1; continue; }; |
758 | |
759 | BZ_GET_SMALL(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32 )(s->ll4[(s->tPos) >> 1])) >> (((s->tPos ) << 2) & 0x4)) & 0xF) << 16));; BZ_RAND_UPD_MASKif (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos ]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s ->rNToGo--;; |
760 | k1 ^= BZ_RAND_MASK((s->rNToGo == 1) ? 1 : 0); s->nblock_used++; |
761 | s->state_out_len = ((Int32)k1) + 4; |
762 | BZ_GET_SMALL(s->k0)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); s->k0 = BZ2_indexIntoF ( s->tPos, s ->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> ( ((s->tPos) << 2) & 0x4)) & 0xF) << 16) );; BZ_RAND_UPD_MASKif (s->rNToGo == 0) { s->rNToGo = BZ2_rNums[s->rTPos ]; s->rTPos++; if (s->rTPos == 512) s->rTPos = 0; } s ->rNToGo--;; |
763 | s->k0 ^= BZ_RAND_MASK((s->rNToGo == 1) ? 1 : 0); s->nblock_used++; |
764 | } |
765 | |
766 | } else { |
767 | |
768 | while (True((Bool)1)) { |
769 | /* try to finish existing run */ |
770 | while (True((Bool)1)) { |
771 | if (s->strm->avail_out == 0) return False((Bool)0); |
772 | if (s->state_out_len == 0) break; |
773 | *( (UChar*)(s->strm->next_out) ) = s->state_out_ch; |
774 | BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ){ s->calculatedBlockCRC = (s->calculatedBlockCRC << 8) ^ BZ2_crc32Table[(s->calculatedBlockCRC >> 24) ^ ((UChar)s->state_out_ch)]; }; |
775 | s->state_out_len--; |
776 | s->strm->next_out++; |
777 | s->strm->avail_out--; |
778 | s->strm->total_out_lo32++; |
779 | if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; |
780 | } |
781 | |
782 | /* can a new run be started? */ |
783 | if (s->nblock_used == s->save_nblock+1) return False((Bool)0); |
784 | |
785 | /* Only caused by corrupt data stream? */ |
786 | if (s->nblock_used > s->save_nblock+1) |
787 | return True((Bool)1); |
788 | |
789 | s->state_out_len = 1; |
790 | s->state_out_ch = s->k0; |
791 | BZ_GET_SMALL(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32 )(s->ll4[(s->tPos) >> 1])) >> (((s->tPos ) << 2) & 0x4)) & 0xF) << 16));; s->nblock_used++; |
792 | if (s->nblock_used == s->save_nblock+1) continue; |
793 | if (k1 != s->k0) { s->k0 = k1; continue; }; |
794 | |
795 | s->state_out_len = 2; |
796 | BZ_GET_SMALL(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32 )(s->ll4[(s->tPos) >> 1])) >> (((s->tPos ) << 2) & 0x4)) & 0xF) << 16));; s->nblock_used++; |
797 | if (s->nblock_used == s->save_nblock+1) continue; |
798 | if (k1 != s->k0) { s->k0 = k1; continue; }; |
799 | |
800 | s->state_out_len = 3; |
801 | BZ_GET_SMALL(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32 )(s->ll4[(s->tPos) >> 1])) >> (((s->tPos ) << 2) & 0x4)) & 0xF) << 16));; s->nblock_used++; |
802 | if (s->nblock_used == s->save_nblock+1) continue; |
803 | if (k1 != s->k0) { s->k0 = k1; continue; }; |
804 | |
805 | BZ_GET_SMALL(k1)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); k1 = BZ2_indexIntoF ( s->tPos, s->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32 )(s->ll4[(s->tPos) >> 1])) >> (((s->tPos ) << 2) & 0x4)) & 0xF) << 16));; s->nblock_used++; |
806 | s->state_out_len = ((Int32)k1) + 4; |
807 | BZ_GET_SMALL(s->k0)if (s->tPos >= (UInt32)100000 * (UInt32)s->blockSize100k ) return ((Bool)1); s->k0 = BZ2_indexIntoF ( s->tPos, s ->cftab ); s->tPos = (((UInt32)s->ll16[s->tPos]) | (((((UInt32)(s->ll4[(s->tPos) >> 1])) >> ( ((s->tPos) << 2) & 0x4)) & 0xF) << 16) );; s->nblock_used++; |
808 | } |
809 | |
810 | } |
811 | } |
812 | |
813 | |
814 | /*---------------------------------------------------*/ |
815 | int BZ_API(BZ2_bzDecompress)BZ2_bzDecompress ( bz_stream *strm ) |
816 | { |
817 | Bool corrupt; |
818 | DState* s; |
819 | if (strm == NULL((void *)0)) return BZ_PARAM_ERROR(-2); |
820 | s = (DState*) strm->state; |
821 | if (s == NULL((void *)0)) return BZ_PARAM_ERROR(-2); |
822 | if (s->strm != strm) return BZ_PARAM_ERROR(-2); |
823 | |
824 | while (True((Bool)1)) { |
825 | if (s->state == BZ_X_IDLE1) return BZ_SEQUENCE_ERROR(-1); |
826 | if (s->state == BZ_X_OUTPUT2) { |
827 | if (s->smallDecompress) |
828 | corrupt = unRLE_obuf_to_output_SMALL ( s ); else |
829 | corrupt = unRLE_obuf_to_output_FAST ( s ); |
830 | if (corrupt) return BZ_DATA_ERROR(-4); |
831 | if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) { |
832 | BZ_FINALISE_CRC ( s->calculatedBlockCRC ){ s->calculatedBlockCRC = ~(s->calculatedBlockCRC); }; |
833 | if (s->verbosity >= 3) |
834 | VPrintf2 ( " {0x%08x, 0x%08x}", s->storedBlockCRC,do { } while (0) |
835 | s->calculatedBlockCRC )do { } while (0); |
836 | if (s->verbosity >= 2) VPrintf0 ( "]" )do { } while (0); |
837 | if (s->calculatedBlockCRC != s->storedBlockCRC) |
838 | return BZ_DATA_ERROR(-4); |
839 | s->calculatedCombinedCRC |
840 | = (s->calculatedCombinedCRC << 1) | |
841 | (s->calculatedCombinedCRC >> 31); |
842 | s->calculatedCombinedCRC ^= s->calculatedBlockCRC; |
843 | s->state = BZ_X_BLKHDR_114; |
844 | } else { |
845 | return BZ_OK0; |
846 | } |
847 | } |
848 | if (s->state >= BZ_X_MAGIC_110) { |
849 | Int32 r = BZ2_decompress ( s ); |
850 | if (r == BZ_STREAM_END4) { |
851 | if (s->verbosity >= 3) |
852 | VPrintf2 ( "\n combined CRCs: stored = 0x%08x, computed = 0x%08x",do { } while (0) |
853 | s->storedCombinedCRC, s->calculatedCombinedCRC )do { } while (0); |
854 | if (s->calculatedCombinedCRC != s->storedCombinedCRC) |
855 | return BZ_DATA_ERROR(-4); |
856 | return r; |
857 | } |
858 | if (s->state != BZ_X_OUTPUT2) return r; |
859 | } |
860 | } |
861 | |
862 | AssertH ( 0, 6001 ){ if (!(0)) bz_internal_error ( 6001 ); }; |
863 | |
864 | return 0; /*NOTREACHED*/ |
865 | } |
866 | |
867 | |
868 | /*---------------------------------------------------*/ |
869 | int BZ_API(BZ2_bzDecompressEnd)BZ2_bzDecompressEnd ( bz_stream *strm ) |
870 | { |
871 | DState* s; |
872 | if (strm == NULL((void *)0)) return BZ_PARAM_ERROR(-2); |
873 | s = (DState*) strm->state; |
874 | if (s == NULL((void *)0)) return BZ_PARAM_ERROR(-2); |
875 | if (s->strm != strm) return BZ_PARAM_ERROR(-2); |
876 | |
877 | if (s->tt != NULL((void *)0)) BZFREE(s->tt)(strm->bzfree)(strm->opaque,(s->tt)); |
878 | if (s->ll16 != NULL((void *)0)) BZFREE(s->ll16)(strm->bzfree)(strm->opaque,(s->ll16)); |
879 | if (s->ll4 != NULL((void *)0)) BZFREE(s->ll4)(strm->bzfree)(strm->opaque,(s->ll4)); |
880 | |
881 | BZFREE(strm->state)(strm->bzfree)(strm->opaque,(strm->state)); |
882 | strm->state = NULL((void *)0); |
883 | |
884 | return BZ_OK0; |
885 | } |
886 | |
887 | |
888 | #ifndef BZ_NO_STDIO1 |
889 | /*---------------------------------------------------*/ |
890 | /*--- File I/O stuff ---*/ |
891 | /*---------------------------------------------------*/ |
892 | |
893 | #define BZ_SETERR(eee) \ |
894 | { \ |
895 | if (bzerror != NULL((void *)0)) *bzerror = eee; \ |
896 | if (bzf != NULL((void *)0)) bzf->lastErr = eee; \ |
897 | } |
898 | |
899 | typedef |
900 | struct { |
901 | FILE* handle; |
902 | Char buf[BZ_MAX_UNUSED]; |
903 | Int32 bufN; |
904 | Bool writing; |
905 | bz_stream strm; |
906 | Int32 lastErr; |
907 | Bool initialisedOk; |
908 | } |
909 | bzFile; |
910 | |
911 | |
912 | /*---------------------------------------------*/ |
913 | static Bool myfeof ( FILE* f ) |
914 | { |
915 | Int32 c = fgetc ( f ); |
916 | if (c == EOF) return True((Bool)1); |
917 | ungetc ( c, f ); |
918 | return False((Bool)0); |
919 | } |
920 | |
921 | |
922 | /*---------------------------------------------------*/ |
923 | BZFILE* BZ_API(BZ2_bzWriteOpen)BZ2_bzWriteOpen |
924 | ( int* bzerror, |
925 | FILE* f, |
926 | int blockSize100k, |
927 | int verbosity, |
928 | int workFactor ) |
929 | { |
930 | Int32 ret; |
931 | bzFile* bzf = NULL((void *)0); |
932 | |
933 | BZ_SETERR(BZ_OK0); |
934 | |
935 | if (f == NULL((void *)0) || |
936 | (blockSize100k < 1 || blockSize100k > 9) || |
937 | (workFactor < 0 || workFactor > 250) || |
938 | (verbosity < 0 || verbosity > 4)) |
939 | { BZ_SETERR(BZ_PARAM_ERROR(-2)); return NULL((void *)0); }; |
940 | |
941 | if (ferror(f)) |
942 | { BZ_SETERR(BZ_IO_ERROR(-6)); return NULL((void *)0); }; |
943 | |
944 | bzf = (bzFile*) malloc ( sizeof(bzFile) ); |
945 | if (bzf == NULL((void *)0)) |
946 | { BZ_SETERR(BZ_MEM_ERROR(-3)); return NULL((void *)0); }; |
947 | |
948 | BZ_SETERR(BZ_OK0); |
949 | bzf->initialisedOk = False((Bool)0); |
950 | bzf->bufN = 0; |
951 | bzf->handle = f; |
952 | bzf->writing = True((Bool)1); |
953 | bzf->strm.bzalloc = NULL((void *)0); |
954 | bzf->strm.bzfree = NULL((void *)0); |
955 | bzf->strm.opaque = NULL((void *)0); |
956 | |
957 | if (workFactor == 0) workFactor = 30; |
958 | ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k, |
959 | verbosity, workFactor ); |
960 | if (ret != BZ_OK0) |
961 | { BZ_SETERR(ret); free(bzf); return NULL((void *)0); }; |
962 | |
963 | bzf->strm.avail_in = 0; |
964 | bzf->initialisedOk = True((Bool)1); |
965 | return bzf; |
966 | } |
967 | |
968 | |
969 | |
970 | /*---------------------------------------------------*/ |
971 | void BZ_API(BZ2_bzWrite)BZ2_bzWrite |
972 | ( int* bzerror, |
973 | BZFILE* b, |
974 | void* buf, |
975 | int len ) |
976 | { |
977 | Int32 n, n2, ret; |
978 | bzFile* bzf = (bzFile*)b; |
979 | |
980 | BZ_SETERR(BZ_OK0); |
981 | if (bzf == NULL((void *)0) || buf == NULL((void *)0) || len < 0) |
982 | { BZ_SETERR(BZ_PARAM_ERROR(-2)); return; }; |
983 | if (!(bzf->writing)) |
984 | { BZ_SETERR(BZ_SEQUENCE_ERROR(-1)); return; }; |
985 | if (ferror(bzf->handle)) |
986 | { BZ_SETERR(BZ_IO_ERROR(-6)); return; }; |
987 | |
988 | if (len == 0) |
989 | { BZ_SETERR(BZ_OK0); return; }; |
990 | |
991 | bzf->strm.avail_in = len; |
992 | bzf->strm.next_in = (char*)buf; |
993 | |
994 | while (True((Bool)1)) { |
995 | bzf->strm.avail_out = BZ_MAX_UNUSED; |
996 | bzf->strm.next_out = bzf->buf; |
997 | ret = BZ2_bzCompress ( &(bzf->strm), BZ_RUN0 ); |
998 | if (ret != BZ_RUN_OK1) |
999 | { BZ_SETERR(ret); return; }; |
1000 | |
1001 | if (bzf->strm.avail_out < BZ_MAX_UNUSED) { |
1002 | n = BZ_MAX_UNUSED - bzf->strm.avail_out; |
1003 | n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar), |
1004 | n, bzf->handle ); |
1005 | if (n != n2 || ferror(bzf->handle)) |
1006 | { BZ_SETERR(BZ_IO_ERROR(-6)); return; }; |
1007 | } |
1008 | |
1009 | if (bzf->strm.avail_in == 0) |
1010 | { BZ_SETERR(BZ_OK0); return; }; |
1011 | } |
1012 | } |
1013 | |
1014 | |
1015 | /*---------------------------------------------------*/ |
1016 | void BZ_API(BZ2_bzWriteClose)BZ2_bzWriteClose |
1017 | ( int* bzerror, |
1018 | BZFILE* b, |
1019 | int abandon, |
1020 | unsigned int* nbytes_in, |
1021 | unsigned int* nbytes_out ) |
1022 | { |
1023 | BZ2_bzWriteClose64 ( bzerror, b, abandon, |
1024 | nbytes_in, NULL((void *)0), nbytes_out, NULL((void *)0) ); |
1025 | } |
1026 | |
1027 | |
1028 | void BZ_API(BZ2_bzWriteClose64)BZ2_bzWriteClose64 |
1029 | ( int* bzerror, |
1030 | BZFILE* b, |
1031 | int abandon, |
1032 | unsigned int* nbytes_in_lo32, |
1033 | unsigned int* nbytes_in_hi32, |
1034 | unsigned int* nbytes_out_lo32, |
1035 | unsigned int* nbytes_out_hi32 ) |
1036 | { |
1037 | Int32 n, n2, ret; |
1038 | bzFile* bzf = (bzFile*)b; |
1039 | |
1040 | if (bzf == NULL((void *)0)) |
1041 | { BZ_SETERR(BZ_OK0); return; }; |
1042 | if (!(bzf->writing)) |
1043 | { BZ_SETERR(BZ_SEQUENCE_ERROR(-1)); return; }; |
1044 | if (ferror(bzf->handle)) |
1045 | { BZ_SETERR(BZ_IO_ERROR(-6)); return; }; |
1046 | |
1047 | if (nbytes_in_lo32 != NULL((void *)0)) *nbytes_in_lo32 = 0; |
1048 | if (nbytes_in_hi32 != NULL((void *)0)) *nbytes_in_hi32 = 0; |
1049 | if (nbytes_out_lo32 != NULL((void *)0)) *nbytes_out_lo32 = 0; |
1050 | if (nbytes_out_hi32 != NULL((void *)0)) *nbytes_out_hi32 = 0; |
1051 | |
1052 | if ((!abandon) && bzf->lastErr == BZ_OK0) { |
1053 | while (True((Bool)1)) { |
1054 | bzf->strm.avail_out = BZ_MAX_UNUSED; |
1055 | bzf->strm.next_out = bzf->buf; |
1056 | ret = BZ2_bzCompress ( &(bzf->strm), BZ_FINISH2 ); |
1057 | if (ret != BZ_FINISH_OK3 && ret != BZ_STREAM_END4) |
1058 | { BZ_SETERR(ret); return; }; |
1059 | |
1060 | if (bzf->strm.avail_out < BZ_MAX_UNUSED) { |
1061 | n = BZ_MAX_UNUSED - bzf->strm.avail_out; |
1062 | n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar), |
1063 | n, bzf->handle ); |
1064 | if (n != n2 || ferror(bzf->handle)) |
1065 | { BZ_SETERR(BZ_IO_ERROR(-6)); return; }; |
1066 | } |
1067 | |
1068 | if (ret == BZ_STREAM_END4) break; |
1069 | } |
1070 | } |
1071 | |
1072 | if ( !abandon && !ferror ( bzf->handle ) ) { |
1073 | fflush ( bzf->handle ); |
1074 | if (ferror(bzf->handle)) |
1075 | { BZ_SETERR(BZ_IO_ERROR(-6)); return; }; |
1076 | } |
1077 | |
1078 | if (nbytes_in_lo32 != NULL((void *)0)) |
1079 | *nbytes_in_lo32 = bzf->strm.total_in_lo32; |
1080 | if (nbytes_in_hi32 != NULL((void *)0)) |
1081 | *nbytes_in_hi32 = bzf->strm.total_in_hi32; |
1082 | if (nbytes_out_lo32 != NULL((void *)0)) |
1083 | *nbytes_out_lo32 = bzf->strm.total_out_lo32; |
1084 | if (nbytes_out_hi32 != NULL((void *)0)) |
1085 | *nbytes_out_hi32 = bzf->strm.total_out_hi32; |
1086 | |
1087 | BZ_SETERR(BZ_OK0); |
1088 | BZ2_bzCompressEnd ( &(bzf->strm) ); |
1089 | free ( bzf ); |
1090 | } |
1091 | |
1092 | |
1093 | /*---------------------------------------------------*/ |
1094 | BZFILE* BZ_API(BZ2_bzReadOpen)BZ2_bzReadOpen |
1095 | ( int* bzerror, |
1096 | FILE* f, |
1097 | int verbosity, |
1098 | int small, |
1099 | void* unused, |
1100 | int nUnused ) |
1101 | { |
1102 | bzFile* bzf = NULL((void *)0); |
1103 | int ret; |
1104 | |
1105 | BZ_SETERR(BZ_OK0); |
1106 | |
1107 | if (f == NULL((void *)0) || |
1108 | (small != 0 && small != 1) || |
1109 | (verbosity < 0 || verbosity > 4) || |
1110 | (unused == NULL((void *)0) && nUnused != 0) || |
1111 | (unused != NULL((void *)0) && (nUnused < 0 || nUnused > BZ_MAX_UNUSED))) |
1112 | { BZ_SETERR(BZ_PARAM_ERROR(-2)); return NULL((void *)0); }; |
1113 | |
1114 | if (ferror(f)) |
1115 | { BZ_SETERR(BZ_IO_ERROR(-6)); return NULL((void *)0); }; |
1116 | |
1117 | bzf = (bzFile*) malloc ( sizeof(bzFile) ); |
1118 | if (bzf == NULL((void *)0)) |
1119 | { BZ_SETERR(BZ_MEM_ERROR(-3)); return NULL((void *)0); }; |
1120 | |
1121 | BZ_SETERR(BZ_OK0); |
1122 | |
1123 | bzf->initialisedOk = False((Bool)0); |
1124 | bzf->handle = f; |
1125 | bzf->bufN = 0; |
1126 | bzf->writing = False((Bool)0); |
1127 | bzf->strm.bzalloc = NULL((void *)0); |
1128 | bzf->strm.bzfree = NULL((void *)0); |
1129 | bzf->strm.opaque = NULL((void *)0); |
1130 | |
1131 | while (nUnused > 0) { |
1132 | bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++; |
1133 | unused = ((void*)( 1 + ((UChar*)(unused)) )); |
1134 | nUnused--; |
1135 | } |
1136 | |
1137 | ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small ); |
1138 | if (ret != BZ_OK0) |
1139 | { BZ_SETERR(ret); free(bzf); return NULL((void *)0); }; |
1140 | |
1141 | bzf->strm.avail_in = bzf->bufN; |
1142 | bzf->strm.next_in = bzf->buf; |
1143 | |
1144 | bzf->initialisedOk = True((Bool)1); |
1145 | return bzf; |
1146 | } |
1147 | |
1148 | |
1149 | /*---------------------------------------------------*/ |
1150 | void BZ_API(BZ2_bzReadClose)BZ2_bzReadClose ( int *bzerror, BZFILE *b ) |
1151 | { |
1152 | bzFile* bzf = (bzFile*)b; |
1153 | |
1154 | BZ_SETERR(BZ_OK0); |
1155 | if (bzf == NULL((void *)0)) |
1156 | { BZ_SETERR(BZ_OK0); return; }; |
1157 | |
1158 | if (bzf->writing) |
1159 | { BZ_SETERR(BZ_SEQUENCE_ERROR(-1)); return; }; |
1160 | |
1161 | if (bzf->initialisedOk) |
1162 | (void)BZ2_bzDecompressEnd ( &(bzf->strm) ); |
1163 | free ( bzf ); |
1164 | } |
1165 | |
1166 | |
1167 | /*---------------------------------------------------*/ |
1168 | int BZ_API(BZ2_bzRead)BZ2_bzRead |
1169 | ( int* bzerror, |
1170 | BZFILE* b, |
1171 | void* buf, |
1172 | int len ) |
1173 | { |
1174 | Int32 n, ret; |
1175 | bzFile* bzf = (bzFile*)b; |
1176 | |
1177 | BZ_SETERR(BZ_OK0); |
1178 | |
1179 | if (bzf == NULL((void *)0) || buf == NULL((void *)0) || len < 0) |
1180 | { BZ_SETERR(BZ_PARAM_ERROR(-2)); return 0; }; |
1181 | |
1182 | if (bzf->writing) |
1183 | { BZ_SETERR(BZ_SEQUENCE_ERROR(-1)); return 0; }; |
1184 | |
1185 | if (len == 0) |
1186 | { BZ_SETERR(BZ_OK0); return 0; }; |
1187 | |
1188 | bzf->strm.avail_out = len; |
1189 | bzf->strm.next_out = (char*) buf; |
1190 | |
1191 | while (True((Bool)1)) { |
1192 | |
1193 | if (ferror(bzf->handle)) |
1194 | { BZ_SETERR(BZ_IO_ERROR(-6)); return 0; }; |
1195 | |
1196 | if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) { |
1197 | n = fread ( bzf->buf, sizeof(UChar), |
1198 | BZ_MAX_UNUSED, bzf->handle ); |
1199 | if (ferror(bzf->handle)) |
1200 | { BZ_SETERR(BZ_IO_ERROR(-6)); return 0; }; |
1201 | bzf->bufN = n; |
1202 | bzf->strm.avail_in = bzf->bufN; |
1203 | bzf->strm.next_in = bzf->buf; |
1204 | } |
1205 | |
1206 | ret = BZ2_bzDecompress ( &(bzf->strm) ); |
1207 | |
1208 | if (ret != BZ_OK0 && ret != BZ_STREAM_END4) |
1209 | { BZ_SETERR(ret); return 0; }; |
1210 | |
1211 | if (ret == BZ_OK0 && myfeof(bzf->handle) && |
1212 | bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0) |
1213 | { BZ_SETERR(BZ_UNEXPECTED_EOF(-7)); return 0; }; |
1214 | |
1215 | if (ret == BZ_STREAM_END4) |
1216 | { BZ_SETERR(BZ_STREAM_END4); |
1217 | return len - bzf->strm.avail_out; }; |
1218 | if (bzf->strm.avail_out == 0) |
1219 | { BZ_SETERR(BZ_OK0); return len; }; |
1220 | |
1221 | } |
1222 | |
1223 | return 0; /*not reached*/ |
1224 | } |
1225 | |
1226 | |
1227 | /*---------------------------------------------------*/ |
1228 | void BZ_API(BZ2_bzReadGetUnused)BZ2_bzReadGetUnused |
1229 | ( int* bzerror, |
1230 | BZFILE* b, |
1231 | void** unused, |
1232 | int* nUnused ) |
1233 | { |
1234 | bzFile* bzf = (bzFile*)b; |
1235 | if (bzf == NULL((void *)0)) |
1236 | { BZ_SETERR(BZ_PARAM_ERROR(-2)); return; }; |
1237 | if (bzf->lastErr != BZ_STREAM_END4) |
1238 | { BZ_SETERR(BZ_SEQUENCE_ERROR(-1)); return; }; |
1239 | if (unused == NULL((void *)0) || nUnused == NULL((void *)0)) |
1240 | { BZ_SETERR(BZ_PARAM_ERROR(-2)); return; }; |
1241 | |
1242 | BZ_SETERR(BZ_OK0); |
1243 | *nUnused = bzf->strm.avail_in; |
1244 | *unused = bzf->strm.next_in; |
1245 | } |
1246 | #endif |
1247 | |
1248 | |
1249 | /*---------------------------------------------------*/ |
1250 | /*--- Misc convenience stuff ---*/ |
1251 | /*---------------------------------------------------*/ |
1252 | |
1253 | /*---------------------------------------------------*/ |
1254 | int BZ_API(BZ2_bzBuffToBuffCompress)BZ2_bzBuffToBuffCompress |
1255 | ( char* dest, |
1256 | unsigned int* destLen, |
1257 | char* source, |
1258 | unsigned int sourceLen, |
1259 | int blockSize100k, |
1260 | int verbosity, |
1261 | int workFactor ) |
1262 | { |
1263 | bz_stream strm; |
1264 | int ret; |
1265 | |
1266 | if (dest == NULL((void *)0) || destLen == NULL((void *)0) || |
1267 | source == NULL((void *)0) || |
1268 | blockSize100k < 1 || blockSize100k > 9 || |
1269 | verbosity < 0 || verbosity > 4 || |
1270 | workFactor < 0 || workFactor > 250) |
1271 | return BZ_PARAM_ERROR(-2); |
1272 | |
1273 | if (workFactor == 0) workFactor = 30; |
1274 | strm.bzalloc = NULL((void *)0); |
1275 | strm.bzfree = NULL((void *)0); |
1276 | strm.opaque = NULL((void *)0); |
1277 | ret = BZ2_bzCompressInit ( &strm, blockSize100k, |
1278 | verbosity, workFactor ); |
1279 | if (ret != BZ_OK0) return ret; |
1280 | |
1281 | strm.next_in = source; |
1282 | strm.next_out = dest; |
1283 | strm.avail_in = sourceLen; |
1284 | strm.avail_out = *destLen; |
1285 | |
1286 | ret = BZ2_bzCompress ( &strm, BZ_FINISH2 ); |
1287 | if (ret == BZ_FINISH_OK3) goto output_overflow; |
1288 | if (ret != BZ_STREAM_END4) goto errhandler; |
1289 | |
1290 | /* normal termination */ |
1291 | *destLen -= strm.avail_out; |
1292 | BZ2_bzCompressEnd ( &strm ); |
1293 | return BZ_OK0; |
1294 | |
1295 | output_overflow: |
1296 | BZ2_bzCompressEnd ( &strm ); |
1297 | return BZ_OUTBUFF_FULL(-8); |
1298 | |
1299 | errhandler: |
1300 | BZ2_bzCompressEnd ( &strm ); |
1301 | return ret; |
1302 | } |
1303 | |
1304 | |
1305 | /*---------------------------------------------------*/ |
1306 | int BZ_API(BZ2_bzBuffToBuffDecompress)BZ2_bzBuffToBuffDecompress |
1307 | ( char* dest, |
1308 | unsigned int* destLen, |
1309 | char* source, |
1310 | unsigned int sourceLen, |
1311 | int small, |
1312 | int verbosity ) |
1313 | { |
1314 | bz_stream strm; |
1315 | int ret; |
1316 | |
1317 | if (dest == NULL((void *)0) || destLen == NULL((void *)0) || |
1318 | source == NULL((void *)0) || |
1319 | (small != 0 && small != 1) || |
1320 | verbosity < 0 || verbosity > 4) |
1321 | return BZ_PARAM_ERROR(-2); |
1322 | |
1323 | strm.bzalloc = NULL((void *)0); |
1324 | strm.bzfree = NULL((void *)0); |
1325 | strm.opaque = NULL((void *)0); |
1326 | ret = BZ2_bzDecompressInit ( &strm, verbosity, small ); |
1327 | if (ret != BZ_OK0) return ret; |
1328 | |
1329 | strm.next_in = source; |
1330 | strm.next_out = dest; |
1331 | strm.avail_in = sourceLen; |
1332 | strm.avail_out = *destLen; |
1333 | |
1334 | ret = BZ2_bzDecompress ( &strm ); |
1335 | if (ret == BZ_OK0) goto output_overflow_or_eof; |
1336 | if (ret != BZ_STREAM_END4) goto errhandler; |
1337 | |
1338 | /* normal termination */ |
1339 | *destLen -= strm.avail_out; |
1340 | BZ2_bzDecompressEnd ( &strm ); |
1341 | return BZ_OK0; |
1342 | |
1343 | output_overflow_or_eof: |
1344 | if (strm.avail_out > 0) { |
1345 | BZ2_bzDecompressEnd ( &strm ); |
1346 | return BZ_UNEXPECTED_EOF(-7); |
1347 | } else { |
1348 | BZ2_bzDecompressEnd ( &strm ); |
1349 | return BZ_OUTBUFF_FULL(-8); |
1350 | }; |
1351 | |
1352 | errhandler: |
1353 | BZ2_bzDecompressEnd ( &strm ); |
1354 | return ret; |
1355 | } |
1356 | |
1357 | |
1358 | /*---------------------------------------------------*/ |
1359 | /*-- |
1360 | Code contributed by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp) |
1361 | to support better zlib compatibility. |
1362 | This code is not _officially_ part of libbzip2 (yet); |
1363 | I haven't tested it, documented it, or considered the |
1364 | threading-safeness of it. |
1365 | If this code breaks, please contact both Yoshioka and me. |
1366 | --*/ |
1367 | /*---------------------------------------------------*/ |
1368 | |
1369 | /*---------------------------------------------------*/ |
1370 | /*-- |
1371 | return version like "0.9.5d, 4-Sept-1999". |
1372 | --*/ |
1373 | const char * BZ_API(BZ2_bzlibVersion)BZ2_bzlibVersion(void) |
1374 | { |
1375 | return BZ_VERSION"1.0.8, 13-Jul-2019"; |
1376 | } |
1377 | |
1378 | |
1379 | #ifndef BZ_NO_STDIO1 |
1380 | /*---------------------------------------------------*/ |
1381 | |
1382 | #if defined(_WIN32) || defined(OS2) || defined(MSDOS) |
1383 | # include <fcntl.h> |
1384 | # include <io.h> |
1385 | # define SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY) |
1386 | #else |
1387 | # define SET_BINARY_MODE(file) |
1388 | #endif |
1389 | static |
1390 | BZFILE * bzopen_or_bzdopen |
1391 | ( const char *path, /* no use when bzdopen */ |
1392 | int fd, /* no use when bzdopen */ |
1393 | const char *mode, |
1394 | int open_mode) /* bzopen: 0, bzdopen:1 */ |
1395 | { |
1396 | int bzerr; |
1397 | char unused[BZ_MAX_UNUSED]; |
1398 | int blockSize100k = 9; |
1399 | int writing = 0; |
1400 | char mode2[10] = ""; |
1401 | FILE *fp = NULL((void *)0); |
1402 | BZFILE *bzfp = NULL((void *)0); |
1403 | int verbosity = 0; |
1404 | int workFactor = 30; |
1405 | int smallMode = 0; |
1406 | int nUnused = 0; |
1407 | |
1408 | if (mode == NULL((void *)0)) return NULL((void *)0); |
1409 | while (*mode) { |
1410 | switch (*mode) { |
1411 | case 'r': |
1412 | writing = 0; break; |
1413 | case 'w': |
1414 | writing = 1; break; |
1415 | case 's': |
1416 | smallMode = 1; break; |
1417 | default: |
1418 | if (isdigit((int)(*mode))) { |
1419 | blockSize100k = *mode-BZ_HDR_00x30; |
1420 | } |
1421 | } |
1422 | mode++; |
1423 | } |
1424 | strcat(mode2, writing ? "w" : "r" ); |
1425 | strcat(mode2,"b"); /* binary mode */ |
1426 | |
1427 | if (open_mode==0) { |
1428 | if (path==NULL((void *)0) || strcmp(path,"")==0) { |
1429 | fp = (writing ? stdout : stdin); |
1430 | SET_BINARY_MODE(fp); |
1431 | } else { |
1432 | fp = fopen(path,mode2); |
1433 | } |
1434 | } else { |
1435 | #ifdef BZ_STRICT_ANSI |
1436 | fp = NULL((void *)0); |
1437 | #else |
1438 | fp = fdopen(fd,mode2); |
1439 | #endif |
1440 | } |
1441 | if (fp == NULL((void *)0)) return NULL((void *)0); |
1442 | |
1443 | if (writing) { |
1444 | /* Guard against total chaos and anarchy -- JRS */ |
1445 | if (blockSize100k < 1) blockSize100k = 1; |
1446 | if (blockSize100k > 9) blockSize100k = 9; |
1447 | bzfp = BZ2_bzWriteOpen(&bzerr,fp,blockSize100k, |
1448 | verbosity,workFactor); |
1449 | } else { |
1450 | bzfp = BZ2_bzReadOpen(&bzerr,fp,verbosity,smallMode, |
1451 | unused,nUnused); |
1452 | } |
1453 | if (bzfp == NULL((void *)0)) { |
1454 | if (fp != stdin && fp != stdout) fclose(fp); |
1455 | return NULL((void *)0); |
1456 | } |
1457 | return bzfp; |
1458 | } |
1459 | |
1460 | |
1461 | /*---------------------------------------------------*/ |
1462 | /*-- |
1463 | open file for read or write. |
1464 | ex) bzopen("file","w9") |
1465 | case path="" or NULL => use stdin or stdout. |
1466 | --*/ |
1467 | BZFILE * BZ_API(BZ2_bzopen)BZ2_bzopen |
1468 | ( const char *path, |
1469 | const char *mode ) |
1470 | { |
1471 | return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0); |
1472 | } |
1473 | |
1474 | |
1475 | /*---------------------------------------------------*/ |
1476 | BZFILE * BZ_API(BZ2_bzdopen)BZ2_bzdopen |
1477 | ( int fd, |
1478 | const char *mode ) |
1479 | { |
1480 | return bzopen_or_bzdopen(NULL((void *)0),fd,mode,/*bzdopen*/1); |
1481 | } |
1482 | |
1483 | |
1484 | /*---------------------------------------------------*/ |
1485 | int BZ_API(BZ2_bzread)BZ2_bzread (BZFILE* b, void* buf, int len ) |
1486 | { |
1487 | int bzerr, nread; |
1488 | if (((bzFile*)b)->lastErr == BZ_STREAM_END4) return 0; |
1489 | nread = BZ2_bzRead(&bzerr,b,buf,len); |
1490 | if (bzerr == BZ_OK0 || bzerr == BZ_STREAM_END4) { |
1491 | return nread; |
1492 | } else { |
1493 | return -1; |
1494 | } |
1495 | } |
1496 | |
1497 | |
1498 | /*---------------------------------------------------*/ |
1499 | int BZ_API(BZ2_bzwrite)BZ2_bzwrite (BZFILE* b, void* buf, int len ) |
1500 | { |
1501 | int bzerr; |
1502 | |
1503 | BZ2_bzWrite(&bzerr,b,buf,len); |
1504 | if(bzerr == BZ_OK0){ |
1505 | return len; |
1506 | }else{ |
1507 | return -1; |
1508 | } |
1509 | } |
1510 | |
1511 | |
1512 | /*---------------------------------------------------*/ |
1513 | int BZ_API(BZ2_bzflush)BZ2_bzflush (BZFILE *b) |
1514 | { |
1515 | /* do nothing now... */ |
1516 | return 0; |
1517 | } |
1518 | |
1519 | |
1520 | /*---------------------------------------------------*/ |
1521 | void BZ_API(BZ2_bzclose)BZ2_bzclose (BZFILE* b) |
1522 | { |
1523 | int bzerr; |
1524 | FILE *fp; |
1525 | |
1526 | if (b==NULL((void *)0)) {return;} |
1527 | fp = ((bzFile *)b)->handle; |
1528 | if(((bzFile*)b)->writing){ |
1529 | BZ2_bzWriteClose(&bzerr,b,0,NULL((void *)0),NULL((void *)0)); |
1530 | if(bzerr != BZ_OK0){ |
1531 | BZ2_bzWriteClose(NULL((void *)0),b,1,NULL((void *)0),NULL((void *)0)); |
1532 | } |
1533 | }else{ |
1534 | BZ2_bzReadClose(&bzerr,b); |
1535 | } |
1536 | if(fp!=stdin && fp!=stdout){ |
1537 | fclose(fp); |
1538 | } |
1539 | } |
1540 | |
1541 | |
1542 | /*---------------------------------------------------*/ |
1543 | /*-- |
1544 | return last error code |
1545 | --*/ |
1546 | static const char *bzerrorstrings[] = { |
1547 | "OK" |
1548 | ,"SEQUENCE_ERROR" |
1549 | ,"PARAM_ERROR" |
1550 | ,"MEM_ERROR" |
1551 | ,"DATA_ERROR" |
1552 | ,"DATA_ERROR_MAGIC" |
1553 | ,"IO_ERROR" |
1554 | ,"UNEXPECTED_EOF" |
1555 | ,"OUTBUFF_FULL" |
1556 | ,"CONFIG_ERROR" |
1557 | ,"???" /* for future */ |
1558 | ,"???" /* for future */ |
1559 | ,"???" /* for future */ |
1560 | ,"???" /* for future */ |
1561 | ,"???" /* for future */ |
1562 | ,"???" /* for future */ |
1563 | }; |
1564 | |
1565 | |
1566 | const char * BZ_API(BZ2_bzerror)BZ2_bzerror (BZFILE *b, int *errnum) |
1567 | { |
1568 | int err = ((bzFile *)b)->lastErr; |
1569 | |
1570 | if(err>0) err = 0; |
1571 | *errnum = err; |
1572 | return bzerrorstrings[err*-1]; |
1573 | } |
1574 | #endif |
1575 | |
1576 | |
1577 | /*-------------------------------------------------------------*/ |
1578 | /*--- end bzlib.c ---*/ |
1579 | /*-------------------------------------------------------------*/ |