WebSVN – nw_plus – Blame – /nw_plus/utils/source/bsdiff-4.3/win32/bzlib.c

Rev	Author	Line No.	Line
23	h266	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.4 of 20 December 2006
		12	Copyright (C) 1996-2006 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, 15 February 2005.\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	/* end restore */
		602
		603	UInt32 avail_out_INIT = cs_avail_out;
		604	Int32 s_save_nblockPP = s->save_nblock+1;
		605	unsigned int total_out_lo32_old;
		606
		607	while (True) {
		608
		609	/* try to finish existing run */
		610	if (c_state_out_len > 0) {
		611	while (True) {
		612	if (cs_avail_out == 0) goto return_notr;
		613	if (c_state_out_len == 1) break;
		614	( (UChar)(cs_next_out) ) = c_state_out_ch;
		615	BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
		616	c_state_out_len--;
		617	cs_next_out++;
		618	cs_avail_out--;
		619	}
		620	s_state_out_len_eq_one:
		621	{
		622	if (cs_avail_out == 0) {
		623	c_state_out_len = 1; goto return_notr;
		624	};
		625	( (UChar)(cs_next_out) ) = c_state_out_ch;
		626	BZ_UPDATE_CRC ( c_calculatedBlockCRC, c_state_out_ch );
		627	cs_next_out++;
		628	cs_avail_out--;
		629	}
		630	}
		631	/* Only caused by corrupt data stream? */
		632	if (c_nblock_used > s_save_nblockPP)
		633	return True;
		634
		635	/* can a new run be started? */
		636	if (c_nblock_used == s_save_nblockPP) {
		637	c_state_out_len = 0; goto return_notr;
		638	};
		639	c_state_out_ch = c_k0;
		640	BZ_GET_FAST_C(k1); c_nblock_used++;
		641	if (k1 != c_k0) {
		642	c_k0 = k1; goto s_state_out_len_eq_one;
		643	};
		644	if (c_nblock_used == s_save_nblockPP)
		645	goto s_state_out_len_eq_one;
		646
		647	c_state_out_len = 2;
		648	BZ_GET_FAST_C(k1); c_nblock_used++;
		649	if (c_nblock_used == s_save_nblockPP) continue;
		650	if (k1 != c_k0) { c_k0 = k1; continue; };
		651
		652	c_state_out_len = 3;
		653	BZ_GET_FAST_C(k1); c_nblock_used++;
		654	if (c_nblock_used == s_save_nblockPP) continue;
		655	if (k1 != c_k0) { c_k0 = k1; continue; };
		656
		657	BZ_GET_FAST_C(k1); c_nblock_used++;
		658	c_state_out_len = ((Int32)k1) + 4;
		659	BZ_GET_FAST_C(c_k0); c_nblock_used++;
		660	}
		661
		662	return_notr:
		663	total_out_lo32_old = s->strm->total_out_lo32;
		664	s->strm->total_out_lo32 += (avail_out_INIT - cs_avail_out);
		665	if (s->strm->total_out_lo32 < total_out_lo32_old)
		666	s->strm->total_out_hi32++;
		667
		668	/* save */
		669	s->calculatedBlockCRC = c_calculatedBlockCRC;
		670	s->state_out_ch = c_state_out_ch;
		671	s->state_out_len = c_state_out_len;
		672	s->nblock_used = c_nblock_used;
		673	s->k0 = c_k0;
		674	s->tt = c_tt;
		675	s->tPos = c_tPos;
		676	s->strm->next_out = cs_next_out;
		677	s->strm->avail_out = cs_avail_out;
		678	/* end save */
		679	}
		680	return False;
		681	}
		682
		683
		684
		685	/---------------------------------------------------/
		686	__inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
		687	{
		688	Int32 nb, na, mid;
		689	nb = 0;
		690	na = 256;
		691	do {
		692	mid = (nb + na) >> 1;
		693	if (indx >= cftab[mid]) nb = mid; else na = mid;
		694	}
		695	while (na - nb != 1);
		696	return nb;
		697	}
		698
		699
		700	/---------------------------------------------------/
		701	/* Return True iff data corruption is discovered.
		702	Returns False if there is no problem.
		703	*/
		704	static
		705	Bool unRLE_obuf_to_output_SMALL ( DState* s )
		706	{
		707	UChar k1;
		708
		709	if (s->blockRandomised) {
		710
		711	while (True) {
		712	/* try to finish existing run */
		713	while (True) {
		714	if (s->strm->avail_out == 0) return False;
		715	if (s->state_out_len == 0) break;
		716	( (UChar)(s->strm->next_out) ) = s->state_out_ch;
		717	BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
		718	s->state_out_len--;
		719	s->strm->next_out++;
		720	s->strm->avail_out--;
		721	s->strm->total_out_lo32++;
		722	if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
		723	}
		724
		725	/* can a new run be started? */
		726	if (s->nblock_used == s->save_nblock+1) return False;
		727
		728	/* Only caused by corrupt data stream? */
		729	if (s->nblock_used > s->save_nblock+1)
		730	return True;
		731
		732	s->state_out_len = 1;
		733	s->state_out_ch = s->k0;
		734	BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
		735	k1 ^= BZ_RAND_MASK; s->nblock_used++;
		736	if (s->nblock_used == s->save_nblock+1) continue;
		737	if (k1 != s->k0) { s->k0 = k1; continue; };
		738
		739	s->state_out_len = 2;
		740	BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
		741	k1 ^= BZ_RAND_MASK; s->nblock_used++;
		742	if (s->nblock_used == s->save_nblock+1) continue;
		743	if (k1 != s->k0) { s->k0 = k1; continue; };
		744
		745	s->state_out_len = 3;
		746	BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
		747	k1 ^= BZ_RAND_MASK; s->nblock_used++;
		748	if (s->nblock_used == s->save_nblock+1) continue;
		749	if (k1 != s->k0) { s->k0 = k1; continue; };
		750
		751	BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
		752	k1 ^= BZ_RAND_MASK; s->nblock_used++;
		753	s->state_out_len = ((Int32)k1) + 4;
		754	BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK;
		755	s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
		756	}
		757
		758	} else {
		759
		760	while (True) {
		761	/* try to finish existing run */
		762	while (True) {
		763	if (s->strm->avail_out == 0) return False;
		764	if (s->state_out_len == 0) break;
		765	( (UChar)(s->strm->next_out) ) = s->state_out_ch;
		766	BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
		767	s->state_out_len--;
		768	s->strm->next_out++;
		769	s->strm->avail_out--;
		770	s->strm->total_out_lo32++;
		771	if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
		772	}
		773
		774	/* can a new run be started? */
		775	if (s->nblock_used == s->save_nblock+1) return False;
		776
		777	/* Only caused by corrupt data stream? */
		778	if (s->nblock_used > s->save_nblock+1)
		779	return True;
		780
		781	s->state_out_len = 1;
		782	s->state_out_ch = s->k0;
		783	BZ_GET_SMALL(k1); s->nblock_used++;
		784	if (s->nblock_used == s->save_nblock+1) continue;
		785	if (k1 != s->k0) { s->k0 = k1; continue; };
		786
		787	s->state_out_len = 2;
		788	BZ_GET_SMALL(k1); s->nblock_used++;
		789	if (s->nblock_used == s->save_nblock+1) continue;
		790	if (k1 != s->k0) { s->k0 = k1; continue; };
		791
		792	s->state_out_len = 3;
		793	BZ_GET_SMALL(k1); s->nblock_used++;
		794	if (s->nblock_used == s->save_nblock+1) continue;
		795	if (k1 != s->k0) { s->k0 = k1; continue; };
		796
		797	BZ_GET_SMALL(k1); s->nblock_used++;
		798	s->state_out_len = ((Int32)k1) + 4;
		799	BZ_GET_SMALL(s->k0); s->nblock_used++;
		800	}
		801
		802	}
		803	}
		804
		805
		806	/---------------------------------------------------/
		807	int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
		808	{
		809	Bool corrupt;
		810	DState* s;
		811	if (strm == NULL) return BZ_PARAM_ERROR;
		812	s = strm->state;
		813	if (s == NULL) return BZ_PARAM_ERROR;
		814	if (s->strm != strm) return BZ_PARAM_ERROR;
		815
		816	while (True) {
		817	if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR;
		818	if (s->state == BZ_X_OUTPUT) {
		819	if (s->smallDecompress)
		820	corrupt = unRLE_obuf_to_output_SMALL ( s ); else
		821	corrupt = unRLE_obuf_to_output_FAST ( s );
		822	if (corrupt) return BZ_DATA_ERROR;
		823	if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
		824	BZ_FINALISE_CRC ( s->calculatedBlockCRC );
		825	if (s->verbosity >= 3)
		826	VPrintf2 ( " {0x%08x, 0x%08x}", s->storedBlockCRC,
		827	s->calculatedBlockCRC );
		828	if (s->verbosity >= 2) VPrintf0 ( "]" );
		829	if (s->calculatedBlockCRC != s->storedBlockCRC)
		830	return BZ_DATA_ERROR;
		831	s->calculatedCombinedCRC
		832	= (s->calculatedCombinedCRC << 1) \|
		833	(s->calculatedCombinedCRC >> 31);
		834	s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
		835	s->state = BZ_X_BLKHDR_1;
		836	} else {
		837	return BZ_OK;
		838	}
		839	}
		840	if (s->state >= BZ_X_MAGIC_1) {
		841	Int32 r = BZ2_decompress ( s );
		842	if (r == BZ_STREAM_END) {
		843	if (s->verbosity >= 3)
		844	VPrintf2 ( "\n combined CRCs: stored = 0x%08x, computed = 0x%08x",
		845	s->storedCombinedCRC, s->calculatedCombinedCRC );
		846	if (s->calculatedCombinedCRC != s->storedCombinedCRC)
		847	return BZ_DATA_ERROR;
		848	return r;
		849	}
		850	if (s->state != BZ_X_OUTPUT) return r;
		851	}
		852	}
		853
		854	AssertH ( 0, 6001 );
		855
		856	return 0; /NOTREACHED/
		857	}
		858
		859
		860	/---------------------------------------------------/
		861	int BZ_API(BZ2_bzDecompressEnd) ( bz_stream *strm )
		862	{
		863	DState* s;
		864	if (strm == NULL) return BZ_PARAM_ERROR;
		865	s = strm->state;
		866	if (s == NULL) return BZ_PARAM_ERROR;
		867	if (s->strm != strm) return BZ_PARAM_ERROR;
		868
		869	if (s->tt != NULL) BZFREE(s->tt);
		870	if (s->ll16 != NULL) BZFREE(s->ll16);
		871	if (s->ll4 != NULL) BZFREE(s->ll4);
		872
		873	BZFREE(strm->state);
		874	strm->state = NULL;
		875
		876	return BZ_OK;
		877	}
		878
		879
		880	#ifndef BZ_NO_STDIO
		881	/---------------------------------------------------/
		882	/--- File I/O stuff ---/
		883	/---------------------------------------------------/
		884
		885	#define BZ_SETERR(eee) \
		886	{ \
		887	if (bzerror != NULL) *bzerror = eee; \
		888	if (bzf != NULL) bzf->lastErr = eee; \
		889	}
		890
		891	typedef
		892	struct {
		893	FILE* handle;
		894	Char buf[BZ_MAX_UNUSED];
		895	Int32 bufN;
		896	Bool writing;
		897	bz_stream strm;
		898	Int32 lastErr;
		899	Bool initialisedOk;
		900	}
		901	bzFile;
		902
		903
		904	/---------------------------------------------/
		905	static Bool myfeof ( FILE* f )
		906	{
		907	Int32 c = fgetc ( f );
		908	if (c == EOF) return True;
		909	ungetc ( c, f );
		910	return False;
		911	}
		912
		913
		914	/---------------------------------------------------/
		915	BZFILE* BZ_API(BZ2_bzWriteOpen)
		916	( int* bzerror,
		917	FILE* f,
		918	int blockSize100k,
		919	int verbosity,
		920	int workFactor )
		921	{
		922	Int32 ret;
		923	bzFile* bzf = NULL;
		924
		925	BZ_SETERR(BZ_OK);
		926
		927	if (f == NULL \|\|
		928	(blockSize100k < 1 \|\| blockSize100k > 9) \|\|
		929	(workFactor < 0 \|\| workFactor > 250) \|\|
		930	(verbosity < 0 \|\| verbosity > 4))
		931	{ BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
		932
		933	if (ferror(f))
		934	{ BZ_SETERR(BZ_IO_ERROR); return NULL; };
		935
		936	bzf = malloc ( sizeof(bzFile) );
		937	if (bzf == NULL)
		938	{ BZ_SETERR(BZ_MEM_ERROR); return NULL; };
		939
		940	BZ_SETERR(BZ_OK);
		941	bzf->initialisedOk = False;
		942	bzf->bufN = 0;
		943	bzf->handle = f;
		944	bzf->writing = True;
		945	bzf->strm.bzalloc = NULL;
		946	bzf->strm.bzfree = NULL;
		947	bzf->strm.opaque = NULL;
		948
		949	if (workFactor == 0) workFactor = 30;
		950	ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k,
		951	verbosity, workFactor );
		952	if (ret != BZ_OK)
		953	{ BZ_SETERR(ret); free(bzf); return NULL; };
		954
		955	bzf->strm.avail_in = 0;
		956	bzf->initialisedOk = True;
		957	return bzf;
		958	}
		959
		960
		961
		962	/---------------------------------------------------/
		963	void BZ_API(BZ2_bzWrite)
		964	( int* bzerror,
		965	BZFILE* b,
		966	void* buf,
		967	int len )
		968	{
		969	Int32 n, n2, ret;
		970	bzFile* bzf = (bzFile*)b;
		971
		972	BZ_SETERR(BZ_OK);
		973	if (bzf == NULL \|\| buf == NULL \|\| len < 0)
		974	{ BZ_SETERR(BZ_PARAM_ERROR); return; };
		975	if (!(bzf->writing))
		976	{ BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
		977	if (ferror(bzf->handle))
		978	{ BZ_SETERR(BZ_IO_ERROR); return; };
		979
		980	if (len == 0)
		981	{ BZ_SETERR(BZ_OK); return; };
		982
		983	bzf->strm.avail_in = len;
		984	bzf->strm.next_in = buf;
		985
		986	while (True) {
		987	bzf->strm.avail_out = BZ_MAX_UNUSED;
		988	bzf->strm.next_out = bzf->buf;
		989	ret = BZ2_bzCompress ( &(bzf->strm), BZ_RUN );
		990	if (ret != BZ_RUN_OK)
		991	{ BZ_SETERR(ret); return; };
		992
		993	if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
		994	n = BZ_MAX_UNUSED - bzf->strm.avail_out;
		995	n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
		996	n, bzf->handle );
		997	if (n != n2 \|\| ferror(bzf->handle))
		998	{ BZ_SETERR(BZ_IO_ERROR); return; };
		999	}
		1000
		1001	if (bzf->strm.avail_in == 0)
		1002	{ BZ_SETERR(BZ_OK); return; };
		1003	}
		1004	}
		1005
		1006
		1007	/---------------------------------------------------/
		1008	void BZ_API(BZ2_bzWriteClose)
		1009	( int* bzerror,
		1010	BZFILE* b,
		1011	int abandon,
		1012	unsigned int* nbytes_in,
		1013	unsigned int* nbytes_out )
		1014	{
		1015	BZ2_bzWriteClose64 ( bzerror, b, abandon,
		1016	nbytes_in, NULL, nbytes_out, NULL );
		1017	}
		1018
		1019
		1020	void BZ_API(BZ2_bzWriteClose64)
		1021	( int* bzerror,
		1022	BZFILE* b,
		1023	int abandon,
		1024	unsigned int* nbytes_in_lo32,
		1025	unsigned int* nbytes_in_hi32,
		1026	unsigned int* nbytes_out_lo32,
		1027	unsigned int* nbytes_out_hi32 )
		1028	{
		1029	Int32 n, n2, ret;
		1030	bzFile* bzf = (bzFile*)b;
		1031
		1032	if (bzf == NULL)
		1033	{ BZ_SETERR(BZ_OK); return; };
		1034	if (!(bzf->writing))
		1035	{ BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
		1036	if (ferror(bzf->handle))
		1037	{ BZ_SETERR(BZ_IO_ERROR); return; };
		1038
		1039	if (nbytes_in_lo32 != NULL) *nbytes_in_lo32 = 0;
		1040	if (nbytes_in_hi32 != NULL) *nbytes_in_hi32 = 0;
		1041	if (nbytes_out_lo32 != NULL) *nbytes_out_lo32 = 0;
		1042	if (nbytes_out_hi32 != NULL) *nbytes_out_hi32 = 0;
		1043
		1044	if ((!abandon) && bzf->lastErr == BZ_OK) {
		1045	while (True) {
		1046	bzf->strm.avail_out = BZ_MAX_UNUSED;
		1047	bzf->strm.next_out = bzf->buf;
		1048	ret = BZ2_bzCompress ( &(bzf->strm), BZ_FINISH );
		1049	if (ret != BZ_FINISH_OK && ret != BZ_STREAM_END)
		1050	{ BZ_SETERR(ret); return; };
		1051
		1052	if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
		1053	n = BZ_MAX_UNUSED - bzf->strm.avail_out;
		1054	n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
		1055	n, bzf->handle );
		1056	if (n != n2 \|\| ferror(bzf->handle))
		1057	{ BZ_SETERR(BZ_IO_ERROR); return; };
		1058	}
		1059
		1060	if (ret == BZ_STREAM_END) break;
		1061	}
		1062	}
		1063
		1064	if ( !abandon && !ferror ( bzf->handle ) ) {
		1065	fflush ( bzf->handle );
		1066	if (ferror(bzf->handle))
		1067	{ BZ_SETERR(BZ_IO_ERROR); return; };
		1068	}
		1069
		1070	if (nbytes_in_lo32 != NULL)
		1071	*nbytes_in_lo32 = bzf->strm.total_in_lo32;
		1072	if (nbytes_in_hi32 != NULL)
		1073	*nbytes_in_hi32 = bzf->strm.total_in_hi32;
		1074	if (nbytes_out_lo32 != NULL)
		1075	*nbytes_out_lo32 = bzf->strm.total_out_lo32;
		1076	if (nbytes_out_hi32 != NULL)
		1077	*nbytes_out_hi32 = bzf->strm.total_out_hi32;
		1078
		1079	BZ_SETERR(BZ_OK);
		1080	BZ2_bzCompressEnd ( &(bzf->strm) );
		1081	free ( bzf );
		1082	}
		1083
		1084
		1085	/---------------------------------------------------/
		1086	BZFILE* BZ_API(BZ2_bzReadOpen)
		1087	( int* bzerror,
		1088	FILE* f,
		1089	int verbosity,
		1090	int small,
		1091	void* unused,
		1092	int nUnused )
		1093	{
		1094	bzFile* bzf = NULL;
		1095	int ret;
		1096
		1097	BZ_SETERR(BZ_OK);
		1098
		1099	if (f == NULL \|\|
		1100	(small != 0 && small != 1) \|\|
		1101	(verbosity < 0 \|\| verbosity > 4) \|\|
		1102	(unused == NULL && nUnused != 0) \|\|
		1103	(unused != NULL && (nUnused < 0 \|\| nUnused > BZ_MAX_UNUSED)))
		1104	{ BZ_SETERR(BZ_PARAM_ERROR); return NULL; };
		1105
		1106	if (ferror(f))
		1107	{ BZ_SETERR(BZ_IO_ERROR); return NULL; };
		1108
		1109	bzf = malloc ( sizeof(bzFile) );
		1110	if (bzf == NULL)
		1111	{ BZ_SETERR(BZ_MEM_ERROR); return NULL; };
		1112
		1113	BZ_SETERR(BZ_OK);
		1114
		1115	bzf->initialisedOk = False;
		1116	bzf->handle = f;
		1117	bzf->bufN = 0;
		1118	bzf->writing = False;
		1119	bzf->strm.bzalloc = NULL;
		1120	bzf->strm.bzfree = NULL;
		1121	bzf->strm.opaque = NULL;
		1122
		1123	while (nUnused > 0) {
		1124	bzf->buf[bzf->bufN] = ((UChar)(unused)); bzf->bufN++;
		1125	unused = ((void)( 1 + ((UChar)(unused)) ));
		1126	nUnused--;
		1127	}
		1128
		1129	ret = BZ2_bzDecompressInit ( &(bzf->strm), verbosity, small );
		1130	if (ret != BZ_OK)
		1131	{ BZ_SETERR(ret); free(bzf); return NULL; };
		1132
		1133	bzf->strm.avail_in = bzf->bufN;
		1134	bzf->strm.next_in = bzf->buf;
		1135
		1136	bzf->initialisedOk = True;
		1137	return bzf;
		1138	}
		1139
		1140
		1141	/---------------------------------------------------/
		1142	void BZ_API(BZ2_bzReadClose) ( int bzerror, BZFILE b )
		1143	{
		1144	bzFile* bzf = (bzFile*)b;
		1145
		1146	BZ_SETERR(BZ_OK);
		1147	if (bzf == NULL)
		1148	{ BZ_SETERR(BZ_OK); return; };
		1149
		1150	if (bzf->writing)
		1151	{ BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
		1152
		1153	if (bzf->initialisedOk)
		1154	(void)BZ2_bzDecompressEnd ( &(bzf->strm) );
		1155	free ( bzf );
		1156	}
		1157
		1158
		1159	/---------------------------------------------------/
		1160	int BZ_API(BZ2_bzRead)
		1161	( int* bzerror,
		1162	BZFILE* b,
		1163	void* buf,
		1164	int len )
		1165	{
		1166	Int32 n, ret;
		1167	bzFile* bzf = (bzFile*)b;
		1168
		1169	BZ_SETERR(BZ_OK);
		1170
		1171	if (bzf == NULL \|\| buf == NULL \|\| len < 0)
		1172	{ BZ_SETERR(BZ_PARAM_ERROR); return 0; };
		1173
		1174	if (bzf->writing)
		1175	{ BZ_SETERR(BZ_SEQUENCE_ERROR); return 0; };
		1176
		1177	if (len == 0)
		1178	{ BZ_SETERR(BZ_OK); return 0; };
		1179
		1180	bzf->strm.avail_out = len;
		1181	bzf->strm.next_out = buf;
		1182
		1183	while (True) {
		1184
		1185	if (ferror(bzf->handle))
		1186	{ BZ_SETERR(BZ_IO_ERROR); return 0; };
		1187
		1188	if (bzf->strm.avail_in == 0 && !myfeof(bzf->handle)) {
		1189	n = fread ( bzf->buf, sizeof(UChar),
		1190	BZ_MAX_UNUSED, bzf->handle );
		1191	if (ferror(bzf->handle))
		1192	{ BZ_SETERR(BZ_IO_ERROR); return 0; };
		1193	bzf->bufN = n;
		1194	bzf->strm.avail_in = bzf->bufN;
		1195	bzf->strm.next_in = bzf->buf;
		1196	}
		1197
		1198	ret = BZ2_bzDecompress ( &(bzf->strm) );
		1199
		1200	if (ret != BZ_OK && ret != BZ_STREAM_END)
		1201	{ BZ_SETERR(ret); return 0; };
		1202
		1203	if (ret == BZ_OK && myfeof(bzf->handle) &&
		1204	bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0)
		1205	{ BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };
		1206
		1207	if (ret == BZ_STREAM_END)
		1208	{ BZ_SETERR(BZ_STREAM_END);
		1209	return len - bzf->strm.avail_out; };
		1210	if (bzf->strm.avail_out == 0)
		1211	{ BZ_SETERR(BZ_OK); return len; };
		1212
		1213	}
		1214
		1215	return 0; /not reached/
		1216	}
		1217
		1218
		1219	/---------------------------------------------------/
		1220	void BZ_API(BZ2_bzReadGetUnused)
		1221	( int* bzerror,
		1222	BZFILE* b,
		1223	void** unused,
		1224	int* nUnused )
		1225	{
		1226	bzFile* bzf = (bzFile*)b;
		1227	if (bzf == NULL)
		1228	{ BZ_SETERR(BZ_PARAM_ERROR); return; };
		1229	if (bzf->lastErr != BZ_STREAM_END)
		1230	{ BZ_SETERR(BZ_SEQUENCE_ERROR); return; };
		1231	if (unused == NULL \|\| nUnused == NULL)
		1232	{ BZ_SETERR(BZ_PARAM_ERROR); return; };
		1233
		1234	BZ_SETERR(BZ_OK);
		1235	*nUnused = bzf->strm.avail_in;
		1236	*unused = bzf->strm.next_in;
		1237	}
		1238	#endif
		1239
		1240
		1241	/---------------------------------------------------/
		1242	/--- Misc convenience stuff ---/
		1243	/---------------------------------------------------/
		1244
		1245	/---------------------------------------------------/
		1246	int BZ_API(BZ2_bzBuffToBuffCompress)
		1247	( char* dest,
		1248	unsigned int* destLen,
		1249	char* source,
		1250	unsigned int sourceLen,
		1251	int blockSize100k,
		1252	int verbosity,
		1253	int workFactor )
		1254	{
		1255	bz_stream strm;
		1256	int ret;
		1257
		1258	if (dest == NULL \|\| destLen == NULL \|\|
		1259	source == NULL \|\|
		1260	blockSize100k < 1 \|\| blockSize100k > 9 \|\|
		1261	verbosity < 0 \|\| verbosity > 4 \|\|
		1262	workFactor < 0 \|\| workFactor > 250)
		1263	return BZ_PARAM_ERROR;
		1264
		1265	if (workFactor == 0) workFactor = 30;
		1266	strm.bzalloc = NULL;
		1267	strm.bzfree = NULL;
		1268	strm.opaque = NULL;
		1269	ret = BZ2_bzCompressInit ( &strm, blockSize100k,
		1270	verbosity, workFactor );
		1271	if (ret != BZ_OK) return ret;
		1272
		1273	strm.next_in = source;
		1274	strm.next_out = dest;
		1275	strm.avail_in = sourceLen;
		1276	strm.avail_out = *destLen;
		1277
		1278	ret = BZ2_bzCompress ( &strm, BZ_FINISH );
		1279	if (ret == BZ_FINISH_OK) goto output_overflow;
		1280	if (ret != BZ_STREAM_END) goto errhandler;
		1281
		1282	/* normal termination */
		1283	*destLen -= strm.avail_out;
		1284	BZ2_bzCompressEnd ( &strm );
		1285	return BZ_OK;
		1286
		1287	output_overflow:
		1288	BZ2_bzCompressEnd ( &strm );
		1289	return BZ_OUTBUFF_FULL;
		1290
		1291	errhandler:
		1292	BZ2_bzCompressEnd ( &strm );
		1293	return ret;
		1294	}
		1295
		1296
		1297	/---------------------------------------------------/
		1298	int BZ_API(BZ2_bzBuffToBuffDecompress)
		1299	( char* dest,
		1300	unsigned int* destLen,
		1301	char* source,
		1302	unsigned int sourceLen,
		1303	int small,
		1304	int verbosity )
		1305	{
		1306	bz_stream strm;
		1307	int ret;
		1308
		1309	if (dest == NULL \|\| destLen == NULL \|\|
		1310	source == NULL \|\|
		1311	(small != 0 && small != 1) \|\|
		1312	verbosity < 0 \|\| verbosity > 4)
		1313	return BZ_PARAM_ERROR;
		1314
		1315	strm.bzalloc = NULL;
		1316	strm.bzfree = NULL;
		1317	strm.opaque = NULL;
		1318	ret = BZ2_bzDecompressInit ( &strm, verbosity, small );
		1319	if (ret != BZ_OK) return ret;
		1320
		1321	strm.next_in = source;
		1322	strm.next_out = dest;
		1323	strm.avail_in = sourceLen;
		1324	strm.avail_out = *destLen;
		1325
		1326	ret = BZ2_bzDecompress ( &strm );
		1327	if (ret == BZ_OK) goto output_overflow_or_eof;
		1328	if (ret != BZ_STREAM_END) goto errhandler;
		1329
		1330	/* normal termination */
		1331	*destLen -= strm.avail_out;
		1332	BZ2_bzDecompressEnd ( &strm );
		1333	return BZ_OK;
		1334
		1335	output_overflow_or_eof:
		1336	if (strm.avail_out > 0) {
		1337	BZ2_bzDecompressEnd ( &strm );
		1338	return BZ_UNEXPECTED_EOF;
		1339	} else {
		1340	BZ2_bzDecompressEnd ( &strm );
		1341	return BZ_OUTBUFF_FULL;
		1342	};
		1343
		1344	errhandler:
		1345	BZ2_bzDecompressEnd ( &strm );
		1346	return ret;
		1347	}
		1348
		1349
		1350	/---------------------------------------------------/
		1351	/*--
		1352	Code contributed by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp)
		1353	to support better zlib compatibility.
		1354	This code is not _officially_ part of libbzip2 (yet);
		1355	I haven't tested it, documented it, or considered the
		1356	threading-safeness of it.
		1357	If this code breaks, please contact both Yoshioka and me.
		1358	--*/
		1359	/---------------------------------------------------/
		1360
		1361	/---------------------------------------------------/
		1362	/*--
		1363	return version like "0.9.5d, 4-Sept-1999".
		1364	--*/
		1365	const char * BZ_API(BZ2_bzlibVersion)(void)
		1366	{
		1367	return BZ_VERSION;
		1368	}
		1369
		1370
		1371	#ifndef BZ_NO_STDIO
		1372	/---------------------------------------------------/
		1373
		1374	#if defined(_WIN32) \|\| defined(OS2) \|\| defined(MSDOS)
		1375	# include <fcntl.h>
		1376	# include <io.h>
		1377	# define SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY)
		1378	#else
		1379	# define SET_BINARY_MODE(file)
		1380	#endif
		1381	static
		1382	BZFILE * bzopen_or_bzdopen
		1383	( const char path, / no use when bzdopen */
		1384	int fd, /* no use when bzdopen */
		1385	const char *mode,
		1386	int open_mode) /* bzopen: 0, bzdopen:1 */
		1387	{
		1388	int bzerr;
		1389	char unused[BZ_MAX_UNUSED];
		1390	int blockSize100k = 9;
		1391	int writing = 0;
		1392	char mode2[10] = "";
		1393	FILE *fp = NULL;
		1394	BZFILE *bzfp = NULL;
		1395	int verbosity = 0;
		1396	int workFactor = 30;
		1397	int smallMode = 0;
		1398	int nUnused = 0;
		1399
		1400	if (mode == NULL) return NULL;
		1401	while (*mode) {
		1402	switch (*mode) {
		1403	case 'r':
		1404	writing = 0; break;
		1405	case 'w':
		1406	writing = 1; break;
		1407	case 's':
		1408	smallMode = 1; break;
		1409	default:
		1410	if (isdigit((int)(*mode))) {
		1411	blockSize100k = *mode-BZ_HDR_0;
		1412	}
		1413	}
		1414	mode++;
		1415	}
		1416	strcat(mode2, writing ? "w" : "r" );
		1417	strcat(mode2,"b"); /* binary mode */
		1418
		1419	if (open_mode==0) {
		1420	if (path==NULL \|\| strcmp(path,"")==0) {
		1421	fp = (writing ? stdout : stdin);
		1422	SET_BINARY_MODE(fp);
		1423	} else {
		1424	fp = fopen(path,mode2);
		1425	}
		1426	} else {
		1427	#ifdef BZ_STRICT_ANSI
		1428	fp = NULL;
		1429	#else
		1430	fp = fdopen(fd,mode2);
		1431	#endif
		1432	}
		1433	if (fp == NULL) return NULL;
		1434
		1435	if (writing) {
		1436	/* Guard against total chaos and anarchy -- JRS */
		1437	if (blockSize100k < 1) blockSize100k = 1;
		1438	if (blockSize100k > 9) blockSize100k = 9;
		1439	bzfp = BZ2_bzWriteOpen(&bzerr,fp,blockSize100k,
		1440	verbosity,workFactor);
		1441	} else {
		1442	bzfp = BZ2_bzReadOpen(&bzerr,fp,verbosity,smallMode,
		1443	unused,nUnused);
		1444	}
		1445	if (bzfp == NULL) {
		1446	if (fp != stdin && fp != stdout) fclose(fp);
		1447	return NULL;
		1448	}
		1449	return bzfp;
		1450	}
		1451
		1452
		1453	/---------------------------------------------------/
		1454	/*--
		1455	open file for read or write.
		1456	ex) bzopen("file","w9")
		1457	case path="" or NULL => use stdin or stdout.
		1458	--*/
		1459	BZFILE * BZ_API(BZ2_bzopen)
		1460	( const char *path,
		1461	const char *mode )
		1462	{
		1463	return bzopen_or_bzdopen(path,-1,mode,/bzopen/0);
		1464	}
		1465
		1466
		1467	/---------------------------------------------------/
		1468	BZFILE * BZ_API(BZ2_bzdopen)
		1469	( int fd,
		1470	const char *mode )
		1471	{
		1472	return bzopen_or_bzdopen(NULL,fd,mode,/bzdopen/1);
		1473	}
		1474
		1475
		1476	/---------------------------------------------------/
		1477	int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len )
		1478	{
		1479	int bzerr, nread;
		1480	if (((bzFile*)b)->lastErr == BZ_STREAM_END) return 0;
		1481	nread = BZ2_bzRead(&bzerr,b,buf,len);
		1482	if (bzerr == BZ_OK \|\| bzerr == BZ_STREAM_END) {
		1483	return nread;
		1484	} else {
		1485	return -1;
		1486	}
		1487	}
		1488
		1489
		1490	/---------------------------------------------------/
		1491	int BZ_API(BZ2_bzwrite) (BZFILE* b, void* buf, int len )
		1492	{
		1493	int bzerr;
		1494
		1495	BZ2_bzWrite(&bzerr,b,buf,len);
		1496	if(bzerr == BZ_OK){
		1497	return len;
		1498	}else{
		1499	return -1;
		1500	}
		1501	}
		1502
		1503
		1504	/---------------------------------------------------/
		1505	int BZ_API(BZ2_bzflush) (BZFILE *b)
		1506	{
		1507	/* do nothing now... */
		1508	return 0;
		1509	}
		1510
		1511
		1512	/---------------------------------------------------/
		1513	void BZ_API(BZ2_bzclose) (BZFILE* b)
		1514	{
		1515	int bzerr;
		1516	FILE *fp;
		1517
		1518	if (b==NULL) {return;}
		1519	fp = ((bzFile *)b)->handle;
		1520	if(((bzFile*)b)->writing){
		1521	BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL);
		1522	if(bzerr != BZ_OK){
		1523	BZ2_bzWriteClose(NULL,b,1,NULL,NULL);
		1524	}
		1525	}else{
		1526	BZ2_bzReadClose(&bzerr,b);
		1527	}
		1528	if(fp!=stdin && fp!=stdout){
		1529	fclose(fp);
		1530	}
		1531	}
		1532
		1533
		1534	/---------------------------------------------------/
		1535	/*--
		1536	return last error code
		1537	--*/
		1538	static const char *bzerrorstrings[] = {
		1539	"OK"
		1540	,"SEQUENCE_ERROR"
		1541	,"PARAM_ERROR"
		1542	,"MEM_ERROR"
		1543	,"DATA_ERROR"
		1544	,"DATA_ERROR_MAGIC"
		1545	,"IO_ERROR"
		1546	,"UNEXPECTED_EOF"
		1547	,"OUTBUFF_FULL"
		1548	,"CONFIG_ERROR"
		1549	,"???" /* for future */
		1550	,"???" /* for future */
		1551	,"???" /* for future */
		1552	,"???" /* for future */
		1553	,"???" /* for future */
		1554	,"???" /* for future */
		1555	};
		1556
		1557
		1558	const char * BZ_API(BZ2_bzerror) (BZFILE b, int errnum)
		1559	{
		1560	int err = ((bzFile *)b)->lastErr;
		1561
		1562	if(err>0) err = 0;
		1563	*errnum = err;
		1564	return bzerrorstrings[err*-1];
		1565	}
		1566	#endif
		1567
		1568
		1569	/-------------------------------------------------------------/
		1570	/--- end bzlib.c ---/
		1571	/-------------------------------------------------------------/

Subversion Repositories nw_plus

(root)/nw_plus/utils/source/bsdiff-4.3/win32/bzlib.c – Rev 23