mirror/unalz
1
0
Fork 1
Code Issues Pull requests Releases Wiki Activity

v0.65

Browse source
This commit is contained in:
King_DuckZ 2020-05-05 20:33:47 +02:00
parent c9bd217232
commit c4ad00c487
15 changed files with 3129 additions and 3419 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
UnAlz.cpp
View file

@ -8,6 +8,10 @@
#endif #endif
#ifdef _WIN32
# pragma warning( disable : 4996 ) // crt secure warning
#endif
// utime 함수 처리 // utime 함수 처리
#if defined(_WIN32) || defined(__CYGWIN__) #if defined(_WIN32) || defined(__CYGWIN__)
# include <time.h> # include <time.h>
@ -38,11 +42,6 @@
# include <errno.h> // iconv.h 때문에 필요 # include <errno.h> // iconv.h 때문에 필요
#endif #endif
#ifdef _WIN32 // string conversion
# include <atlbase.h>
# include <atlconv.h>
#endif
#ifdef _WIN32 // safe string 처리 #ifdef _WIN32 // safe string 처리
# include <strsafe.h> # include <strsafe.h>
#endif #endif
@ -246,8 +245,9 @@ void CUnAlz::SetCallback(_UnAlzCallback* pFunc, void* param)
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::Open(LPCWSTR szPathName) BOOL CUnAlz::Open(LPCWSTR szPathName)
{ {
USES_CONVERSION; char szPathNameA[MAX_PATH];
return Open(W2A(szPathName)); ::WideCharToMultiByte(CP_ACP, 0, szPathName, -1, szPathNameA, MAX_PATH, NULL, NULL);
return Open(szPathNameA);
} }
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
/// 대상 파일 세팅하기. /// 대상 파일 세팅하기.
@ -257,8 +257,9 @@ BOOL CUnAlz::Open(LPCWSTR szPathName)
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUnAlz::SetCurrentFile(LPCWSTR szFileName) BOOL CUnAlz::SetCurrentFile(LPCWSTR szFileName)
{ {
USES_CONVERSION; char szFileNameA[MAX_PATH];
return SetCurrentFile(W2A(szFileName)); ::WideCharToMultiByte(CP_ACP, 0, szFileName, -1, szFileNameA, MAX_PATH, NULL, NULL);
return SetCurrentFile(szFileNameA);
} }
BOOL CUnAlz::IsFolder(LPCWSTR szPathName) BOOL CUnAlz::IsFolder(LPCWSTR szPathName)
{ {

8
UnAlz.h
View file

@ -41,7 +41,7 @@
- .ALZ 의 압축을 해제하기 위한 모듈. - .ALZ 의 압축을 해제하기 위한 모듈.
- ALZ는 BZIP2변형(변형이라고 뭐 개선한게 아니고, 헤더나 CRC 정보등을 빼서 크기를 줄인 것임)과, - ALZ는 BZIP2변형(변형이라고 뭐 개선한게 아니고, 헤더나 CRC 정보등을 빼서 크기를 줄인 것임)과,
DEFLATE 압축 알고리즘에 ZIP과 유사한 헤더를 만들어서 씌운 포맷임. DEFLATE 압축 알고리즘에 ZIP과 유사한 헤더를 만들어서 씌운 포맷임.
(bzip2 는 4.9x 에서 사용하였고, deflate 는 5.x 부터 사용하였음. 5.x 부터는 bzip2는 너무 느려서 사용 안함) (bzip2 는 알집 4.9x 에서 사용하였고, deflate 는 5.x 부터 사용하였음. 5.x 부터는 bzip2는 너무 느려서 사용 안함)
- UnAlzBz2decompress.c 와 UnAlzbzlib.c 는 원래의 bzip2 소스에서 alz 용으로 수정된 파일임 - UnAlzBz2decompress.c 와 UnAlzbzlib.c 는 원래의 bzip2 소스에서 alz 용으로 수정된 파일임
(deflate 는 변형이 안되었기 때문에 그냥 zlib 를 써도 되지만.. bzip2 는 변형이 되어서 (deflate 는 변형이 안되었기 때문에 그냥 zlib 를 써도 되지만.. bzip2 는 변형이 되어서
원래의 bzip2 소스를 그대로 쓰면 안된다.) 원래의 bzip2 소스를 그대로 쓰면 안된다.)
@ -119,6 +119,10 @@
- 파일 리스팅 부분 수정 - 파일 리스팅 부분 수정
- 소스 정리 - 소스 정리
- unalz 0.64 - unalz 0.64
2009/04/01 - bzip2 1.0.5 update
- vs2008 컴파일 관련 이슈 수정(atlconv 안쓰기, crt secure warning disable) (by kaisyu@gmail)
- unalz 0.65
기능 : 기능 :
- alz 파일의 압축 해제 (deflate/변형 bzip2/raw) - alz 파일의 압축 해제 (deflate/변형 bzip2/raw)
@ -224,7 +228,7 @@ namespace UNALZ
# pragma pack(1) # pragma pack(1)
#endif #endif
static const char UNALZ_VERSION[] = "CUnAlz0.63"; static const char UNALZ_VERSION[] = "CUnAlz0.65";
static const char UNALZ_COPYRIGHT[] = "Copyright(C) 2004-2009 by kippler@gmail.com ( http://www.kipple.pe.kr ) "; static const char UNALZ_COPYRIGHT[] = "Copyright(C) 2004-2009 by kippler@gmail.com ( http://www.kipple.pe.kr ) ";
enum {ALZ_ENCR_HEADER_LEN=12}; // xf86 enum {ALZ_ENCR_HEADER_LEN=12}; // xf86

161
UnAlzBz2decompress.c
View file

@ -7,59 +7,19 @@
/*--- decompress.c ---*/ /*--- decompress.c ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*-- /* ------------------------------------------------------------------
This file is a part of bzip2 and/or libbzip2, a program and This file is part of bzip2/libbzip2, a program and library for
library for lossless, block-sorting data compression. lossless, block-sorting data compression.
Copyright (C) 1996-2002 Julian R Seward. All rights reserved. bzip2/libbzip2 version 1.0.5 of 10 December 2007
Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org>
Redistribution and use in source and binary forms, with or without Please read the WARNING, DISCLAIMER and PATENTS sections in the
modification, are permitted provided that the following conditions README file.
are met:
1. Redistributions of source code must retain the above copyright This program is released under the terms of the license contained
notice, this list of conditions and the following disclaimer. in the file LICENSE.
------------------------------------------------------------------ */
2. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
4. The name of the author may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Julian Seward, Cambridge, UK.
jseward@acm.org
bzip2/libbzip2 version 1.0 of 21 March 2000
This program is based on (at least) the work of:
Mike Burrows
David Wheeler
Peter Fenwick
Alistair Moffat
Radford Neal
Ian H. Witten
Robert Sedgewick
Jon L. Bentley
For more information on these sources, see the manual.
--*/
#include "bzip2/bzlib_private.h" #include "bzip2/bzlib_private.h"
@ -240,16 +200,13 @@ Int32 BZ2_decompress ( DState* s )
// [ALZ] - 머리 떼기 // [ALZ] - 머리 떼기
/* /*
GET_UCHAR(BZ_X_MAGIC_1, uc); GET_UCHAR(BZ_X_MAGIC_1, uc);
if (uc != BZ_HDR_B) if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC);
RETURN(BZ_DATA_ERROR_MAGIC);
GET_UCHAR(BZ_X_MAGIC_2, uc); GET_UCHAR(BZ_X_MAGIC_2, uc);
if (uc != BZ_HDR_Z) if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC);
RETURN(BZ_DATA_ERROR_MAGIC);
GET_UCHAR(BZ_X_MAGIC_3, uc) GET_UCHAR(BZ_X_MAGIC_3, uc)
if (uc != BZ_HDR_h) if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC);
RETURN(BZ_DATA_ERROR_MAGIC);
*/ */
case BZ_X_MAGIC_1 : // 없어진 헤더 인식 대신 case BZ_X_MAGIC_1 : // 없어진 헤더 인식 대신
@ -259,8 +216,7 @@ Int32 BZ2_decompress ( DState* s )
s->blockSize100k = 0x39; // static 할당. s->blockSize100k = 0x39; // static 할당.
if (s->blockSize100k < (BZ_HDR_0 + 1) || if (s->blockSize100k < (BZ_HDR_0 + 1) ||
s->blockSize100k > (BZ_HDR_0 + 9)) s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
RETURN(BZ_DATA_ERROR_MAGIC);
s->blockSize100k -= BZ_HDR_0; s->blockSize100k -= BZ_HDR_0;
if (s->smallDecompress) { if (s->smallDecompress) {
@ -268,12 +224,10 @@ Int32 BZ2_decompress ( DState* s )
s->ll4 = BZALLOC( s->ll4 = BZALLOC(
((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar) ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)
); );
if (s->ll16 == NULL || s->ll4 == NULL) if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
RETURN(BZ_MEM_ERROR);
} else { } else {
s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) ); s->tt = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
if (s->tt == NULL) if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
RETURN(BZ_MEM_ERROR);
} }
GET_UCHAR(BZ_X_BLKHDR_1, uc); GET_UCHAR(BZ_X_BLKHDR_1, uc);
@ -300,23 +254,17 @@ Int32 BZ2_decompress ( DState* s )
/* [ALZ] - 원래 헤더 /* [ALZ] - 원래 헤더
if (uc == 0x17) goto endhdr_2; if (uc == 0x17) goto endhdr_2;
if (uc != 0x31) if (uc != 0x31) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_BLKHDR_2, uc); GET_UCHAR(BZ_X_BLKHDR_2, uc);
if (uc != 0x41) if (uc != 0x41) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_BLKHDR_3, uc); GET_UCHAR(BZ_X_BLKHDR_3, uc);
if (uc != 0x59) if (uc != 0x59) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_BLKHDR_4, uc); GET_UCHAR(BZ_X_BLKHDR_4, uc);
if (uc != 0x26) if (uc != 0x26) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_BLKHDR_5, uc); GET_UCHAR(BZ_X_BLKHDR_5, uc);
if (uc != 0x53) if (uc != 0x53) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_BLKHDR_6, uc); GET_UCHAR(BZ_X_BLKHDR_6, uc);
if (uc != 0x59) if (uc != 0x59) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
*/ */
s->currBlockNo++; s->currBlockNo++;
@ -369,25 +317,21 @@ Int32 BZ2_decompress ( DState* s )
if (uc == 1) s->inUse[i * 16 + j] = True; if (uc == 1) s->inUse[i * 16 + j] = True;
} }
makeMaps_d ( s ); makeMaps_d ( s );
if (s->nInUse == 0) if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
alphaSize = s->nInUse+2; alphaSize = s->nInUse+2;
/*--- Now the selectors ---*/ /*--- Now the selectors ---*/
GET_BITS(BZ_X_SELECTOR_1, nGroups, 3); GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
if (nGroups < 2 || nGroups > 6) if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15); GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
if (nSelectors < 1) if (nSelectors < 1) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
for (i = 0; i < nSelectors; i++) { for (i = 0; i < nSelectors; i++) {
j = 0; j = 0;
while (True) { while (True) {
GET_BIT(BZ_X_SELECTOR_3, uc); GET_BIT(BZ_X_SELECTOR_3, uc);
if (uc == 0) break; if (uc == 0) break;
j++; j++;
if (j >= nGroups) if (j >= nGroups) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
} }
s->selectorMtf[i] = j; s->selectorMtf[i] = j;
} }
@ -411,8 +355,7 @@ Int32 BZ2_decompress ( DState* s )
GET_BITS(BZ_X_CODING_1, curr, 5); GET_BITS(BZ_X_CODING_1, curr, 5);
for (i = 0; i < alphaSize; i++) { for (i = 0; i < alphaSize; i++) {
while (True) { while (True) {
if (curr < 1 || curr > 20) if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
GET_BIT(BZ_X_CODING_2, uc); GET_BIT(BZ_X_CODING_2, uc);
if (uc == 0) break; if (uc == 0) break;
GET_BIT(BZ_X_CODING_3, uc); GET_BIT(BZ_X_CODING_3, uc);
@ -488,16 +431,14 @@ Int32 BZ2_decompress ( DState* s )
if (s->smallDecompress) if (s->smallDecompress)
while (es > 0) { while (es > 0) {
if (nblock >= nblockMAX) if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
s->ll16[nblock] = (UInt16)uc; s->ll16[nblock] = (UInt16)uc;
nblock++; nblock++;
es--; es--;
} }
else else
while (es > 0) { while (es > 0) {
if (nblock >= nblockMAX) if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
s->tt[nblock] = (UInt32)uc; s->tt[nblock] = (UInt32)uc;
nblock++; nblock++;
es--; es--;
@ -507,8 +448,7 @@ Int32 BZ2_decompress ( DState* s )
} else { } else {
if (nblock >= nblockMAX) if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR);
/*-- uc = MTF ( nextSym-1 ) --*/ /*-- uc = MTF ( nextSym-1 ) --*/
{ {
@ -581,17 +521,23 @@ Int32 BZ2_decompress ( DState* s )
if (s->origPtr < 0 || s->origPtr >= nblock) if (s->origPtr < 0 || s->origPtr >= nblock)
RETURN(BZ_DATA_ERROR); RETURN(BZ_DATA_ERROR);
/*-- Set up cftab to facilitate generation of T^(-1) --*/
s->cftab[0] = 0;
for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
for (i = 0; i <= 256; i++) {
if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
/* s->cftab[i] can legitimately be == nblock */
RETURN(BZ_DATA_ERROR);
}
}
s->state_out_len = 0; s->state_out_len = 0;
s->state_out_ch = 0; s->state_out_ch = 0;
BZ_INITIALISE_CRC ( s->calculatedBlockCRC ); BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
s->state = BZ_X_OUTPUT; s->state = BZ_X_OUTPUT;
if (s->verbosity >= 2) VPrintf0 ( "rt+rld" ); if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );
/*-- Set up cftab to facilitate generation of T^(-1) --*/
s->cftab[0] = 0;
for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
if (s->smallDecompress) { if (s->smallDecompress) {
/*-- Make a copy of cftab, used in generation of T --*/ /*-- Make a copy of cftab, used in generation of T --*/
@ -656,21 +602,16 @@ Int32 BZ2_decompress ( DState* s )
// [ALZ] - 꼬리 떼기 // [ALZ] - 꼬리 떼기
/* /*
GET_UCHAR(BZ_X_ENDHDR_2, uc); GET_UCHAR(BZ_X_ENDHDR_2, uc);
if (uc != 0x72) if (uc != 0x72) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR); GET_UCHAR(BZ_X_ENDHDR_3, uc);
GET_UCHAR(BZ_X_ENDHDR_3, uc); if (uc != 0x45) RETURN(BZ_DATA_ERROR);
if (uc != 0x45) GET_UCHAR(BZ_X_ENDHDR_4, uc);
RETURN(BZ_DATA_ERROR); if (uc != 0x38) RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_ENDHDR_4, uc); GET_UCHAR(BZ_X_ENDHDR_5, uc);
if (uc != 0x38) if (uc != 0x50) RETURN(BZ_DATA_ERROR);
RETURN(BZ_DATA_ERROR); GET_UCHAR(BZ_X_ENDHDR_6, uc);
GET_UCHAR(BZ_X_ENDHDR_5, uc); if (uc != 0x90) RETURN(BZ_DATA_ERROR);
if (uc != 0x50)
RETURN(BZ_DATA_ERROR);
GET_UCHAR(BZ_X_ENDHDR_6, uc);
if (uc != 0x90)
RETURN(BZ_DATA_ERROR);
s->storedCombinedCRC = 0; s->storedCombinedCRC = 0;
GET_UCHAR(BZ_X_CCRC_1, uc); GET_UCHAR(BZ_X_CCRC_1, uc);

5
UnAlzUtils.cpp
View file

@ -10,6 +10,11 @@
# define U64FORM(x) "%"#x"llu" # define U64FORM(x) "%"#x"llu"
#endif #endif
#ifdef _WIN32
# pragma warning( disable : 4996 ) // crt secure warning
#endif
#define LEN_ATTR 6 #define LEN_ATTR 6
time_t dosTime2TimeT(UINT32 dostime) // from INFO-ZIP src time_t dosTime2TimeT(UINT32 dostime) // from INFO-ZIP src

157
UnAlzbzlib.c
View file

@ -9,80 +9,39 @@
// ALZ 압축 해제를 위해서 수정된 bzip2 소스 // ALZ 압축 해제를 위해서 수정된 bzip2 소스
// [ALZ] 라고 표시된 부분이 수정된 부분이다. // [ALZ] 라고 표시된 부분이 수정된 부분이다.
#ifdef _WIN32
# pragma warning( disable : 4996 ) // crt secure warning
#endif
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- Library top-level functions. ---*/ /*--- Library top-level functions. ---*/
/*--- bzlib.c ---*/ /*--- bzlib.c ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*-- /* ------------------------------------------------------------------
This file is a part of bzip2 and/or libbzip2, a program and This file is part of bzip2/libbzip2, a program and library for
library for lossless, block-sorting data compression. lossless, block-sorting data compression.
Copyright (C) 1996-2002 Julian R Seward. All rights reserved. bzip2/libbzip2 version 1.0.5 of 10 December 2007
Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org>
Redistribution and use in source and binary forms, with or without Please read the WARNING, DISCLAIMER and PATENTS sections in the
modification, are permitted provided that the following conditions README file.
are met:
1. Redistributions of source code must retain the above copyright This program is released under the terms of the license contained
notice, this list of conditions and the following disclaimer. in the file LICENSE.
------------------------------------------------------------------ */
2. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
4. The name of the author may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Julian Seward, Cambridge, UK.
jseward@acm.org
bzip2/libbzip2 version 1.0 of 21 March 2000
This program is based on (at least) the work of:
Mike Burrows
David Wheeler
Peter Fenwick
Alistair Moffat
Radford Neal
Ian H. Witten
Robert Sedgewick
Jon L. Bentley
For more information on these sources, see the manual.
--*/
/*--
CHANGES
~~~~~~~
0.9.0 -- original version.
/* CHANGES
0.9.0 -- original version.
0.9.0a/b -- no changes in this file. 0.9.0a/b -- no changes in this file.
0.9.0c -- made zero-length BZ_FLUSH work correctly in bzCompress().
0.9.0c fixed bzWrite/bzRead to ignore zero-length requests.
* made zero-length BZ_FLUSH work correctly in bzCompress(). fixed bzread to correctly handle read requests after EOF.
* fixed bzWrite/bzRead to ignore zero-length requests. wrong parameter order in call to bzDecompressInit in
* fixed bzread to correctly handle read requests after EOF. bzBuffToBuffDecompress. Fixed.
* wrong parameter order in call to bzDecompressInit in */
bzBuffToBuffDecompress. Fixed.
--*/
#include "bzip2/bzlib_private.h" #include "bzip2/bzlib_private.h"
@ -99,12 +58,12 @@ void BZ2_bz__AssertH__fail ( int errcode )
fprintf(stderr, fprintf(stderr,
"\n\nbzip2/libbzip2: internal error number %d.\n" "\n\nbzip2/libbzip2: internal error number %d.\n"
"This is a bug in bzip2/libbzip2, %s.\n" "This is a bug in bzip2/libbzip2, %s.\n"
"Please report it to me at: jseward@acm.org. If this happened\n" "Please report it to me at: jseward@bzip.org. If this happened\n"
"when you were using some program which uses libbzip2 as a\n" "when you were using some program which uses libbzip2 as a\n"
"component, you should also report this bug to the author(s)\n" "component, you should also report this bug to the author(s)\n"
"of that program. Please make an effort to report this bug;\n" "of that program. Please make an effort to report this bug;\n"
"timely and accurate bug reports eventually lead to higher\n" "timely and accurate bug reports eventually lead to higher\n"
"quality software. Thanks. Julian Seward, 30 December 2001.\n\n", "quality software. Thanks. Julian Seward, 10 December 2007.\n\n",
errcode, errcode,
BZ2_bzlibVersion() BZ2_bzlibVersion()
); );
@ -585,8 +544,11 @@ int BZ_API(BZ2_bzDecompressInit)
/*---------------------------------------------------*/ /*---------------------------------------------------*/
/* Return True iff data corruption is discovered.
Returns False if there is no problem.
*/
static static
void unRLE_obuf_to_output_FAST ( DState* s ) Bool unRLE_obuf_to_output_FAST ( DState* s )
{ {
UChar k1; UChar k1;
@ -595,7 +557,7 @@ void unRLE_obuf_to_output_FAST ( DState* s )
while (True) { while (True) {
/* try to finish existing run */ /* try to finish existing run */
while (True) { while (True) {
if (s->strm->avail_out == 0) return; if (s->strm->avail_out == 0) return False;
if (s->state_out_len == 0) break; if (s->state_out_len == 0) break;
*( (UChar*)(s->strm->next_out) ) = s->state_out_ch; *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
@ -605,10 +567,13 @@ void unRLE_obuf_to_output_FAST ( DState* s )
s->strm->total_out_lo32++; s->strm->total_out_lo32++;
if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++; if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
} }
/* can a new run be started? */ /* can a new run be started? */
if (s->nblock_used == s->save_nblock+1) return; if (s->nblock_used == s->save_nblock+1) return False;
/* Only caused by corrupt data stream? */
if (s->nblock_used > s->save_nblock+1)
return True;
s->state_out_len = 1; s->state_out_len = 1;
s->state_out_ch = s->k0; s->state_out_ch = s->k0;
@ -648,6 +613,7 @@ void unRLE_obuf_to_output_FAST ( DState* s )
UInt32 c_tPos = s->tPos; UInt32 c_tPos = s->tPos;
char* cs_next_out = s->strm->next_out; char* cs_next_out = s->strm->next_out;
unsigned int cs_avail_out = s->strm->avail_out; unsigned int cs_avail_out = s->strm->avail_out;
Int32 ro_blockSize100k = s->blockSize100k;
/* end restore */ /* end restore */
UInt32 avail_out_INIT = cs_avail_out; UInt32 avail_out_INIT = cs_avail_out;
@ -678,6 +644,10 @@ void unRLE_obuf_to_output_FAST ( DState* s )
cs_avail_out--; cs_avail_out--;
} }
} }
/* Only caused by corrupt data stream? */
if (c_nblock_used > s_save_nblockPP)
return True;
/* can a new run be started? */ /* can a new run be started? */
if (c_nblock_used == s_save_nblockPP) { if (c_nblock_used == s_save_nblockPP) {
c_state_out_len = 0; goto return_notr; c_state_out_len = 0; goto return_notr;
@ -723,6 +693,7 @@ void unRLE_obuf_to_output_FAST ( DState* s )
s->strm->avail_out = cs_avail_out; s->strm->avail_out = cs_avail_out;
/* end save */ /* end save */
} }
return False;
} }
@ -743,8 +714,11 @@ __inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
/*---------------------------------------------------*/ /*---------------------------------------------------*/
/* Return True iff data corruption is discovered.
Returns False if there is no problem.
*/
static static
void unRLE_obuf_to_output_SMALL ( DState* s ) Bool unRLE_obuf_to_output_SMALL ( DState* s )
{ {
UChar k1; UChar k1;
@ -753,7 +727,7 @@ void unRLE_obuf_to_output_SMALL ( DState* s )
while (True) { while (True) {
/* try to finish existing run */ /* try to finish existing run */
while (True) { while (True) {
if (s->strm->avail_out == 0) return; if (s->strm->avail_out == 0) return False;
if (s->state_out_len == 0) break; if (s->state_out_len == 0) break;
*( (UChar*)(s->strm->next_out) ) = s->state_out_ch; *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
@ -765,8 +739,11 @@ void unRLE_obuf_to_output_SMALL ( DState* s )
} }
/* can a new run be started? */ /* can a new run be started? */
if (s->nblock_used == s->save_nblock+1) return; if (s->nblock_used == s->save_nblock+1) return False;
/* Only caused by corrupt data stream? */
if (s->nblock_used > s->save_nblock+1)
return True;
s->state_out_len = 1; s->state_out_len = 1;
s->state_out_ch = s->k0; s->state_out_ch = s->k0;
@ -799,7 +776,7 @@ void unRLE_obuf_to_output_SMALL ( DState* s )
while (True) { while (True) {
/* try to finish existing run */ /* try to finish existing run */
while (True) { while (True) {
if (s->strm->avail_out == 0) return; if (s->strm->avail_out == 0) return False;
if (s->state_out_len == 0) break; if (s->state_out_len == 0) break;
*( (UChar*)(s->strm->next_out) ) = s->state_out_ch; *( (UChar*)(s->strm->next_out) ) = s->state_out_ch;
BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch ); BZ_UPDATE_CRC ( s->calculatedBlockCRC, s->state_out_ch );
@ -811,7 +788,11 @@ void unRLE_obuf_to_output_SMALL ( DState* s )
} }
/* can a new run be started? */ /* can a new run be started? */
if (s->nblock_used == s->save_nblock+1) return; if (s->nblock_used == s->save_nblock+1) return False;
/* Only caused by corrupt data stream? */
if (s->nblock_used > s->save_nblock+1)
return True;
s->state_out_len = 1; s->state_out_len = 1;
s->state_out_ch = s->k0; s->state_out_ch = s->k0;
@ -841,6 +822,7 @@ void unRLE_obuf_to_output_SMALL ( DState* s )
/*---------------------------------------------------*/ /*---------------------------------------------------*/
int BZ_API(BZ2_bzDecompress) ( bz_stream *strm ) int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
{ {
Bool corrupt;
DState* s; DState* s;
if (strm == NULL) return BZ_PARAM_ERROR; if (strm == NULL) return BZ_PARAM_ERROR;
s = strm->state; s = strm->state;
@ -848,16 +830,16 @@ int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
if (s->strm != strm) return BZ_PARAM_ERROR; if (s->strm != strm) return BZ_PARAM_ERROR;
while (True) { while (True) {
if (s->state == BZ_X_IDLE) if (s->state == BZ_X_IDLE) return BZ_SEQUENCE_ERROR;
return BZ_SEQUENCE_ERROR;
if (s->state == BZ_X_OUTPUT) { if (s->state == BZ_X_OUTPUT) {
if (s->smallDecompress) if (s->smallDecompress)
unRLE_obuf_to_output_SMALL ( s ); else corrupt = unRLE_obuf_to_output_SMALL ( s ); else
unRLE_obuf_to_output_FAST ( s ); corrupt = unRLE_obuf_to_output_FAST ( s );
if (corrupt) return BZ_DATA_ERROR;
if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) { if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
BZ_FINALISE_CRC ( s->calculatedBlockCRC ); BZ_FINALISE_CRC ( s->calculatedBlockCRC );
if (s->verbosity >= 3) if (s->verbosity >= 3)
VPrintf2 ( " {0x%x, 0x%x}", s->storedBlockCRC, VPrintf2 ( " {0x%08x, 0x%08x}", s->storedBlockCRC,
s->calculatedBlockCRC ); s->calculatedBlockCRC );
if (s->verbosity >= 2) VPrintf0 ( "]" ); if (s->verbosity >= 2) VPrintf0 ( "]" );
@ -877,15 +859,14 @@ int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
Int32 r = BZ2_decompress ( s ); Int32 r = BZ2_decompress ( s );
if (r == BZ_STREAM_END) { if (r == BZ_STREAM_END) {
if (s->verbosity >= 3) if (s->verbosity >= 3)
VPrintf2 ( "\n combined CRCs: stored = 0x%x, computed = 0x%x", VPrintf2 ( "\n combined CRCs: stored = 0x%08x, computed = 0x%08x",
s->storedCombinedCRC, s->calculatedCombinedCRC ); s->storedCombinedCRC, s->calculatedCombinedCRC );
// [ALZ] // [ALZ]
// if (s->calculatedCombinedCRC != s->storedCombinedCRC) // if (s->calculatedCombinedCRC != s->storedCombinedCRC)
// return BZ_DATA_ERROR; // return BZ_DATA_ERROR;
return r; return r;
} }
if (s->state != BZ_X_OUTPUT) if (s->state != BZ_X_OUTPUT) return r;
return r;
} }
} }
@ -1387,8 +1368,7 @@ int BZ_API(BZ2_bzBuffToBuffDecompress)
/*---------------------------------------------------*/ /*---------------------------------------------------*/
/*-- /*--
Code contributed by Yoshioka Tsuneo Code contributed by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp)
(QWF00133@niftyserve.or.jp/tsuneo-y@is.aist-nara.ac.jp),
to support better zlib compatibility. to support better zlib compatibility.
This code is not _officially_ part of libbzip2 (yet); This code is not _officially_ part of libbzip2 (yet);
I haven't tested it, documented it, or considered the I haven't tested it, documented it, or considered the
@ -1399,7 +1379,7 @@ int BZ_API(BZ2_bzBuffToBuffDecompress)
/*---------------------------------------------------*/ /*---------------------------------------------------*/
/*-- /*--
return version like "0.9.0c". return version like "0.9.5d, 4-Sept-1999".
--*/ --*/
const char * BZ_API(BZ2_bzlibVersion)(void) const char * BZ_API(BZ2_bzlibVersion)(void)
{ {
@ -1557,9 +1537,10 @@ int BZ_API(BZ2_bzflush) (BZFILE *b)
void BZ_API(BZ2_bzclose) (BZFILE* b) void BZ_API(BZ2_bzclose) (BZFILE* b)
{ {
int bzerr; int bzerr;
FILE *fp = ((bzFile *)b)->handle; FILE *fp;
if (b==NULL) {return;} if (b==NULL) {return;}
fp = ((bzFile *)b)->handle;
if(((bzFile*)b)->writing){ if(((bzFile*)b)->writing){
BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL); BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL);
if(bzerr != BZ_OK){ if(bzerr != BZ_OK){
@ -1578,7 +1559,7 @@ void BZ_API(BZ2_bzclose) (BZFILE* b)
/*-- /*--
return last error code return last error code
--*/ --*/
static char *bzerrorstrings[] = { static const char *bzerrorstrings[] = {
"OK" "OK"
,"SEQUENCE_ERROR" ,"SEQUENCE_ERROR"
,"PARAM_ERROR" ,"PARAM_ERROR"

2235
bzip2/blocksort.c
View file

File diff suppressed because it is too large Load diff

603
bzip2/bzlib.h
View file

@ -1,321 +1,282 @@
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- Public header file for the library. ---*/ /*--- Public header file for the library. ---*/
/*--- bzlib.h ---*/ /*--- bzlib.h ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*-- /* ------------------------------------------------------------------
This file is a part of bzip2 and/or libbzip2, a program and This file is part of bzip2/libbzip2, a program and library for
library for lossless, block-sorting data compression. lossless, block-sorting data compression.
Copyright (C) 1996-2002 Julian R Seward. All rights reserved. bzip2/libbzip2 version 1.0.5 of 10 December 2007
Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions Please read the WARNING, DISCLAIMER and PATENTS sections in the
are met: README file.
1. Redistributions of source code must retain the above copyright This program is released under the terms of the license contained
notice, this list of conditions and the following disclaimer. in the file LICENSE.
------------------------------------------------------------------ */
2. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product #ifndef _BZLIB_H
documentation would be appreciated but is not required. #define _BZLIB_H
3. Altered source versions must be plainly marked as such, and must #ifdef __cplusplus
not be misrepresented as being the original software. extern "C" {
#endif
4. The name of the author may not be used to endorse or promote
products derived from this software without specific prior written #define BZ_RUN 0
permission. #define BZ_FLUSH 1
#define BZ_FINISH 2
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED #define BZ_OK 0
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE #define BZ_RUN_OK 1
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY #define BZ_FLUSH_OK 2
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL #define BZ_FINISH_OK 3
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE #define BZ_STREAM_END 4
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS #define BZ_SEQUENCE_ERROR (-1)
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, #define BZ_PARAM_ERROR (-2)
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING #define BZ_MEM_ERROR (-3)
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS #define BZ_DATA_ERROR (-4)
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define BZ_DATA_ERROR_MAGIC (-5)
#define BZ_IO_ERROR (-6)
Julian Seward, Cambridge, UK. #define BZ_UNEXPECTED_EOF (-7)
jseward@acm.org #define BZ_OUTBUFF_FULL (-8)
bzip2/libbzip2 version 1.0 of 21 March 2000 #define BZ_CONFIG_ERROR (-9)
This program is based on (at least) the work of: typedef
Mike Burrows struct {
David Wheeler char *next_in;
Peter Fenwick unsigned int avail_in;
Alistair Moffat unsigned int total_in_lo32;
Radford Neal unsigned int total_in_hi32;
Ian H. Witten
Robert Sedgewick char *next_out;
Jon L. Bentley unsigned int avail_out;
unsigned int total_out_lo32;
For more information on these sources, see the manual. unsigned int total_out_hi32;
--*/
void *state;
#ifndef _BZLIB_H void *(*bzalloc)(void *,int,int);
#define _BZLIB_H void (*bzfree)(void *,void *);
void *opaque;
#ifdef __cplusplus }
extern "C" { bz_stream;
#endif
#define BZ_RUN 0 #ifndef BZ_IMPORT
#define BZ_FLUSH 1 #define BZ_EXPORT
#define BZ_FINISH 2 #endif
#define BZ_OK 0 #ifndef BZ_NO_STDIO
#define BZ_RUN_OK 1 /* Need a definitition for FILE */
#define BZ_FLUSH_OK 2 #include <stdio.h>
#define BZ_FINISH_OK 3 #endif
#define BZ_STREAM_END 4
#define BZ_SEQUENCE_ERROR (-1) #ifdef _WIN32
#define BZ_PARAM_ERROR (-2) # include <windows.h>
#define BZ_MEM_ERROR (-3) # ifdef small
#define BZ_DATA_ERROR (-4) /* windows.h define small to char */
#define BZ_DATA_ERROR_MAGIC (-5) # undef small
#define BZ_IO_ERROR (-6) # endif
#define BZ_UNEXPECTED_EOF (-7) # ifdef BZ_EXPORT
#define BZ_OUTBUFF_FULL (-8) # define BZ_API(func) WINAPI func
#define BZ_CONFIG_ERROR (-9) # define BZ_EXTERN extern
# else
typedef /* import windows dll dynamically */
struct { # define BZ_API(func) (WINAPI * func)
char *next_in; # define BZ_EXTERN
unsigned int avail_in; # endif
unsigned int total_in_lo32; #else
unsigned int total_in_hi32; # define BZ_API(func) func
# define BZ_EXTERN extern
char *next_out; #endif
unsigned int avail_out;
unsigned int total_out_lo32;
unsigned int total_out_hi32; /*-- Core (low-level) library functions --*/
void *state; BZ_EXTERN int BZ_API(BZ2_bzCompressInit) (
bz_stream* strm,
void *(*bzalloc)(void *,int,int); int blockSize100k,
void (*bzfree)(void *,void *); int verbosity,
void *opaque; int workFactor
} );
bz_stream;
BZ_EXTERN int BZ_API(BZ2_bzCompress) (
bz_stream* strm,
#ifndef BZ_IMPORT int action
#define BZ_EXPORT );
#endif
BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) (
/* Need a definitition for FILE */ bz_stream* strm
#include <stdio.h> );
#ifdef _WIN32 BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) (
# include <windows.h> bz_stream *strm,
# ifdef small int verbosity,
/* windows.h define small to char */ int small
# undef small );
# endif
# ifdef BZ_EXPORT BZ_EXTERN int BZ_API(BZ2_bzDecompress) (
# define BZ_API(func) WINAPI func bz_stream* strm
# define BZ_EXTERN extern );
# else
/* import windows dll dynamically */ BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) (
# define BZ_API(func) (WINAPI * func) bz_stream *strm
# define BZ_EXTERN );
# endif
#else
# define BZ_API(func) func
# define BZ_EXTERN extern /*-- High(er) level library functions --*/
#endif
#ifndef BZ_NO_STDIO
#define BZ_MAX_UNUSED 5000
/*-- Core (low-level) library functions --*/
typedef void BZFILE;
BZ_EXTERN int BZ_API(BZ2_bzCompressInit) (
bz_stream* strm, BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) (
int blockSize100k, int* bzerror,
int verbosity, FILE* f,
int workFactor int verbosity,
); int small,
void* unused,
BZ_EXTERN int BZ_API(BZ2_bzCompress) ( int nUnused
bz_stream* strm, );
int action
); BZ_EXTERN void BZ_API(BZ2_bzReadClose) (
int* bzerror,
BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) ( BZFILE* b
bz_stream* strm );
);
BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) (
BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) ( int* bzerror,
bz_stream *strm, BZFILE* b,
int verbosity, void** unused,
int small int* nUnused
); );
BZ_EXTERN int BZ_API(BZ2_bzDecompress) ( BZ_EXTERN int BZ_API(BZ2_bzRead) (
bz_stream* strm int* bzerror,
); BZFILE* b,
void* buf,
BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) ( int len
bz_stream *strm );
);
BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) (
int* bzerror,
FILE* f,
/*-- High(er) level library functions --*/ int blockSize100k,
int verbosity,
#ifndef BZ_NO_STDIO int workFactor
#define BZ_MAX_UNUSED 5000 );
typedef void BZFILE; BZ_EXTERN void BZ_API(BZ2_bzWrite) (
int* bzerror,
BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) ( BZFILE* b,
int* bzerror, void* buf,
FILE* f, int len
int verbosity, );
int small,
void* unused, BZ_EXTERN void BZ_API(BZ2_bzWriteClose) (
int nUnused int* bzerror,
); BZFILE* b,
int abandon,
BZ_EXTERN void BZ_API(BZ2_bzReadClose) ( unsigned int* nbytes_in,
int* bzerror, unsigned int* nbytes_out
BZFILE* b );
);
BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) (
BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) ( int* bzerror,
int* bzerror, BZFILE* b,
BZFILE* b, int abandon,
void** unused, unsigned int* nbytes_in_lo32,
int* nUnused unsigned int* nbytes_in_hi32,
); unsigned int* nbytes_out_lo32,
unsigned int* nbytes_out_hi32
BZ_EXTERN int BZ_API(BZ2_bzRead) ( );
int* bzerror, #endif
BZFILE* b,
void* buf,
int len /*-- Utility functions --*/
);
BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) (
BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) ( char* dest,
int* bzerror, unsigned int* destLen,
FILE* f, char* source,
int blockSize100k, unsigned int sourceLen,
int verbosity, int blockSize100k,
int workFactor int verbosity,
); int workFactor
);
BZ_EXTERN void BZ_API(BZ2_bzWrite) (
int* bzerror, BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) (
BZFILE* b, char* dest,
void* buf, unsigned int* destLen,
int len char* source,
); unsigned int sourceLen,
int small,
BZ_EXTERN void BZ_API(BZ2_bzWriteClose) ( int verbosity
int* bzerror, );
BZFILE* b,
int abandon,
unsigned int* nbytes_in, /*--
unsigned int* nbytes_out Code contributed by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp)
); to support better zlib compatibility.
This code is not _officially_ part of libbzip2 (yet);
BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) ( I haven't tested it, documented it, or considered the
int* bzerror, threading-safeness of it.
BZFILE* b, If this code breaks, please contact both Yoshioka and me.
int abandon, --*/
unsigned int* nbytes_in_lo32,
unsigned int* nbytes_in_hi32, BZ_EXTERN const char * BZ_API(BZ2_bzlibVersion) (
unsigned int* nbytes_out_lo32, void
unsigned int* nbytes_out_hi32 );
);
#endif #ifndef BZ_NO_STDIO
BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) (
const char *path,
/*-- Utility functions --*/ const char *mode
);
BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) (
char* dest, BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) (
unsigned int* destLen, int fd,
char* source, const char *mode
unsigned int sourceLen, );
int blockSize100k,
int verbosity, BZ_EXTERN int BZ_API(BZ2_bzread) (
int workFactor BZFILE* b,
); void* buf,
int len
BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) ( );
char* dest,
unsigned int* destLen, BZ_EXTERN int BZ_API(BZ2_bzwrite) (
char* source, BZFILE* b,
unsigned int sourceLen, void* buf,
int small, int len
int verbosity );
);
BZ_EXTERN int BZ_API(BZ2_bzflush) (
BZFILE* b
/*-- );
Code contributed by Yoshioka Tsuneo
(QWF00133@niftyserve.or.jp/tsuneo-y@is.aist-nara.ac.jp), BZ_EXTERN void BZ_API(BZ2_bzclose) (
to support better zlib compatibility. BZFILE* b
This code is not _officially_ part of libbzip2 (yet); );
I haven't tested it, documented it, or considered the
threading-safeness of it. BZ_EXTERN const char * BZ_API(BZ2_bzerror) (
If this code breaks, please contact both Yoshioka and me. BZFILE *b,
--*/ int *errnum
);
BZ_EXTERN const char * BZ_API(BZ2_bzlibVersion) ( #endif
void
); #ifdef __cplusplus
}
#ifndef BZ_NO_STDIO #endif
BZ_EXTERN BZFILE * BZ_API(BZ2_bzopen) (
const char *path, #endif
const char *mode
); /*-------------------------------------------------------------*/
/*--- end bzlib.h ---*/
BZ_EXTERN BZFILE * BZ_API(BZ2_bzdopen) ( /*-------------------------------------------------------------*/
int fd,
const char *mode
);
BZ_EXTERN int BZ_API(BZ2_bzread) (
BZFILE* b,
void* buf,
int len
);
BZ_EXTERN int BZ_API(BZ2_bzwrite) (
BZFILE* b,
void* buf,
int len
);
BZ_EXTERN int BZ_API(BZ2_bzflush) (
BZFILE* b
);
BZ_EXTERN void BZ_API(BZ2_bzclose) (
BZFILE* b
);
BZ_EXTERN const char * BZ_API(BZ2_bzerror) (
BZFILE *b,
int *errnum
);
#endif
#ifdef __cplusplus
}
#endif
#endif
/*-------------------------------------------------------------*/
/*--- end bzlib.h ---*/
/*-------------------------------------------------------------*/

1046
bzip2/bzlib_private.h
View file

File diff suppressed because it is too large Load diff

1386
bzip2/compress.c
View file

File diff suppressed because it is too large Load diff

248
bzip2/crctable.c
View file

@ -1,144 +1,104 @@
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- Table for doing CRCs ---*/ /*--- Table for doing CRCs ---*/
/*--- crctable.c ---*/ /*--- crctable.c ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*-- /* ------------------------------------------------------------------
This file is a part of bzip2 and/or libbzip2, a program and This file is part of bzip2/libbzip2, a program and library for
library for lossless, block-sorting data compression. lossless, block-sorting data compression.
Copyright (C) 1996-2002 Julian R Seward. All rights reserved. bzip2/libbzip2 version 1.0.5 of 10 December 2007
Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions Please read the WARNING, DISCLAIMER and PATENTS sections in the
are met: README file.
1. Redistributions of source code must retain the above copyright This program is released under the terms of the license contained
notice, this list of conditions and the following disclaimer. in the file LICENSE.
------------------------------------------------------------------ */
2. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product #include "bzlib_private.h"
documentation would be appreciated but is not required.
/*--
3. Altered source versions must be plainly marked as such, and must I think this is an implementation of the AUTODIN-II,
not be misrepresented as being the original software. Ethernet & FDDI 32-bit CRC standard. Vaguely derived
from code by Rob Warnock, in Section 51 of the
4. The name of the author may not be used to endorse or promote comp.compression FAQ.
products derived from this software without specific prior written --*/
permission.
UInt32 BZ2_crc32Table[256] = {
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED /*-- Ugly, innit? --*/
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L,
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L,
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L,
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L,
Julian Seward, Cambridge, UK. 0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
jseward@acm.org 0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L,
bzip2/libbzip2 version 1.0 of 21 March 2000 0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L,
This program is based on (at least) the work of: 0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
Mike Burrows 0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L,
David Wheeler 0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
Peter Fenwick 0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL,
Alistair Moffat 0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
Radford Neal 0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L,
Ian H. Witten 0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
Robert Sedgewick 0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL,
Jon L. Bentley 0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L,
For more information on these sources, see the manual. 0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
--*/ 0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL,
0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
#include "bzlib_private.h" 0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL,
/*-- 0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
I think this is an implementation of the AUTODIN-II, 0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
Ethernet & FDDI 32-bit CRC standard. Vaguely derived 0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
from code by Rob Warnock, in Section 51 of the 0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
comp.compression FAQ. 0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
--*/ 0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
UInt32 BZ2_crc32Table[256] = { 0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
/*-- Ugly, innit? --*/ 0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L, 0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L, 0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L, 0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL, 0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L, 0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L, 0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L, 0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL, 0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L, 0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L, 0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L, 0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL, 0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L, 0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L, 0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L, 0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL, 0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL, 0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L, 0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L, 0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL, 0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL, 0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L, 0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L, 0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL, 0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL, };
0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL, /*-------------------------------------------------------------*/
0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL, /*--- end crctable.c ---*/
0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L, /*-------------------------------------------------------------*/
0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
};
/*-------------------------------------------------------------*/
/*--- end crctable.c ---*/
/*-------------------------------------------------------------*/

433
bzip2/huffman.c
View file

@ -1,228 +1,205 @@
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- Huffman coding low-level stuff ---*/ /*--- Huffman coding low-level stuff ---*/
/*--- huffman.c ---*/ /*--- huffman.c ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*-- /* ------------------------------------------------------------------
This file is a part of bzip2 and/or libbzip2, a program and This file is part of bzip2/libbzip2, a program and library for
library for lossless, block-sorting data compression. lossless, block-sorting data compression.
Copyright (C) 1996-2002 Julian R Seward. All rights reserved. bzip2/libbzip2 version 1.0.5 of 10 December 2007
Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions Please read the WARNING, DISCLAIMER and PATENTS sections in the
are met: README file.
1. Redistributions of source code must retain the above copyright This program is released under the terms of the license contained
notice, this list of conditions and the following disclaimer. in the file LICENSE.
------------------------------------------------------------------ */
2. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product #include "bzlib_private.h"
documentation would be appreciated but is not required.
/*---------------------------------------------------*/
3. Altered source versions must be plainly marked as such, and must #define WEIGHTOF(zz0) ((zz0) & 0xffffff00)
not be misrepresented as being the original software. #define DEPTHOF(zz1) ((zz1) & 0x000000ff)
#define MYMAX(zz2,zz3) ((zz2) > (zz3) ? (zz2) : (zz3))
4. The name of the author may not be used to endorse or promote
products derived from this software without specific prior written #define ADDWEIGHTS(zw1,zw2) \
permission. (WEIGHTOF(zw1)+WEIGHTOF(zw2)) | \
(1 + MYMAX(DEPTHOF(zw1),DEPTHOF(zw2)))
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED #define UPHEAP(z) \
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE { \
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY Int32 zz, tmp; \
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL zz = z; tmp = heap[zz]; \
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE while (weight[tmp] < weight[heap[zz >> 1]]) { \
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS heap[zz] = heap[zz >> 1]; \
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, zz >>= 1; \
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING } \
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS heap[zz] = tmp; \
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. }
Julian Seward, Cambridge, UK. #define DOWNHEAP(z) \
jseward@acm.org { \
bzip2/libbzip2 version 1.0 of 21 March 2000 Int32 zz, yy, tmp; \
zz = z; tmp = heap[zz]; \
This program is based on (at least) the work of: while (True) { \
Mike Burrows yy = zz << 1; \
David Wheeler if (yy > nHeap) break; \
Peter Fenwick if (yy < nHeap && \
Alistair Moffat weight[heap[yy+1]] < weight[heap[yy]]) \
Radford Neal yy++; \
Ian H. Witten if (weight[tmp] < weight[heap[yy]]) break; \
Robert Sedgewick heap[zz] = heap[yy]; \
Jon L. Bentley zz = yy; \
} \
For more information on these sources, see the manual. heap[zz] = tmp; \
--*/ }
#include "bzlib_private.h" /*---------------------------------------------------*/
void BZ2_hbMakeCodeLengths ( UChar *len,
/*---------------------------------------------------*/ Int32 *freq,
#define WEIGHTOF(zz0) ((zz0) & 0xffffff00) Int32 alphaSize,
#define DEPTHOF(zz1) ((zz1) & 0x000000ff) Int32 maxLen )
#define MYMAX(zz2,zz3) ((zz2) > (zz3) ? (zz2) : (zz3)) {
/*--
#define ADDWEIGHTS(zw1,zw2) \ Nodes and heap entries run from 1. Entry 0
(WEIGHTOF(zw1)+WEIGHTOF(zw2)) | \ for both the heap and nodes is a sentinel.
(1 + MYMAX(DEPTHOF(zw1),DEPTHOF(zw2))) --*/
Int32 nNodes, nHeap, n1, n2, i, j, k;
#define UPHEAP(z) \ Bool tooLong;
{ \
Int32 zz, tmp; \ Int32 heap [ BZ_MAX_ALPHA_SIZE + 2 ];
zz = z; tmp = heap[zz]; \ Int32 weight [ BZ_MAX_ALPHA_SIZE * 2 ];
while (weight[tmp] < weight[heap[zz >> 1]]) { \ Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ];
heap[zz] = heap[zz >> 1]; \
zz >>= 1; \ for (i = 0; i < alphaSize; i++)
} \ weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
heap[zz] = tmp; \
} while (True) {
#define DOWNHEAP(z) \ nNodes = alphaSize;
{ \ nHeap = 0;
Int32 zz, yy, tmp; \
zz = z; tmp = heap[zz]; \ heap[0] = 0;
while (True) { \ weight[0] = 0;
yy = zz << 1; \ parent[0] = -2;
if (yy > nHeap) break; \
if (yy < nHeap && \ for (i = 1; i <= alphaSize; i++) {
weight[heap[yy+1]] < weight[heap[yy]]) \ parent[i] = -1;
yy++; \ nHeap++;
if (weight[tmp] < weight[heap[yy]]) break; \ heap[nHeap] = i;
heap[zz] = heap[yy]; \ UPHEAP(nHeap);
zz = yy; \ }
} \
heap[zz] = tmp; \ AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 );
}
while (nHeap > 1) {
n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
/*---------------------------------------------------*/ n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
void BZ2_hbMakeCodeLengths ( UChar *len, nNodes++;
Int32 *freq, parent[n1] = parent[n2] = nNodes;
Int32 alphaSize, weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]);
Int32 maxLen ) parent[nNodes] = -1;
{ nHeap++;
/*-- heap[nHeap] = nNodes;
Nodes and heap entries run from 1. Entry 0 UPHEAP(nHeap);
for both the heap and nodes is a sentinel. }
--*/
Int32 nNodes, nHeap, n1, n2, i, j, k; AssertH( nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002 );
Bool tooLong;
tooLong = False;
Int32 heap [ BZ_MAX_ALPHA_SIZE + 2 ]; for (i = 1; i <= alphaSize; i++) {
Int32 weight [ BZ_MAX_ALPHA_SIZE * 2 ]; j = 0;
Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ]; k = i;
while (parent[k] >= 0) { k = parent[k]; j++; }
for (i = 0; i < alphaSize; i++) len[i-1] = j;
weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8; if (j > maxLen) tooLong = True;
}
while (True) {
if (! tooLong) break;
nNodes = alphaSize;
nHeap = 0; /* 17 Oct 04: keep-going condition for the following loop used
to be 'i < alphaSize', which missed the last element,
heap[0] = 0; theoretically leading to the possibility of the compressor
weight[0] = 0; looping. However, this count-scaling step is only needed if
parent[0] = -2; one of the generated Huffman code words is longer than
maxLen, which up to and including version 1.0.2 was 20 bits,
for (i = 1; i <= alphaSize; i++) { which is extremely unlikely. In version 1.0.3 maxLen was
parent[i] = -1; changed to 17 bits, which has minimal effect on compression
nHeap++; ratio, but does mean this scaling step is used from time to
heap[nHeap] = i; time, enough to verify that it works.
UPHEAP(nHeap);
} This means that bzip2-1.0.3 and later will only produce
Huffman codes with a maximum length of 17 bits. However, in
AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 ); order to preserve backwards compatibility with bitstreams
produced by versions pre-1.0.3, the decompressor must still
while (nHeap > 1) { handle lengths of up to 20. */
n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1); for (i = 1; i <= alphaSize; i++) {
nNodes++; j = weight[i] >> 8;
parent[n1] = parent[n2] = nNodes; j = 1 + (j / 2);
weight[nNodes] = ADDWEIGHTS(weight[n1], weight[n2]); weight[i] = j << 8;
parent[nNodes] = -1; }
nHeap++; }
heap[nHeap] = nNodes; }
UPHEAP(nHeap);
}
/*---------------------------------------------------*/
AssertH( nNodes < (BZ_MAX_ALPHA_SIZE * 2), 2002 ); void BZ2_hbAssignCodes ( Int32 *code,
UChar *length,
tooLong = False; Int32 minLen,
for (i = 1; i <= alphaSize; i++) { Int32 maxLen,
j = 0; Int32 alphaSize )
k = i; {
while (parent[k] >= 0) { k = parent[k]; j++; } Int32 n, vec, i;
len[i-1] = j;
if (j > maxLen) tooLong = True; vec = 0;
} for (n = minLen; n <= maxLen; n++) {
for (i = 0; i < alphaSize; i++)
if (! tooLong) break; if (length[i] == n) { code[i] = vec; vec++; };
vec <<= 1;
for (i = 1; i < alphaSize; i++) { }
j = weight[i] >> 8; }
j = 1 + (j / 2);
weight[i] = j << 8;
} /*---------------------------------------------------*/
} void BZ2_hbCreateDecodeTables ( Int32 *limit,
} Int32 *base,
Int32 *perm,
UChar *length,
/*---------------------------------------------------*/ Int32 minLen,
void BZ2_hbAssignCodes ( Int32 *code, Int32 maxLen,
UChar *length, Int32 alphaSize )
Int32 minLen, {
Int32 maxLen, Int32 pp, i, j, vec;
Int32 alphaSize )
{ pp = 0;
Int32 n, vec, i; for (i = minLen; i <= maxLen; i++)
for (j = 0; j < alphaSize; j++)
vec = 0; if (length[j] == i) { perm[pp] = j; pp++; };
for (n = minLen; n <= maxLen; n++) {
for (i = 0; i < alphaSize; i++) for (i = 0; i < BZ_MAX_CODE_LEN; i++) base[i] = 0;
if (length[i] == n) { code[i] = vec; vec++; }; for (i = 0; i < alphaSize; i++) base[length[i]+1]++;
vec <<= 1;
} for (i = 1; i < BZ_MAX_CODE_LEN; i++) base[i] += base[i-1];
}
for (i = 0; i < BZ_MAX_CODE_LEN; i++) limit[i] = 0;
vec = 0;
/*---------------------------------------------------*/
void BZ2_hbCreateDecodeTables ( Int32 *limit, for (i = minLen; i <= maxLen; i++) {
Int32 *base, vec += (base[i+1] - base[i]);
Int32 *perm, limit[i] = vec-1;
UChar *length, vec <<= 1;
Int32 minLen, }
Int32 maxLen, for (i = minLen + 1; i <= maxLen; i++)
Int32 alphaSize ) base[i] = ((limit[i-1] + 1) << 1) - base[i];
{ }
Int32 pp, i, j, vec;
pp = 0; /*-------------------------------------------------------------*/
for (i = minLen; i <= maxLen; i++) /*--- end huffman.c ---*/
for (j = 0; j < alphaSize; j++) /*-------------------------------------------------------------*/
if (length[j] == i) { perm[pp] = j; pp++; };
for (i = 0; i < BZ_MAX_CODE_LEN; i++) base[i] = 0;
for (i = 0; i < alphaSize; i++) base[length[i]+1]++;
for (i = 1; i < BZ_MAX_CODE_LEN; i++) base[i] += base[i-1];
for (i = 0; i < BZ_MAX_CODE_LEN; i++) limit[i] = 0;
vec = 0;
for (i = minLen; i <= maxLen; i++) {
vec += (base[i+1] - base[i]);
limit[i] = vec-1;
vec <<= 1;
}
for (i = minLen + 1; i <= maxLen; i++)
base[i] = ((limit[i-1] + 1) << 1) - base[i];
}
/*-------------------------------------------------------------*/
/*--- end huffman.c ---*/
/*-------------------------------------------------------------*/

208
bzip2/randtable.c
View file

@ -1,124 +1,84 @@
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- Table for randomising repetitive blocks ---*/ /*--- Table for randomising repetitive blocks ---*/
/*--- randtable.c ---*/ /*--- randtable.c ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*-- /* ------------------------------------------------------------------
This file is a part of bzip2 and/or libbzip2, a program and This file is part of bzip2/libbzip2, a program and library for
library for lossless, block-sorting data compression. lossless, block-sorting data compression.
Copyright (C) 1996-2002 Julian R Seward. All rights reserved. bzip2/libbzip2 version 1.0.5 of 10 December 2007
Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org>
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions Please read the WARNING, DISCLAIMER and PATENTS sections in the
are met: README file.
1. Redistributions of source code must retain the above copyright This program is released under the terms of the license contained
notice, this list of conditions and the following disclaimer. in the file LICENSE.
------------------------------------------------------------------ */
2. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product #include "bzlib_private.h"
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must /*---------------------------------------------*/
not be misrepresented as being the original software. Int32 BZ2_rNums[512] = {
619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
4. The name of the author may not be used to endorse or promote 985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
products derived from this software without specific prior written 733, 859, 335, 708, 621, 574, 73, 654, 730, 472,
permission. 419, 436, 278, 496, 867, 210, 399, 680, 480, 51,
878, 465, 811, 169, 869, 675, 611, 697, 867, 561,
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 862, 687, 507, 283, 482, 129, 807, 591, 733, 623,
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 150, 238, 59, 379, 684, 877, 625, 169, 643, 105,
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 170, 607, 520, 932, 727, 476, 693, 425, 174, 647,
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 73, 122, 335, 530, 442, 853, 695, 249, 445, 515,
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 909, 545, 703, 919, 874, 474, 882, 500, 594, 612,
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 641, 801, 220, 162, 819, 984, 589, 513, 495, 799,
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 161, 604, 958, 533, 221, 400, 386, 867, 600, 782,
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 382, 596, 414, 171, 516, 375, 682, 485, 911, 276,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 469, 68, 770, 919, 190, 373, 294, 822, 808, 206,
184, 943, 795, 384, 383, 461, 404, 758, 839, 887,
Julian Seward, Cambridge, UK. 715, 67, 618, 276, 204, 918, 873, 777, 604, 560,
jseward@acm.org 951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
bzip2/libbzip2 version 1.0 of 21 March 2000 652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
This program is based on (at least) the work of: 609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
Mike Burrows 653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
David Wheeler 411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
Peter Fenwick 170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
Alistair Moffat 857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
Radford Neal 669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
Ian H. Witten 944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
Robert Sedgewick 344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
Jon L. Bentley 897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
For more information on these sources, see the manual. 686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
--*/ 946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
#include "bzlib_private.h" 707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
/*---------------------------------------------*/ 343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
Int32 BZ2_rNums[512] = { 140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
619, 720, 127, 481, 931, 816, 813, 233, 566, 247, 170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
985, 724, 205, 454, 863, 491, 741, 242, 949, 214, 369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
733, 859, 335, 708, 621, 574, 73, 654, 730, 472, 804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
419, 436, 278, 496, 867, 210, 399, 680, 480, 51, 896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
878, 465, 811, 169, 869, 675, 611, 697, 867, 561, 661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
862, 687, 507, 283, 482, 129, 807, 591, 733, 623, 768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
150, 238, 59, 379, 684, 877, 625, 169, 643, 105, 61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
170, 607, 520, 932, 727, 476, 693, 425, 174, 647, 372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
73, 122, 335, 530, 442, 853, 695, 249, 445, 515, 780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
909, 545, 703, 919, 874, 474, 882, 500, 594, 612, 920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
641, 801, 220, 162, 819, 984, 589, 513, 495, 799, 645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
161, 604, 958, 533, 221, 400, 386, 867, 600, 782, 936, 638
382, 596, 414, 171, 516, 375, 682, 485, 911, 276, };
98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
469, 68, 770, 919, 190, 373, 294, 822, 808, 206, /*-------------------------------------------------------------*/
184, 943, 795, 384, 383, 461, 404, 758, 839, 887, /*--- end randtable.c ---*/
715, 67, 618, 276, 204, 918, 873, 777, 604, 560, /*-------------------------------------------------------------*/
951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
936, 638
};
/*-------------------------------------------------------------*/
/*--- end randtable.c ---*/
/*-------------------------------------------------------------*/

4
main.cpp
View file

@ -37,6 +37,7 @@
#ifdef _WIN32 #ifdef _WIN32
# pragma warning( disable : 4786 ) // stl warning ¾ø¾Ö±â # pragma warning( disable : 4786 ) // stl warning ¾ø¾Ö±â
# pragma warning( disable : 4996 ) // crt secure warning
#endif #endif
#include <stdio.h> #include <stdio.h>
@ -70,7 +71,8 @@ void Copyright()
// printf("unalz v0.61 (2007/02/10) \n"); // printf("unalz v0.61 (2007/02/10) \n");
// printf("unalz v0.62 (2008/04/04) \n"); // printf("unalz v0.62 (2008/04/04) \n");
// printf("unalz v0.63 (2009/01/09) \n"); // printf("unalz v0.63 (2009/01/09) \n");
printf("unalz v0.64 (2009/01/20) \n"); // printf("unalz v0.64 (2009/01/20) \n");
printf("unalz v0.65 (2009/04/01) \n");
printf("Copyright(C) 2004-2009 by kippler@gmail.com (http://www.kipple.pe.kr) \n"); printf("Copyright(C) 2004-2009 by kippler@gmail.com (http://www.kipple.pe.kr) \n");
} }

2
unalz.dsp
View file

@ -23,6 +23,8 @@ CFG=unalz - Win32 Debug
# Begin Project # Begin Project
# PROP AllowPerConfigDependencies 0 # PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""$/Home/unalz", VXBAAAAA"
# PROP Scc_LocalPath "."
CPP=cl.exe CPP=cl.exe
RSC=rc.exe RSC=rc.exe

33
unalz.dsw Executable file
View file

@ -0,0 +1,33 @@
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
###############################################################################
Project: "unalz"=.\unalz.dsp - Package Owner=<4>
Package=<5>
{{{
begin source code control
"$/Home/unalz", VXBAAAAA
.
end source code control
}}}
Package=<4>
{{{
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################