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