diff --git a/Addons/KOLZLibBzip.pas b/Addons/KOLZLibBzip.pas new file mode 100644 index 0000000..5d7aa33 --- /dev/null +++ b/Addons/KOLZLibBzip.pas @@ -0,0 +1,1960 @@ +//{$DEFINE USE_EXCEPTIONS} +{***************************************************************************** +* unit based on * +* ZLibEx.pas (zlib 1.2.1) * +* Edition 2003.12.18 * +* * +* copyright (c) 2002-2003 Roberto Della Pasqua (www.dellapasqua.com) * +* copyright (c) 2000-2002 base2 technologies (www.base2ti.com) * +* copyright (c) 1997 Borland International (www.borland.com) * +* * +* and * +* * +* BZip2 unit by Edison Mera (www.geocities.com/efmera/) * +* Version 1.02 * +* Edition 21-11-2002 * +* * +* Changes made by GMax: * +* * +* units joined. gzip support functions added. * +* compression/decompression streams classes excluded, * +* compression/decompression stream2stream functions added * +* * +* procedures converted to functions to add "no exceptions" functionality * +* return values actual ONLY in this case (no exceptions) * +* error occured while value<0 * +* * +* function names for Z(De)Compress changed to Z(De)CompressBuf * +* * +* (C) GMax 2004. email: gmax@loving.ru * +*****************************************************************************} + +unit KOLZLibBzip; + +interface + +uses + KOL{$IFDEF USE_EXCEPTIONS}, ERR{$ENDIF}; + +const + ZLIB_VERSION = '1.2.1'; + BZIP_VERSION = '1.0.2'; + +type + TAlloc = function(opaque: Pointer; Items, Size: Integer): Pointer; cdecl; + TFree = procedure(opaque, Block: Pointer); cdecl; + + TZCompressionLevel = (zcNone, zcFastest, zcDefault, zcMax); + TZCompressionStrategy = (zcsDefault, zcsFiltered, zcsHuffmanOnly); + {** TZStreamRec ***********************************************************} + + TZStreamRec = packed record + next_in: PChar; // next input byte + avail_in: Longint; // number of bytes available at next_in + total_in: Longint; // total nb of input bytes read so far + + next_out: PChar; // next output byte should be put here + avail_out: Longint; // remaining free space at next_out + total_out: Longint; // total nb of bytes output so far + + msg: PChar; // last error message, NULL if no error + state: Pointer; // not visible by applications + + zalloc: TAlloc; // used to allocate the internal state + zfree: TFree; // used to free the internal state + opaque: Pointer; // private data object passed to zalloc and zfree + + data_type: Integer; // best guess about the data type: ascii or binary + adler: Longint; // adler32 value of the uncompressed data + reserved: Longint; // reserved for future use + end; + + {** zlib public routines ****************************************************} + + {***************************************************************************** + * ZCompressBuf * + * * + * pre-conditions * + * inBuffer = pointer to uncompressed data * + * inSize = size of inBuffer (bytes) * + * outBuffer = pointer (unallocated) * + * level = compression level * + * * + * post-conditions * + * outBuffer = pointer to compressed data (allocated) * + * outSize = size of outBuffer (bytes) * + *****************************************************************************} + +function ZCompressBuf(const inBuffer: Pointer; inSize: Integer; + out outBuffer: Pointer; out outSize: Integer; + level: TZCompressionLevel = zcDefault): Integer; + +{***************************************************************************** +* ZDecompressBuf * +* * +* pre-conditions * +* inBuffer = pointer to compressed data * +* inSize = size of inBuffer (bytes) * +* outBuffer = pointer (unallocated) * +* outEstimate = estimated size of uncompressed data (bytes) * +* * +* post-conditions * +* outBuffer = pointer to decompressed data (allocated) * +* outSize = size of outBuffer (bytes) * +*****************************************************************************} + +function ZDecompressBuf(const inBuffer: Pointer; inSize: Integer; + out outBuffer: Pointer; out outSize: Integer; outEstimate: Integer = 0): Integer; + +{** string routines *********************************************************} + +function ZCompressStr(const s: string; level: TZCompressionLevel = zcDefault): string; + +function ZDecompressStr(const s: string): string; + +{** stream routines *********************************************************} + +function ZCompressStream(inStream, outStream: PStream; + level: TZCompressionLevel = zcDefault): Integer; + +function ZDecompressStream(inStream, outStream: PStream): Integer; + +{** utility routines ********************************************************} + +function adler32(adler: LongInt; const buf: PChar; len: Integer): LongInt; +function CRC32(CRC: Cardinal; const Data: PChar; cbData: Cardinal): Cardinal; +function compressBound(sourceLen: LongInt): LongInt; + +{****************************************************************************} + +procedure MoveI32(const Source; var Dest; Count: Integer); +procedure ZFastCompressString(var s: string; level: TZCompressionLevel); +procedure ZFastDecompressString(var s: string); +procedure ZSendToBrowser(var s: string); + +type + TgzipHeader = packed record + FileName: string; + Comment: string; + FileTime: TDateTime; + Extra: string; + end; + +function gZipCompressStream(inStream, outStream: PStream; var gzHdr: TgzipHeader; level: TZCompressionLevel = zcDefault; strategy: TZCompressionStrategy = zcsDefault): Integer; overload; +function gZipCompressStream(inStream, outStream: PStream; level: TZCompressionLevel = zcDefault; strategy: TZCompressionStrategy = zcsDefault): Integer; overload; +function gZipDecompressStreamHeader(inStream: PStream; var gzHdr: TgzipHeader): Integer; +function gZipDecompressStreamBody(inStream, outStream: PStream; const aCheckCRC: Boolean = True): Integer; +function gZipDecompressStream(inStream, outStream: PStream; var gzHdr: TgzipHeader): Integer; +function gZipDecompressString(const S: String; const useheaders: Boolean = True; const aCheckCRC: Boolean = True): String; + +{*******************************************************} +{ } +{ BZIP2 Data Compression Interface Unit } +{ } +{*******************************************************} +type + // Internal structure. + TBZStreamRec = packed record + next_in: PChar; // next input byte + avail_in: Integer; // number of bytes available at next_in + total_in_lo32: Integer; // total nb of input bytes read so far + total_in_hi32: Integer; + + next_out: PChar; // next output byte should be put here + avail_out: Integer; // remaining free space at next_out + total_out_lo32: Integer; // total nb of bytes output so far + total_out_hi32: Integer; + + state: Pointer; + + bzalloc: TAlloc; // used to allocate the internal state + bzfree: TFree; // used to free the internal state + opaque: Pointer; + end; + TBlockSize100k = 1..9; + { CompressBuf compresses data, buffer to buffer, in one call. + In: InBuf = ptr to compressed data + InBytes = number of bytes in InBuf + Out: OutBuf = ptr to newly allocated buffer containing decompressed data + OutBytes = number of bytes in OutBuf } +function BZCompressBuf(const InBuf: Pointer; InBytes: Integer; + out OutBuf: Pointer; out OutBytes: Integer): Integer; + +{ DecompressBuf decompresses data, buffer to buffer, in one call. + In: InBuf = ptr to compressed data + InBytes = number of bytes in InBuf + OutEstimate = zero, or est. size of the decompressed data + Out: OutBuf = ptr to newly allocated buffer containing decompressed data + OutBytes = number of bytes in OutBuf } +function BZDecompressBuf(const InBuf: Pointer; InBytes: Integer; + OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer): Integer; + +function BZCompressStream(inStream, outStream: PStream; BlockSize100k: TBlockSize100k = 5): Integer; +function BZDecompressStream(inStream, outStream: PStream): Integer; + + +{** deflate routines ********************************************************} + +function deflateInit_(var strm: TZStreamRec; level: Integer; version: PChar; + recsize: Integer): Integer; external; + +function DeflateInit2_(var strm: TZStreamRec; level: integer; method: integer; windowBits: integer; + memLevel: integer; strategy: integer; version: PChar; recsize: integer): integer; external; + +function deflate(var strm: TZStreamRec; flush: Integer): Integer; + external; + +function deflateEnd(var strm: TZStreamRec): Integer; external; + +{** inflate routines ********************************************************} + +function inflateInit_(var strm: TZStreamRec; version: PChar; + recsize: Integer): Integer; external; + +function inflateInit2_(var strm: TZStreamRec; windowBits: integer; + version: PChar; recsize: integer): integer; external; + +function inflate(var strm: TZStreamRec; flush: Integer): Integer; + external; + +function inflateEnd(var strm: TZStreamRec): Integer; external; + +function inflateReset(var strm: TZStreamRec): Integer; external; + +const + gzBufferSize = 16384; + gz_magic : array[0..1] of Byte = ($1F, $8B); + { gzip flag byte } + + GZF_ASCII_FLAG = $01; { bit 0 set: file probably ascii text } + GZF_HEAD_CRC = $02; { bit 1 set: header CRC present } + GZF_EXTRA_FIELD = $04; { bit 2 set: extra field present } + GZF_ORIG_NAME = $08; { bit 3 set: original file name present } + GZF_COMMENT = $10; { bit 4 set: file comment present } + GZF_RESERVED = $E0; { bits 5..7: reserved } + Z_EOF = -1; + +const + { ** Maximum value for windowBits in deflateInit2 and inflateInit2 } + MAX_WBITS = 15; + { ** Maximum value for memLevel in deflateInit2 } +const + MAX_MEM_LEVEL = 9; + DEF_MEM_LEVEL = 8; + + {** link zlib 1.2.1 *********************************************************} + {** bcc32 flags: -c -6 -O2 -Ve -X- -pr -a8 -b -d -k- -vi -tWM -r -RT- } + +{$L zlib\adler32.obj} +{$L zlib\compress.obj} + {.$L zlib\crc32.obj} +{$L zlib\deflate.obj} +{$L zlib\infback.obj} +{$L zlib\inffast.obj} +{$L zlib\inflate.obj} +{$L zlib\inftrees.obj} +{$L zlib\trees.obj} +{$L zlib\uncompr.obj} + + {***************************************************************************** + * note: do not reorder the above -- doing so will result in external * + * functions being undefined * + *****************************************************************************} + +const + {** flush constants *******************************************************} + + Z_NO_FLUSH = 0; + Z_PARTIAL_FLUSH = 1; + Z_SYNC_FLUSH = 2; + Z_FULL_FLUSH = 3; + Z_FINISH = 4; + + {** return codes **********************************************************} + + Z_OK = 0; + Z_STREAM_END = 1; + Z_NEED_DICT = 2; + Z_ERRNO = (-1); + Z_STREAM_ERROR = (-2); + Z_DATA_ERROR = (-3); + Z_MEM_ERROR = (-4); + Z_BUF_ERROR = (-5); + Z_VERSION_ERROR = (-6); + Z_WRITE_ERROR = (-10); + Z_CRC_ERROR = (-11); + Z_SIZE_ERROR = (-12); + + {** compression levels ****************************************************} + + Z_NO_COMPRESSION = 0; + Z_BEST_SPEED = 1; + Z_BEST_COMPRESSION = 9; + Z_DEFAULT_COMPRESSION = (-1); + + {** compression strategies ************************************************} + + Z_FILTERED = 1; + Z_HUFFMAN_ONLY = 2; + Z_DEFAULT_STRATEGY = 0; + + {** data types ************************************************************} + + Z_BINARY = 0; + Z_ASCII = 1; + Z_UNKNOWN = 2; + + {** compression methods ***************************************************} + + Z_DEFLATED = 8; + + Z_NULL = nil; { for initializing zalloc, zfree, opaque } + + {** return code messages **************************************************} + + _z_errmsg : array[0..14] of PChar = ( + 'need dictionary', // Z_NEED_DICT (2) + 'stream end', // Z_STREAM_END (1) + '', // Z_OK (0) + 'file error', // Z_ERRNO (-1) + 'stream error', // Z_STREAM_ERROR (-2) + 'data error', // Z_DATA_ERROR (-3) + 'insufficient memory', // Z_MEM_ERROR (-4) + 'buffer error', // Z_BUF_ERROR (-5) + 'incompatible version', // Z_VERSION_ERROR (-6) + '', '', '', + 'stream write error', // Z_WRITE_ERROR = (-10); + 'crc error', // Z_CRC_ERROR = (-11); + 'size mismarch' // Z_SIZE_ERROR = (-12); + ); + + ZLevels : array[TZCompressionLevel] of Shortint = ( + Z_NO_COMPRESSION, + Z_BEST_SPEED, + Z_DEFAULT_COMPRESSION, + Z_BEST_COMPRESSION + ); + ZStrategy : array[TZCompressionStrategy] of Shortint = ( + Z_DEFAULT_STRATEGY, + Z_FILTERED, + Z_HUFFMAN_ONLY + ); + + {************** BZip constants **********************************************} +{$L bz2\blocks~1.obj} //blocksort +{$L bz2\huffman.obj} +{$L bz2\compress.obj} +{$L bz2\decomp~1.obj} //decompress +{$L bz2\bzlib.obj} + { $L bz2\crctable.obj} + { $L bz2\randtable.obj} + +procedure _BZ2_hbMakeCodeLengths; external; +procedure _BZ2_blockSort; external; +procedure _BZ2_hbCreateDecodeTables; external; +procedure _BZ2_hbAssignCodes; external; +procedure _BZ2_compressBlock; external; +procedure _BZ2_decompress; external; + +const + bzBufferSize = 32768; + + BZ_RUN = 0; + BZ_FLUSH = 1; + BZ_FINISH = 2; + BZ_OK = 0; + BZ_RUN_OK = 1; + BZ_FLUSH_OK = 2; + BZ_FINISH_OK = 3; + BZ_STREAM_END = 4; + BZ_SEQUENCE_ERROR = (-1); + BZ_PARAM_ERROR = (-2); + BZ_MEM_ERROR = (-3); + BZ_DATA_ERROR = (-4); + BZ_DATA_ERROR_MAGIC = (-5); + BZ_IO_ERROR = (-6); + BZ_UNEXPECTED_EOF = (-7); + BZ_OUTBUFF_FULL = (-8); + + BZ_Error_Msg : array[1..8] of PChar = ( + 'BZ_SEQUENCE_ERROR', + 'BZ_PARAM_ERROR', + 'BZ_MEM_ERROR', + 'BZ_DATA_ERROR', + 'BZ_DATA_ERROR_MAGIC', + 'BZ_IO_ERROR', + 'BZ_UNEXPECTED_EOF', + 'BZ_OUTBUFF_FULL' + ); + + BZ_BLOCK_SIZE_100K = 9; + + _BZ2_rNums : array[0..511] of Longint = ( + 619, 720, 127, 481, 931, 816, 813, 233, 566, 247, + 985, 724, 205, 454, 863, 491, 741, 242, 949, 214, + 733, 859, 335, 708, 621, 574, 73, 654, 730, 472, + 419, 436, 278, 496, 867, 210, 399, 680, 480, 51, + 878, 465, 811, 169, 869, 675, 611, 697, 867, 561, + 862, 687, 507, 283, 482, 129, 807, 591, 733, 623, + 150, 238, 59, 379, 684, 877, 625, 169, 643, 105, + 170, 607, 520, 932, 727, 476, 693, 425, 174, 647, + 73, 122, 335, 530, 442, 853, 695, 249, 445, 515, + 909, 545, 703, 919, 874, 474, 882, 500, 594, 612, + 641, 801, 220, 162, 819, 984, 589, 513, 495, 799, + 161, 604, 958, 533, 221, 400, 386, 867, 600, 782, + 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, + 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 + ); + + _BZ2_crc32Table : array[0..255] of Longint = ( + $00000000, $04C11DB7, $09823B6E, $0D4326D9, + $130476DC, $17C56B6B, $1A864DB2, $1E475005, + $2608EDB8, $22C9F00F, $2F8AD6D6, $2B4BCB61, + $350C9B64, $31CD86D3, $3C8EA00A, $384FBDBD, + $4C11DB70, $48D0C6C7, $4593E01E, $4152FDA9, + $5F15ADAC, $5BD4B01B, $569796C2, $52568B75, + $6A1936C8, $6ED82B7F, $639B0DA6, $675A1011, + $791D4014, $7DDC5DA3, $709F7B7A, $745E66CD, + -$67DC4920, -$631D54A9, -$6E5E7272, -$6A9F6FC7, + -$74D83FC4, -$70192275, -$7D5A04AE, -$799B191B, + -$41D4A4A8, -$4515B911, -$48569FCA, -$4C97827F, + -$52D0D27C, -$5611CFCD, -$5B52E916, -$5F93F4A3, + -$2BCD9270, -$2F0C8FD9, -$224FA902, -$268EB4B7, + -$38C9E4B4, -$3C08F905, -$314BDFDE, -$358AC26B, + -$0DC57FD8, -$09046261, -$044744BA, -$0086590F, + -$1EC1090C, -$1A0014BD, -$17433266, -$13822FD3, + $34867077, $30476DC0, $3D044B19, $39C556AE, + $278206AB, $23431B1C, $2E003DC5, $2AC12072, + $128E9DCF, $164F8078, $1B0CA6A1, $1FCDBB16, + $018AEB13, $054BF6A4, $0808D07D, $0CC9CDCA, + $7897AB07, $7C56B6B0, $71159069, $75D48DDE, + $6B93DDDB, $6F52C06C, $6211E6B5, $66D0FB02, + $5E9F46BF, $5A5E5B08, $571D7DD1, $53DC6066, + $4D9B3063, $495A2DD4, $44190B0D, $40D816BA, + -$535A3969, -$579B24E0, -$5AD80207, -$5E191FB2, + -$405E4FB5, -$449F5204, -$49DC74DB, -$4D1D696E, + -$7552D4D1, -$7193C968, -$7CD0EFBF, -$7811F20A, + -$6656A20D, -$6297BFBC, -$6FD49963, -$6B1584D6, + -$1F4BE219, -$1B8AFFB0, -$16C9D977, -$1208C4C2, + -$0C4F94C5, -$088E8974, -$05CDAFAB, -$010CB21E, + -$39430FA1, -$3D821218, -$30C134CF, -$3400297A, + -$2A47797D, -$2E8664CC, -$23C54213, -$27045FA6, + $690CE0EE, $6DCDFD59, $608EDB80, $644FC637, + $7A089632, $7EC98B85, $738AAD5C, $774BB0EB, + $4F040D56, $4BC510E1, $46863638, $42472B8F, + $5C007B8A, $58C1663D, $558240E4, $51435D53, + $251D3B9E, $21DC2629, $2C9F00F0, $285E1D47, + $36194D42, $32D850F5, $3F9B762C, $3B5A6B9B, + $0315D626, $07D4CB91, $0A97ED48, $0E56F0FF, + $1011A0FA, $14D0BD4D, $19939B94, $1D528623, + -$0ED0A9F2, -$0A11B447, -$075292A0, -$03938F29, + -$1DD4DF2E, -$1915C29B, -$1456E444, -$1097F9F5, + -$28D8444A, -$2C1959FF, -$215A7F28, -$259B6291, + -$3BDC3296, -$3F1D2F23, -$325E09FC, -$369F144D, + -$42C17282, -$46006F37, -$4B4349F0, -$4F825459, + -$51C5045E, -$550419EB, -$58473F34, -$5C862285, + -$64C99F3A, -$6008828F, -$6D4BA458, -$698AB9E1, + -$77CDE9E6, -$730CF453, -$7E4FD28C, -$7A8ECF3D, + $5D8A9099, $594B8D2E, $5408ABF7, $50C9B640, + $4E8EE645, $4A4FFBF2, $470CDD2B, $43CDC09C, + $7B827D21, $7F436096, $7200464F, $76C15BF8, + $68860BFD, $6C47164A, $61043093, $65C52D24, + $119B4BE9, $155A565E, $18197087, $1CD86D30, + $029F3D35, $065E2082, $0B1D065B, $0FDC1BEC, + $3793A651, $3352BBE6, $3E119D3F, $3AD08088, + $2497D08D, $2056CD3A, $2D15EBE3, $29D4F654, + -$3A56D987, -$3E97C432, -$33D4E2E9, -$3715FF60, + -$2952AF5B, -$2D93B2EE, -$20D09435, -$24118984, + -$1C5E343F, -$189F298A, -$15DC0F51, -$111D12E8, + -$0F5A42E3, -$0B9B5F56, -$06D8798D, -$0219643C, + -$764702F7, -$72861F42, -$7FC53999, -$7B042430, + -$6543742B, -$6182699E, -$6CC14F45, -$680052F4, + -$504FEF4F, -$548EF2FA, -$59CDD421, -$5D0CC998, + -$434B9993, -$478A8426, -$4AC9A2FD, -$4E08BF4C + ); + +// deflate compresses data + +function BZ2_bzCompressInit(var strm: TBZStreamRec; blockSize100k: Integer; + verbosity: Integer; workFactor: Integer): Integer; stdcall; external; + +function BZ2_bzCompress(var strm: TBZStreamRec; action: Integer): Integer; stdcall; external; + +function BZ2_bzCompressEnd(var strm: TBZStreamRec): Integer; stdcall; external; + +function BZ2_bzBuffToBuffCompress(dest: Pointer; var destLen: Integer; source: Pointer; + sourceLen, blockSize100k, verbosity, workFactor: Integer): Integer; stdcall; external; + +// inflate decompresses data + +function BZ2_bzDecompressInit(var strm: TBZStreamRec; verbosity: Integer; + small: Integer): Integer; stdcall; external; + +function BZ2_bzDecompress(var strm: TBZStreamRec): Integer; stdcall; external; + +function BZ2_bzDecompressEnd(var strm: TBZStreamRec): Integer; stdcall; external; + +function BZ2_bzBuffToBuffDecompress(dest: Pointer; var destLen: Integer; source: Pointer; + sourceLen, small, verbosity: Integer): Integer; stdcall; external; + +{** utility routines *******************************************************} + +function adler32; external; +function compressBound; external; + +// +function InflateInit(var stream: TZStreamRec): Integer; + +implementation + +procedure _bz_internal_error(errcode: Integer); cdecl; +begin +{$IFDEF USE_EXCEPTIONS} + //raise EBZip2Error.CreateFmt('Compression Error %d', [errcode]); + raise Exception.CreateFMT(e_Convert, 'Compression Error %d', [errcode]); + // I don't know, what make in {$ELSE} :( +{$ENDIF} +end; + +function _malloc(size: Integer): Pointer; cdecl; +begin + GetMem(Result, Size); +end; + +procedure _free(block: Pointer); cdecl; +begin + FreeMem(block); +end; + +function bzip2AllocMem(AppData: Pointer; Items, Size: Integer): Pointer; cdecl; +begin + GetMem(Result, Items * Size); +end; + +procedure bzip2FreeMem(AppData, Block: Pointer); cdecl; +begin + FreeMem(Block); +end; + +{*********************** Peter Morris not aligned move **********************} + +procedure MoveI32(const Source; var Dest; Count: Integer); register; +asm + cmp ECX,0 + Je @JustQuit + push ESI + push EDI + mov ESI, EAX + mov EDI, EDX + @Loop: + Mov AL, [ESI] + Inc ESI + mov [EDI], AL + Inc EDI + Dec ECX + Jnz @Loop + pop EDI + pop ESI + @JustQuit: +end; +{****************************************************************************} + +{** utility routines *******************************************************} + +//function crc32; external; +function CRC32(CRC: Cardinal; const Data: PChar; cbData: Cardinal): Cardinal; assembler; +asm + or edx, edx + je @@exi + jecxz @@exi + xor eax,0FFFFFFFFh + push ebx +@@upd: + movzx ebx, al + xor bl, [ edx ] + shr eax, 8 + and eax, 00FFFFFFh + xor eax, cs:[ebx*4 + offset @@c32tt ]//OFFSET @@C32TT ] + inc edx + loop @@upd + pop ebx + xor eax,0FFFFFFFFh +@@exi: + ret + +@@C32TT: + +DD 000000000h, 077073096h, 0ee0e612ch, 0990951bah +DD 0076dc419h, 0706af48fh, 0e963a535h, 09e6495a3h +DD 00edb8832h, 079dcb8a4h, 0e0d5e91eh, 097d2d988h +DD 009b64c2bh, 07eb17cbdh, 0e7b82d07h, 090bf1d91h +DD 01db71064h, 06ab020f2h, 0f3b97148h, 084be41deh +DD 01adad47dh, 06ddde4ebh, 0f4d4b551h, 083d385c7h +DD 0136c9856h, 0646ba8c0h, 0fd62f97ah, 08a65c9ech +DD 014015c4fh, 063066cd9h, 0fa0f3d63h, 08d080df5h +DD 03b6e20c8h, 04c69105eh, 0d56041e4h, 0a2677172h +DD 03c03e4d1h, 04b04d447h, 0d20d85fdh, 0a50ab56bh +DD 035b5a8fah, 042b2986ch, 0dbbbc9d6h, 0acbcf940h +DD 032d86ce3h, 045df5c75h, 0dcd60dcfh, 0abd13d59h +DD 026d930ach, 051de003ah, 0c8d75180h, 0bfd06116h +DD 021b4f4b5h, 056b3c423h, 0cfba9599h, 0b8bda50fh +DD 02802b89eh, 05f058808h, 0c60cd9b2h, 0b10be924h +DD 02f6f7c87h, 058684c11h, 0c1611dabh, 0b6662d3dh +DD 076dc4190h, 001db7106h, 098d220bch, 0efd5102ah +DD 071b18589h, 006b6b51fh, 09fbfe4a5h, 0e8b8d433h +DD 07807c9a2h, 00f00f934h, 09609a88eh, 0e10e9818h +DD 07f6a0dbbh, 0086d3d2dh, 091646c97h, 0e6635c01h +DD 06b6b51f4h, 01c6c6162h, 0856530d8h, 0f262004eh +DD 06c0695edh, 01b01a57bh, 08208f4c1h, 0f50fc457h +DD 065b0d9c6h, 012b7e950h, 08bbeb8eah, 0fcb9887ch +DD 062dd1ddfh, 015da2d49h, 08cd37cf3h, 0fbd44c65h +DD 04db26158h, 03ab551ceh, 0a3bc0074h, 0d4bb30e2h +DD 04adfa541h, 03dd895d7h, 0a4d1c46dh, 0d3d6f4fbh +DD 04369e96ah, 0346ed9fch, 0ad678846h, 0da60b8d0h +DD 044042d73h, 033031de5h, 0aa0a4c5fh, 0dd0d7cc9h +DD 05005713ch, 0270241aah, 0be0b1010h, 0c90c2086h +DD 05768b525h, 0206f85b3h, 0b966d409h, 0ce61e49fh +DD 05edef90eh, 029d9c998h, 0b0d09822h, 0c7d7a8b4h +DD 059b33d17h, 02eb40d81h, 0b7bd5c3bh, 0c0ba6cadh +DD 0edb88320h, 09abfb3b6h, 003b6e20ch, 074b1d29ah +DD 0ead54739h, 09dd277afh, 004db2615h, 073dc1683h +DD 0e3630b12h, 094643b84h, 00d6d6a3eh, 07a6a5aa8h +DD 0e40ecf0bh, 09309ff9dh, 00a00ae27h, 07d079eb1h +DD 0f00f9344h, 08708a3d2h, 01e01f268h, 06906c2feh +DD 0f762575dh, 0806567cbh, 0196c3671h, 06e6b06e7h +DD 0fed41b76h, 089d32be0h, 010da7a5ah, 067dd4acch +DD 0f9b9df6fh, 08ebeeff9h, 017b7be43h, 060b08ed5h +DD 0d6d6a3e8h, 0a1d1937eh, 038d8c2c4h, 04fdff252h +DD 0d1bb67f1h, 0a6bc5767h, 03fb506ddh, 048b2364bh +DD 0d80d2bdah, 0af0a1b4ch, 036034af6h, 041047a60h +DD 0df60efc3h, 0a867df55h, 0316e8eefh, 04669be79h +DD 0cb61b38ch, 0bc66831ah, 0256fd2a0h, 05268e236h +DD 0cc0c7795h, 0bb0b4703h, 0220216b9h, 05505262fh +DD 0c5ba3bbeh, 0b2bd0b28h, 02bb45a92h, 05cb36a04h +DD 0c2d7ffa7h, 0b5d0cf31h, 02cd99e8bh, 05bdeae1dh +DD 09b64c2b0h, 0ec63f226h, 0756aa39ch, 0026d930ah +DD 09c0906a9h, 0eb0e363fh, 072076785h, 005005713h +DD 095bf4a82h, 0e2b87a14h, 07bb12baeh, 00cb61b38h +DD 092d28e9bh, 0e5d5be0dh, 07cdcefb7h, 00bdbdf21h +DD 086d3d2d4h, 0f1d4e242h, 068ddb3f8h, 01fda836eh +DD 081be16cdh, 0f6b9265bh, 06fb077e1h, 018b74777h +DD 088085ae6h, 0ff0f6a70h, 066063bcah, 011010b5ch +DD 08f659effh, 0f862ae69h, 0616bffd3h, 0166ccf45h +DD 0a00ae278h, 0d70dd2eeh, 04e048354h, 03903b3c2h +DD 0a7672661h, 0d06016f7h, 04969474dh, 03e6e77dbh +DD 0aed16a4ah, 0d9d65adch, 040df0b66h, 037d83bf0h +DD 0a9bcae53h, 0debb9ec5h, 047b2cf7fh, 030b5ffe9h +DD 0bdbdf21ch, 0cabac28ah, 053b39330h, 024b4a3a6h +DD 0bad03605h, 0cdd70693h, 054de5729h, 023d967bfh +DD 0b3667a2eh, 0c4614ab8h, 05d681b02h, 02a6f2b94h +DD 0b40bbe37h, 0c30c8ea1h, 05a05df1bh, 02d02ef8dh + +end; + +{** zlib function implementations *******************************************} + +function zcalloc(opaque: Pointer; items, size: Integer): Pointer; +begin + GetMem(result, items * size); +end; + +procedure zcfree(opaque, block: Pointer); +begin + FreeMem(block); +end; + +{** c function implementations **********************************************} + +procedure _memset(p: Pointer; b: Byte; count: Integer); cdecl; +begin + FillChar(p^, count, b); +end; + +procedure _memcpy(dest, source: Pointer; count: Integer); cdecl; +begin + Move(source^, dest^, count); +end; + +{** custom zlib routines ****************************************************} + +function DeflateInit(var stream: TZStreamRec; level: Integer): Integer; +begin + result := DeflateInit_(stream, level, ZLIB_VERSION, SizeOf(TZStreamRec)); +end; + +function DeflateInit2(var stream: TZStreamRec; level, method, windowBits, memLevel, strategy: Integer): Integer; +begin + result := DeflateInit2_(stream, level, method, windowBits, memLevel, + strategy, ZLIB_VERSION, SizeOf(TZStreamRec)); +end; + +function InflateInit(var stream: TZStreamRec): Integer; +begin + result := InflateInit_(stream, ZLIB_VERSION, SizeOf(TZStreamRec)); +end; + +function InflateInit2(var stream: TZStreamRec; windowBits: Integer): Integer; +begin + result := InflateInit2_(stream, windowBits, ZLIB_VERSION, SizeOf(TZStreamRec)); +end; + +{****************************************************************************} +{$IFDEF USE_EXCEPTIONS} + +function ZCompressCheck(code: Integer): Integer; +begin + result := code; + + if code < 0 then begin + raise Exception.CreateFMT(e_Convert, 'Compression Error %d - %s', [code, _z_errmsg[2 - code]]); + end; +end; + +function ZDecompressCheck(code: Integer): Integer; +begin + Result := code; + + if code < 0 then begin + raise Exception.CreateFMT(e_Convert, 'Decompression Error %d - %s', [code, _z_errmsg[2 - code]]); + end; +end; +{$ENDIF} + +{****************************************************************************} +{****************************************************************************} +{****************************************************************************} +{**** implementation itself *************************************************} +{****************************************************************************} +{****************************************************************************} +{****************************************************************************} + +function ZCompressBuf(const inBuffer: Pointer; inSize: Integer; out outBuffer: Pointer; out outSize: Integer; level: TZCompressionLevel): Integer; +const + delta = 256; +var + zstream : TZStreamRec; +begin + FillChar(zstream, SizeOf(TZStreamRec), 0); + Result := Z_OK; + outSize := ((inSize + (inSize div 10) + 12) + 255) and not 255; + outBuffer := nil; + GetMem(outBuffer, outSize); + try + zstream.next_in := inBuffer; + zstream.avail_in := inSize; + zstream.next_out := outBuffer; + zstream.avail_out := outSize; +{$IFDEF USE_EXCEPTIONS} + ZCompressCheck(DeflateInit(zstream, ZLevels[level])); +{$ELSE} + Result := DeflateInit(zstream, ZLevels[level]); + if Result < 0 then Exit; +{$ENDIF} + try +{$IFDEF USE_EXCEPTIONS} + Result := ZCompressCheck(deflate(zstream, Z_FINISH)); +{$ELSE} + Result := deflate(zstream, Z_FINISH); + if Result < 0 then Exit; +{$ENDIF} + while Result <> Z_STREAM_END do begin + Inc(outSize, delta); + ReallocMem(outBuffer, outSize); + + zstream.next_out := PChar(Integer(outBuffer) + zstream.total_out); + zstream.avail_out := delta; +{$IFDEF USE_EXCEPTIONS} + Result := ZCompressCheck(deflate(zstream, Z_FINISH)); +{$ELSE} + Result := deflate(zstream, Z_FINISH); + if Result < 0 then Exit; +{$ENDIF} + end; // while + finally +{$IFDEF USE_EXCEPTIONS} + ZCompressCheck(deflateEnd(zstream)); +{$ELSE} + deflateEnd(zstream); +{$ENDIF} + end; + + ReallocMem(outBuffer, zstream.total_out); + outSize := zstream.total_out; +{$IFDEF USE_EXCEPTIONS} + except + FreeMem(outBuffer); + raise; +{$ELSE} + finally + if Result < 0 then FreeMem(outBuffer); +{$ENDIF} + end; +end; + +function ZCompressBuf2(const inBuffer: Pointer; inSize: Integer; out outBuffer: Pointer; out outSize: Integer): Integer; +const + delta = 256; +var + zstream : TZStreamRec; +begin + FillChar(zstream, SizeOf(TZStreamRec), 0); + + outSize := ((inSize + (inSize div 10) + 12) + 255) and not 255; + GetMem(outBuffer, outSize); + Result := Z_OK; + try + zstream.next_in := inBuffer; + zstream.avail_in := inSize; + zstream.next_out := outBuffer; + zstream.avail_out := outSize; +{$IFDEF USE_EXCEPTIONS} + ZCompressCheck(DeflateInit2(zstream, 1, 8, -15, 9, 0)); +{$ELSE} + Result := DeflateInit2(zstream, 1, 8, -15, 9, 0); + if Result < 0 then Exit; +{$ENDIF} + + try +{$IFDEF USE_EXCEPTIONS} + Result := ZCompressCheck(deflate(zstream, Z_FINISH)); +{$ELSE} + Result := deflate(zstream, Z_FINISH); + if Result < 0 then Exit; +{$ENDIF} + while Result <> Z_STREAM_END do begin + Inc(outSize, delta); + ReallocMem(outBuffer, outSize); + + zstream.next_out := PChar(Integer(outBuffer) + zstream.total_out); + zstream.avail_out := delta; +{$IFDEF USE_EXCEPTIONS} + Result := ZCompressCheck(deflate(zstream, Z_FINISH)); +{$ELSE} + Result := deflate(zstream, Z_FINISH); + if Result < 0 then Exit; +{$ENDIF} + end; // while + finally +{$IFDEF USE_EXCEPTIONS} + ZCompressCheck(deflateEnd(zstream)); +{$ELSE} + deflateEnd(zstream); +{$ENDIF} + end; + + ReallocMem(outBuffer, zstream.total_out); + outSize := zstream.total_out; +{$IFDEF USE_EXCEPTIONS} + except + FreeMem(outBuffer); + raise; +{$ELSE} + finally + if Result < 0 then FreeMem(outBuffer); +{$ENDIF} + end; +end; + +function ZDecompressBuf(const inBuffer: Pointer; inSize: Integer; out outBuffer: Pointer; out outSize: Integer; outEstimate: Integer): Integer; +var + zstream : TZStreamRec; + delta : Integer; +begin + FillChar(zstream, SizeOf(TZStreamRec), 0); + + delta := (inSize + 255) and not 255; + + if outEstimate = 0 then outSize := delta + else outSize := outEstimate; + Result := Z_OK; + GetMem(outBuffer, outSize); + try + zstream.next_in := inBuffer; + zstream.avail_in := inSize; + zstream.next_out := outBuffer; + zstream.avail_out := outSize; + +{$IFDEF USE_EXCEPTIONS} + ZDecompressCheck(InflateInit(zstream)); +{$ELSE} + Result := InflateInit(zstream); + if Result < 0 then Exit; +{$ENDIF} + + try +{$IFDEF USE_EXCEPTIONS} + Result := ZDecompressCheck(inflate(zstream, Z_NO_FLUSH)); +{$ELSE} + Result := inflate(zstream, Z_NO_FLUSH); + if Result < 0 then Exit; +{$ENDIF} + while (Result <> Z_STREAM_END) do begin + Inc(outSize, delta); + ReallocMem(outBuffer, outSize); + + zstream.next_out := PChar(Integer(outBuffer) + zstream.total_out); + zstream.avail_out := delta; +{$IFDEF USE_EXCEPTIONS} + Result := ZDecompressCheck(inflate(zstream, Z_NO_FLUSH)); +{$ELSE} + Result := inflate(zstream, Z_NO_FLUSH); + if Result < 0 then Exit; +{$ENDIF} + end; + finally +{$IFDEF USE_EXCEPTIONS} + ZDecompressCheck(inflateEnd(zstream)); +{$ELSE} + inflateEnd(zstream); +{$ENDIF} + end; + + ReallocMem(outBuffer, zstream.total_out); + outSize := zstream.total_out; + +{$IFDEF USE_EXCEPTIONS} + except + FreeMem(outBuffer); + raise; +{$ELSE} + finally + if Result < 0 then FreeMem(outBuffer); +{$ENDIF} + end; +end; + +{** string routines *********************************************************} + +function ZCompressStr(const s: string; level: TZCompressionLevel): string; +var + buffer : Pointer; + size : Integer; +begin + ZCompressBuf(PChar(s), Length(s), buffer, size, level); + SetLength(result, size); + Move(buffer^, pointer(result)^, size); + FreeMem(buffer); +end; + +procedure ZFastCompressString(var s: string; level: TZCompressionLevel); +var + outBuf : Pointer; + outBytes : Integer; +begin + ZCompressBuf(pointer(s), length(s), outBuf, outBytes, level); + SetLength(s, outBytes); + MoveI32(pointer(outBuf)^, pointer(s)^, outBytes); + FreeMem(outBuf); +end; + +procedure ZFastDecompressString(var s: string); +var + outBuf : Pointer; + outBytes : Integer; +begin + ZDecompressBuf(pointer(s), Length(s), outBuf, outBytes); + SetLength(s, outBytes); + MoveI32(pointer(outBuf)^, pointer(s)^, outBytes); + FreeMem(outBuf); +end; + +procedure ZSendToBrowser(var s: string); +var + outBuf : Pointer; + outBytes : Integer; +begin + ZCompressBuf2(pointer(s), length(s), outBuf, outBytes); + SetLength(s, outBytes); + Move(pointer(outBuf)^, pointer(s)^, outBytes); + FreeMem(outBuf); +end; + +function ZDecompressStr(const s: string): string; +var + buffer : Pointer; + size : Integer; +begin + ZDecompressBuf(PChar(s), Length(s), buffer, size); + SetLength(result, size); + Move(buffer^, pointer(result)^, size); + FreeMem(buffer); +end; + +{** stream routines *********************************************************} + +function ZCompressStream(inStream, outStream: PStream; level: TZCompressionLevel): Integer; +const + bufferSize = 32768; +var + zstream : TZStreamRec; + inBuffer : array[0..bufferSize - 1] of Char; + outBuffer : array[0..bufferSize - 1] of Char; + inSize : Integer; + outSize : Integer; +begin + FillChar(zstream, SizeOf(TZStreamRec), 0); +{$IFDEF USE_EXCEPTIONS} + Result := Z_OK; + ZCompressCheck(DeflateInit(zstream, ZLevels[level])); +{$ELSE} + Result := DeflateInit(zstream, ZLevels[level]); + if Result < 0 then Exit; +{$ENDIF} + try + inSize := inStream.Read(inBuffer, bufferSize); + + while inSize > 0 do begin + zstream.next_in := inBuffer; + zstream.avail_in := inSize; + + repeat + zstream.next_out := outBuffer; + zstream.avail_out := bufferSize; + +{$IFDEF USE_EXCEPTIONS} + ZCompressCheck(deflate(zstream, Z_NO_FLUSH)); +{$ELSE} + Result := deflate(zstream, Z_NO_FLUSH); + if Result < 0 then Exit; +{$ENDIF} + + // outSize := zstream.next_out - outBuffer; + outSize := bufferSize - zstream.avail_out; + + outStream.Write(outBuffer, outSize); + until (zstream.avail_in = 0) and (zstream.avail_out > 0); + + inSize := inStream.Read(inBuffer, bufferSize); + end; + + repeat + zstream.next_out := outBuffer; + zstream.avail_out := bufferSize; + +{$IFDEF USE_EXCEPTIONS} + Result := ZCompressCheck(deflate(zstream, Z_FINISH)); +{$ELSE} + Result := deflate(zstream, Z_FINISH); + if Result < 0 then Break; +{$ENDIF} + + // outSize := zstream.next_out - outBuffer; + outSize := bufferSize - zstream.avail_out; + + outStream.Write(outBuffer, outSize); + until (Result = Z_STREAM_END) and (zstream.avail_out > 0); + finally +{$IFDEF USE_EXCEPTIONS} + ZCompressCheck(deflateEnd(zstream)); +{$ELSE} + deflateEnd(zstream); +{$ENDIF} + end; +end; + +function ZDecompressStream(inStream, outStream: PStream): Integer; +const + bufferSize = 32768; +var + zstream : TZStreamRec; + inBuffer : array[0..bufferSize - 1] of Char; + outBuffer : array[0..bufferSize - 1] of Char; + inSize : Integer; + outSize : Integer; +begin + FillChar(zstream, SizeOf(TZStreamRec), 0); + +{$IFDEF USE_EXCEPTIONS} + Result := ZCompressCheck(InflateInit(zstream)); +{$ELSE} + Result := InflateInit(zstream); + if Result < 0 then Exit; +{$ENDIF} + try + inSize := inStream.Read(inBuffer, bufferSize); + + while inSize > 0 do begin + zstream.next_in := inBuffer; + zstream.avail_in := inSize; + + repeat + zstream.next_out := outBuffer; + zstream.avail_out := bufferSize; + +{$IFDEF USE_EXCEPTIONS} + ZCompressCheck(inflate(zstream, Z_NO_FLUSH)); +{$ELSE} + Result := inflate(zstream, Z_NO_FLUSH); + if Result < 0 then Exit; +{$ENDIF} + + // outSize := zstream.next_out - outBuffer; + outSize := bufferSize - zstream.avail_out; + + outStream.Write(outBuffer, outSize); + until (zstream.avail_in = 0) and (zstream.avail_out > 0); + + inSize := inStream.Read(inBuffer, bufferSize); + end; + + repeat + zstream.next_out := outBuffer; + zstream.avail_out := bufferSize; + +{$IFDEF USE_EXCEPTIONS} + Result := ZCompressCheck(inflate(zstream, Z_FINISH)); +{$ELSE} + Result := inflate(zstream, Z_FINISH); + if Result < 0 then Break; +{$ENDIF} + + // outSize := zstream.next_out - outBuffer; + outSize := bufferSize - zstream.avail_out; + + outStream.Write(outBuffer, outSize); + until (Result = Z_STREAM_END) and (zstream.avail_out > 0); + finally +{$IFDEF USE_EXCEPTIONS} + ZCompressCheck(inflateEnd(zstream)); +{$ELSE} + inflateEnd(zstream); +{$ENDIF} + end; +end; + +{** gzip Stream routines ******************************************************} +const + UnixDateDelta = 25569; + +function DateTimeToUnix(ConvDate: TDateTime): Longint; +begin + //example: DateTimeToUnix(now); + Result := Round((ConvDate - UnixDateDelta) * 86400); +end; + +function UnixToDateTime(USec: Longint): TDateTime; +begin + //Example: UnixToDateTime(1003187418); + Result := (Usec / 86400) + UnixDateDelta; +end; + +function gZipCompressStream(inStream, outStream: PStream; var gzHdr: TgzipHeader; level: TZCompressionLevel = zcDefault; strategy: TZCompressionStrategy = zcsDefault): Integer; +var + rSize, + wSize, + zResult : LongInt; + done : Boolean; + iBuffer, + oBuffer : PChar; //Array [0..gzBufferSize-1] of Char; + fCrc : Cardinal; + zStream : TZStreamRec; + stamp : Integer; + +begin + iBuffer := nil; + oBuffer := nil; +{$IFDEF USE_EXCEPTIONS} + Result := Z_MEM_ERROR; +{$ENDIF} + try + GetMem(iBuffer, gzBufferSize); + GetMem(oBuffer, gzBufferSize); + + fCrc := 0; + FillChar(zStream, SizeOf(zStream), 0); + +{$IFDEF USE_EXCEPTIONS} + ZCompressCheck(DeflateInit2(zStream, ZLevels[level], Z_DEFLATED, -MAX_WBITS, + DEF_MEM_LEVEL, ZStrategy[strategy])); +{$ELSE} + Result := DeflateInit2(zStream, ZLevels[level], Z_DEFLATED, -MAX_WBITS, + DEF_MEM_LEVEL, ZStrategy[strategy]); + if Result < 0 then Exit; +{$ENDIF} + { windowBits is passed < 0 to suppress zlib header } + oBuffer[0] := Char(gz_magic[0]); + oBuffer[1] := Char(gz_magic[1]); // gz Magic + oBuffer[2] := #08; // gz Compression method + oBuffer[3] := #0; + // set mtime + { + Inc(gzHdr.TimeStamp,gzTimeStampCorrection); + oBuffer[4]:=Lo(gzHdr.TimeStamp and $FFFF); oBuffer[5]:=Hi(gzHdr.TimeStamp and $FFFF); + oBuffer[6]:=Lo(gzHdr.TimeStamp shr 16); oBuffer[7]:=Hi(gzHdr.TimeStamp shr 16); + Dec(gzHdr.TimeStamp,gzTimeStampCorrection); + } + stamp := DateTimeToUnix(gzHdr.FileTime); + oBuffer[4] := Char(Lo(stamp and $FFFF)); + oBuffer[5] := Char(Hi(stamp and $FFFF)); + oBuffer[6] := Char(Lo(stamp shr 16)); + oBuffer[7] := Char(Hi(stamp shr 16)); + + // xfl, os code sets to 0 + oBuffer[8] := #0; + oBuffer[9] := #0; + + if gzHdr.FileName <> '' then begin + oBuffer[3] := Char(Byte(oBuffer[3]) or GZF_ORIG_NAME); + end; + if gzHdr.Comment <> '' then begin + oBuffer[3] := Char(Byte(oBuffer[3]) or GZF_COMMENT); + end; + if gzHdr.Extra <> '' then begin + oBuffer[3] := Char(Byte(oBuffer[3]) or GZF_EXTRA_FIELD); + end; + wSize := outStream.Write(oBuffer^, 10); +{$IFDEF USE_EXCEPTIONS} + if wSize <> 10 then ZCompressCheck(Z_WRITE_ERROR); +{$ELSE} + if wSize <> 10 then begin + Result := Z_WRITE_ERROR; + Exit; + end; +{$ENDIF} + + // extra + if (byte(oBuffer[3]) and GZF_EXTRA_FIELD) <> 0 then begin + rSize := Length(gzHdr.Extra); + Move(gzHdr.Extra[1], iBuffer^, rSize); + iBuffer[rSize] := #0; + Inc(rSize); + wSize := outStream.Write(iBuffer^, rSize); +{$IFDEF USE_EXCEPTIONS} + if wSize <> rSize then ZCompressCheck(Z_WRITE_ERROR); +{$ELSE} + if wSize <> rSize then begin + Result := Z_WRITE_ERROR; + Exit; + end; +{$ENDIF} + end; + // filename + if (byte(oBuffer[3]) and GZF_ORIG_NAME) <> 0 then begin + rSize := Length(gzHdr.FileName); + Move(gzHdr.FileName[1], iBuffer^, rSize); + iBuffer[rSize] := #0; + Inc(rSize); + wSize := outStream.Write(iBuffer^, rSize); +{$IFDEF USE_EXCEPTIONS} + if wSize <> rSize then ZCompressCheck(Z_WRITE_ERROR); +{$ELSE} + if wSize <> rSize then begin + Result := Z_WRITE_ERROR; + Exit; + end; +{$ENDIF} + end; + // comment + if (byte(oBuffer[3]) and GZF_COMMENT) <> 0 then begin + rSize := Length(gzHdr.Comment); + Move(gzHdr.Comment[1], iBuffer^, rSize); + iBuffer[rSize] := #0; + Inc(rSize); + wSize := outStream.Write(iBuffer^, rSize); +{$IFDEF USE_EXCEPTIONS} + if wSize <> rSize then ZCompressCheck(Z_WRITE_ERROR); +{$ELSE} + if wSize <> rSize then begin + Result := Z_WRITE_ERROR; + Exit; + end; +{$ENDIF} + end; + // hcrc + + rSize := inStream.Read(iBuffer^, gzBufferSize); + zStream.next_out := PChar(oBuffer); + zStream.avail_out := gzBufferSize; + repeat + //DoProgressEvent; + zStream.next_in := PChar(iBuffer); + zStream.avail_in := rSize; + while (zStream.avail_in <> 0) do begin + if (zStream.avail_out = 0) then begin + zStream.next_out := PChar(oBuffer); + wSize := outStream.Write(oBuffer^, gzBufferSize); + if (wSize <> gzBufferSize) then begin +{$IFDEF USE_EXCEPTIONS} + ZCompressCheck(Z_WRITE_ERROR); +{$ELSE} + Result := Z_WRITE_ERROR; + Exit; +{$ENDIF} + end; + zStream.avail_out := gzBufferSize; + end; +{$IFDEF USE_EXCEPTIONS} + ZCompressCheck(deflate(zStream, Z_NO_FLUSH)); +{$ELSE} + Result := deflate(zStream, Z_NO_FLUSH); + if Result < 0 then Exit; +{$ENDIF} + end; // while + fCrc := Crc32(fCrc, PChar(iBuffer), rSize); + rSize := inStream.Read(iBuffer^, gzBufferSize); + until rSize = 0; + { flush buffers } + zStream.avail_in := 0; { should be zero already anyway } + done := False; + + repeat + rSize := gzBufferSize - zStream.avail_out; + if (rSize <> 0) then begin + wSize := outStream.Write(oBuffer^, rSize); +{$IFDEF USE_EXCEPTIONS} + if (wSize <> rSize) then ZCompressCheck(Z_WRITE_ERROR); +{$ELSE} + if (wSize <> rSize) then begin + Result := Z_WRITE_ERROR; + Exit; + end; +{$ENDIF} + zStream.next_out := PChar(oBuffer); + zStream.avail_out := gzBufferSize; + end; + if done then Break; + zResult := deflate(zStream, Z_FINISH); + if (rSize = 0) and (zResult = Z_BUF_ERROR) then +{$IFDEF USE_EXCEPTIONS} + else ZCompressCheck(zResult); +{$ELSE} + else begin + Result := zResult; + if Result < 0 then Exit; + end; +{$ENDIF} + { deflate has finished flushing only when it hasn't used up + all the available space in the output buffer: } + done := (zStream.avail_out <> 0) or (zResult = Z_STREAM_END); + until False; + wSize := outStream.Write(fCrc, 4); +{$IFDEF USE_EXCEPTIONS} + if wSize <> 4 then ZCompressCheck(Z_WRITE_ERROR); +{$ELSE} + if wSize <> 4 then begin + Result := Z_WRITE_ERROR; + Exit; + end; +{$ENDIF} + rSize := inStream.Size; + wSize := outStream.Write(rSize, 4); +{$IFDEF USE_EXCEPTIONS} + if wSize <> 4 then ZCompressCheck(Z_WRITE_ERROR); +{$ELSE} + if wSize <> 4 then begin + Result := Z_WRITE_ERROR; + Exit; + end; +{$ENDIF} + Result := Z_OK; + finally + deflateEnd(zStream); + if Assigned(iBuffer) then FreeMem(iBuffer); + if Assigned(oBuffer) then FreeMem(oBuffer); + end; +end; + +function gZipCompressStream(inStream, outStream: PStream; level: TZCompressionLevel = zcDefault; strategy: TZCompressionStrategy = zcsDefault): Integer; overload; +var + gzHdr : TgzipHeader; +begin + FillChar(gzHdr, SizeOf(gzHdr), 0); + gzHdr.FileTime := Date; + Result := gZipCompressStream(inStream, outStream, gzHdr, level, strategy); +end; + +function gZipDecompressStreamHeader(inStream: PStream; var gzHdr: TgzipHeader): Integer; +var + i, c, flg : LongInt; + fEOF : Boolean; + + function gz_getbyte: Integer; + var + b, c : Integer; + begin + b := 0; + c := inStream.Read(b, 1); + if c = 0 then begin + fEOF := True; + Result := Z_EOF; + end + else Result := b; + end; + + function gz_getlong: Integer; + var + b, c : Integer; + begin + b := 0; + c := inStream.Read(b, 4); + if c < 4 then begin + fEOF := True; + Result := Z_EOF; + end + else Result := b; + end; +begin + // fTransparent := False; + Result := Z_OK; + fEOF := False; + gzHdr.FileName := ''; + gzHdr.Comment := ''; + gzHdr.Extra := ''; + try + for i := 0 to 1 do begin + flg := gz_getbyte; + if (flg <> gz_magic[i]) then begin + fEOF := True; + exit; + end; + end; + c := gz_getbyte; // method + flg := gz_getbyte; // flags + if (c <> Z_DEFLATED) or ((flg and GZF_RESERVED) <> 0) then begin + fEOF := True; + exit; + end; + + gzHdr.FileTime := UnixToDateTime(gz_getLong); + gz_getbyte; + gz_getbyte; { skip xflags and OS code } + + if (flg and GZF_EXTRA_FIELD) <> 0 then begin // skip extra fields + i := gz_getbyte + (gz_getbyte shl 8); // length of extra + SetLength(gzHdr.Extra, i); + c := inStream.Read(gzHdr.Extra, i); + if c <> i then begin + fEOF := True; + Exit; + end; + end; + if (flg and GZF_ORIG_NAME) <> 0 then begin // extract File Name + repeat + c := gz_getbyte; + if (c <> 0) and (c <> Z_EOF) then gzHdr.FileName := gzHdr.FileName + char(c); + until (c = 0) or (c = Z_EOF); + end; + if (flg and GZF_COMMENT) <> 0 then begin // extract Comment + repeat + c := gz_getbyte; + if (c <> 0) and (c <> Z_EOF) then gzHdr.Comment := gzHdr.Comment + char(c); + until (c = 0) or (c = Z_EOF); + end; + if (flg and GZF_HEAD_CRC) <> 0 then begin // skip head crc + gz_getbyte; + gz_getbyte; + end; + finally + if fEOF then Result := Z_DATA_ERROR + else Result := Z_OK; + end; +end; + +function gZipDecompressStreamBody(inStream, outStream: PStream; const aCheckCRC: Boolean = True): Integer; +var + iBuffer, + oBuffer : PChar; //Array [0..gzBufferSize-1] of Char; + fCrc : Cardinal; + zStream : TZStreamRec; + rSize, + wSize : LongInt; + startCRC : PChar; + fileCRC, + fileSize : Cardinal; + fEOF : Boolean; + + function gz_getbyte: Integer; + begin + // if (eof) then result:=-1; + if (zStream.avail_in = 0) then begin + zStream.avail_in := inStream.Read(iBuffer^, gzBufferSize); + if (zStream.avail_in = 0) then begin + Result := Z_EOF; + fEOF := True; + exit; + end + else zStream.next_in := PChar(iBuffer); + end; + Dec(zStream.avail_in); + Result := Byte(zStream.next_in[0]); + Inc(zStream.next_in); + end; + + function gz_getLong: Cardinal; + var + c : Integer; + begin + c := gz_getbyte; + c := c + gz_getbyte shl 8; + c := c + gz_getbyte shl 16; + c := c + gz_getbyte shl 24; + Result := Cardinal(c); + end; +begin + iBuffer := nil; + oBuffer := nil; +{$IFDEF USE_EXCEPTIONS} + Result := Z_MEM_ERROR; +{$ENDIF} + try + GetMem(iBuffer, gzBufferSize); + GetMem(oBuffer, gzBufferSize); + fEOF := False; + {Check the gzip header of a gz_stream opened for reading. + Set the stream mode to transparent if the gzip magic header is not present.} + + FillChar(zStream, SizeOf(zStream), 0); + zStream.next_in := pChar(iBuffer); + fCRC := 0; + { windowBits is passed < 0 to tell that there is no zlib header } +{$IFDEF USE_EXCEPTIONS} + ZDecompressCheck(InflateInit2(zStream, -MAX_WBITS)); +{$ELSE} + Result := InflateInit2(zStream, -MAX_WBITS); + if Result < 0 then Exit; +{$ENDIF} + while not fEOF do begin + // gzread() + // DoProgressEvent; + startCRC := PChar(oBuffer); + zStream.next_out := PChar(oBuffer); + zStream.avail_out := gzBufferSize; +// rSize := 0; + Result := Z_OK; + while zStream.avail_out <> 0 do begin + // not transparent + if (zStream.avail_in = 0) and (not fEOF) then begin + zStream.avail_in := inStream.Read(iBuffer^, gzBufferSize); + if (zStream.avail_in = 0) then fEOF := True; + zStream.next_in := PChar(iBuffer); + end; + Result := inflate(zStream, Z_NO_FLUSH); + if (Result = Z_STREAM_END) then begin + { Check CRC and original size } + fCrc := crc32(fCrc, PChar(StartCRC), (zStream.next_out - startCRC)); + startCRC := zStream.next_out; + + fileCRC := gz_getLong; + fileSize := gz_getLong; + if aCheckCRC and (fCrc <> fileCRC) then + {$IFDEF USE_EXCEPTIONS} + ZDecompressCheck(Z_CRC_ERROR) + {$ELSE} + Result := Z_CRC_ERROR + {$ENDIF} + else if aCheckCRC and (Cardinal(zStream.total_out) <> fileSize) then + {$IFDEF USE_EXCEPTIONS} + ZDecompressCheck(Z_SIZE_ERROR) + {$ELSE} + Result := Z_SIZE_ERROR + {$ENDIF} + else begin + if (zStream.avail_in > 0) then + inStream.Seek(-zStream.avail_in, spCurrent); + fEOF := True; + end; + end; + if (Result <> Z_OK) or (fEOF) then + break; + end; // while zStream.avail_out<>0 + // end of gzread() + + {$IFDEF USE_EXCEPTIONS} + DecompressCheck(Result); + {$ELSE} + if (Result < 0) then + Exit; + {$ENDIF} + fCrc := crc32(fCrc, PChar(oBuffer), (zStream.next_out - startCRC)); + rSize := gzBufferSize - zStream.avail_out; + + {$IFDEF USE_EXCEPTIONS} + if (rSize < 0) then + ZDecompressCheck(rSize); + {$ELSE} + if (rSize <= 0) then + break; + {$ENDIF} + + wSize := outStream.Write(oBuffer^, rSize); + {$IFDEF USE_EXCEPTIONS} + if (rSize <> wSize) then + ZDecompressCheck(Z_WRITE_ERROR); + {$ELSE} + if (rSize <> wSize) then begin + Result := Z_WRITE_ERROR; + Exit; + end; + {$ENDIF} + end; + if (Result = Z_STREAM_END) then + Result := Z_OK; + finally + inflateEnd(zStream); + if Assigned(iBuffer) then + FreeMem(iBuffer); + if Assigned(oBuffer) then + FreeMem(oBuffer); + end; +end; + +function gZipDecompressStream(inStream, outStream: PStream; var gzHdr: TgzipHeader): Integer; +begin + Result := gZipDecompressStreamHeader(inStream, gzHdr); + if (Result >= Z_OK) then + Result := gZipDecompressStreamBody(inStream, outStream); +end; + +function gZipDecompressString(const S: String; const useheaders: Boolean = True; const aCheckCRC: Boolean = True): String; +var + Rslt: Integer; + gzHdr: TgzipHeader; + inStream: PStream; + outStream: PStream; +begin + Result := ''; + inStream := NewExMemoryStream(@S[1], Length(S)); + // unpack head + if useheaders then + Rslt := gZipDecompressStreamHeader(inStream, gzHdr) + else + Rslt := Z_OK; + // unpack body + if (Rslt >= Z_OK) then begin + outStream := NewMemoryStream; + Rslt := gZipDecompressStreamBody(inStream, outStream, aCheckCRC); + if not useheaders or (Rslt >= Z_OK) then begin + outStream.Position := 0; + Result := outStream.ReadStrLen(outStream.Size); + end; + outStream.Free; + end; + inStream.Free; +end; + +{****************************************************************************} +{** BZip implementation *****************************************************} +{****************************************************************************} +{$IFDEF USE_EXCEPTIONS} + +function CCheck(code: Integer): Integer; +begin + Result := code; + if code < 0 then + raise Exception.CreateFMT(e_Convert, 'Compression Error %d - %s', [code, BZ_Error_Msg[-code]]); +end; + +function DCheck(code: Integer): Integer; +begin + Result := code; + if code < 0 then + raise Exception.CreateFMT(e_Convert, 'Decompression Error %d - %s', [code, BZ_Error_Msg[-code]]); +end; +{$ENDIF} + +function BZCompressBuf(const InBuf: Pointer; InBytes: Integer; out OutBuf: Pointer; out OutBytes: Integer): Integer; +var + strm : TBZStreamRec; + P : Pointer; +begin + FillChar(strm, sizeof(strm), 0); + strm.bzalloc := bzip2AllocMem; + strm.bzfree := bzip2FreeMem; + OutBytes := ((InBytes + (InBytes div 10) + 12) + 255) and not 255; + GetMem(OutBuf, OutBytes); + Result := BZ_OK; + try + strm.next_in := InBuf; + strm.avail_in := InBytes; + strm.next_out := OutBuf; + strm.avail_out := OutBytes; +{$IFDEF USE_EXCEPTIONS} + CCheck(BZ2_bzCompressInit(strm, 9, 0, 0)); +{$ELSE} + Result := BZ2_bzCompressInit(strm, 9, 0, 0); + if Result < 0 then Exit; +{$ENDIF} + try +{$IFDEF USE_EXCEPTIONS} + Result := CCheck(BZ2_bzCompress(strm, BZ_FINISH)); +{$ELSE} + Result := BZ2_bzCompress(strm, BZ_FINISH); + if Result < 0 then Exit; +{$ENDIF} + while Result <> BZ_STREAM_END do begin + P := OutBuf; + Inc(OutBytes, 256); + ReallocMem(OutBuf, OutBytes); + strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P))); + strm.avail_out := 256; +{$IFDEF USE_EXCEPTIONS} + Result := CCheck(BZ2_bzCompress(strm, BZ_FINISH)); +{$ELSE} + Result := BZ2_bzCompress(strm, BZ_FINISH); + if Result < 0 then Exit; +{$ENDIF} + end; + finally +{$IFDEF USE_EXCEPTIONS} + CCheck(BZ2_bzCompressEnd(strm)); +{$ELSE} + BZ2_bzCompressEnd(strm); +{$ENDIF} + end; + ReallocMem(OutBuf, strm.total_out_lo32); + OutBytes := strm.total_out_lo32; +{$IFDEF USE_EXCEPTIONS} + except + FreeMem(outBuf); + raise; +{$ELSE} + finally + if Result < 0 then FreeMem(outBuf); +{$ENDIF} + end; +end; + +function BZDecompressBuf(const InBuf: Pointer; InBytes: Integer; OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer): Integer; +var + strm : TBZStreamRec; + P : Pointer; + BufInc : Integer; +begin + FillChar(strm, sizeof(strm), 0); + strm.bzalloc := bzip2AllocMem; + strm.bzfree := bzip2FreeMem; + BufInc := (InBytes + 255) and not 255; +{$IFDEF USE_EXCEPTIONS} + Result := BZ_OK; +{$ENDIF} + if OutEstimate = 0 then + OutBytes := BufInc + else + OutBytes := OutEstimate; + GetMem(OutBuf, OutBytes); + try + strm.next_in := InBuf; + strm.avail_in := InBytes; + strm.next_out := OutBuf; + strm.avail_out := OutBytes; +{$IFDEF USE_EXCEPTIONS} + DCheck(BZ2_bzDecompressInit(strm, 0, 0)); +{$ELSE} + Result := BZ2_bzDecompressInit(strm, 0, 0); + if Result < 0 then Exit; +{$ENDIF} + try +{$IFDEF USE_EXCEPTIONS} + Result := DCheck(BZ2_bzDecompress(strm)); +{$ELSE} + Result := BZ2_bzDecompress(strm); + if Result < 0 then Exit; +{$ENDIF} + while Result <> BZ_STREAM_END do begin + P := OutBuf; + Inc(OutBytes, BufInc); + ReallocMem(OutBuf, OutBytes); + strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P))); + strm.avail_out := BufInc; +{$IFDEF USE_EXCEPTIONS} + Result := DCheck(BZ2_bzDecompress(strm)); +{$ELSE} + Result := BZ2_bzDecompress(strm); + if Result < 0 then Exit; +{$ENDIF} + end; + finally +{$IFDEF USE_EXCEPTIONS} + DCheck(BZ2_bzDecompressEnd(strm)); +{$ELSE} + BZ2_bzDecompressEnd(strm); +{$ENDIF} + end; + ReallocMem(OutBuf, strm.total_out_lo32); + OutBytes := strm.total_out_lo32; + except + FreeMem(OutBuf); + raise + end; +end; + +function BZCompressStream(inStream, outStream: PStream; BlockSize100k: TBlockSize100k = 5): Integer; +var + FBZRec : TBZStreamRec; + iBuffer, + oBuffer : PChar; + wSize, + rSize : Integer; +begin + Result := BZ_MEM_ERROR; + iBuffer := nil; + oBuffer := nil; + FillChar(FBZRec, SizeOf(FBZRec), 0); + // FBZRec.bzalloc := bzip2AllocMem; + // FBZRec.bzfree := bzip2FreeMem; + try + GetMem(iBuffer, bzBufferSize); + GetMem(oBuffer, bzBufferSize); +{$IFDEF USE_EXCEPTIONS} + CCheck(BZ2_bzCompressInit(FBZRec, BlockSize100k, 0, 0)); +{$ELSE} + Result := BZ2_bzCompressInit(FBZRec, BlockSize100k, 0, 0); + if Result < 0 then Exit; +{$ENDIF} + FBZRec.next_out := PChar(oBuffer); + FBZRec.avail_out := bzBufferSize; + rSize := inStream.Read(iBuffer^, bzBufferSize); + repeat + //DoProgressEvent; + FBZRec.next_in := PChar(iBuffer); + FBZRec.avail_in := rSize; + while (FBZRec.avail_in > 0) do begin + if (FBZRec.avail_out = 0) then begin + wSize := outStream.Write(oBuffer^, bzBufferSize); + if (wSize <> bzBufferSize) then begin +{$IFDEF USE_EXCEPTIONS} + CCheck(BZ_IO_ERROR); +{$ELSE} + Result := BZ_IO_ERROR; + Exit; +{$ENDIF} + end; + FBZRec.next_out := PChar(oBuffer); + FBZRec.avail_out := bzBufferSize; + end; +{$IFDEF USE_EXCEPTIONS} + CCheck(BZ2_bzCompress(FBZRec, BZ_RUN)); +{$ELSE} + Result := BZ2_bzCompress(FBZRec, BZ_RUN); + if Result < 0 then Exit; +{$ENDIF} + end; // while + rSize := inStream.Read(iBuffer^, bzBufferSize); + until rSize = 0; + { flush buffers } + FBZRec.avail_in := 0; { should be zero already anyway } + repeat +{$IFDEF USE_EXCEPTIONS} + Result := CCheck(BZ2_bzCompress(FBZRec, BZ_FINISH)); +{$ELSE} + Result := BZ2_bzCompress(FBZRec, BZ_FINISH); + if Result < 0 then Break; +{$ENDIF} + rSize := bzBufferSize - FBZRec.avail_out; + wSize := outStream.Write(oBuffer^, rSize); +{$IFDEF USE_EXCEPTIONS} + if (wSize <> rSize) then CCheck(BZ_IO_ERROR); +{$ELSE} + if (wSize <> rSize) then begin + Result := BZ_IO_ERROR; + break; + end; +{$ENDIF} + FBZRec.next_out := PChar(oBuffer); + FBZRec.avail_out := bzBufferSize; + until Result = BZ_STREAM_END; + finally + if Result = BZ_STREAM_END then Result := BZ_OK; + BZ2_bzCompressEnd(FBZRec); + if Assigned(iBuffer) then FreeMem(iBuffer); + if Assigned(oBuffer) then FreeMem(oBuffer); + end; + +end; + +function BZDecompressStream(inStream, outStream: PStream): Integer; +var + FBZRec : TBZStreamRec; + iBuffer, + oBuffer : PChar; + wSize, + rSize : Integer; +begin + Result := BZ_MEM_ERROR; + iBuffer := nil; + oBuffer := nil; + FillChar(FBZRec, SizeOf(FBZRec), 0); + try + GetMem(iBuffer, bzBufferSize); + GetMem(oBuffer, bzBufferSize); +{$IFDEF USE_EXCEPTIONS} + DCheck(BZ2_bzDecompressInit(FBZRec, 0, 0)); +{$ELSE} + Result := BZ2_bzDecompressInit(FBZRec, 0, 0); + if Result < 0 then Exit; +{$ENDIF} + rSize := inStream.Read(iBuffer^, bzBufferSize); + FBZRec.next_in := PChar(iBuffer); + FBZRec.avail_in := rSize; + repeat + FBZRec.next_out := PChar(oBuffer); + FBZRec.avail_out := bzBufferSize; + Result := 0; + while (FBZRec.avail_out > 0) and (Result <> BZ_STREAM_END) do begin +{$IFDEF USE_EXCEPTIONS} + Result := CCheck(BZ2_bzDecompress(FBZRec)); +{$ELSE} + Result := BZ2_bzDecompress(FBZRec); + if Result < 0 then Break; +{$ENDIF} + if FBZRec.avail_in = 0 then begin + rSize := inStream.Read(iBuffer^, bzBufferSize); + FBZRec.next_in := PChar(iBuffer); + FBZRec.avail_in := rSize; + end; + end; + FBZRec.avail_out := bzBufferSize - FBZRec.avail_out; + wSize := outStream.Write(oBuffer^, FBZRec.avail_out); +{$IFDEF USE_EXCEPTIONS} + if FBZRec.avail_out <> wSize then CCheck(BZ_IO_ERROR); +{$ELSE} + if FBZRec.avail_out <> wSize then Result := BZ_IO_ERROR; +{$ENDIF} + until (rSize = 0) or (Result < 0); + finally + if Result = BZ_STREAM_END then Result := BZ_OK; + BZ2_bzDecompressEnd(FBZRec); + if Assigned(iBuffer) then FreeMem(iBuffer); + if Assigned(oBuffer) then FreeMem(oBuffer); + end; +end; + +end. diff --git a/Addons/mckCCtrls.pas b/Addons/mckCCtrls.pas index d6f5eb6..9e7e996 100644 --- a/Addons/mckCCtrls.pas +++ b/Addons/mckCCtrls.pas @@ -35,7 +35,7 @@ type function AdditionalUnits: string; override; function TabStopByDefault: Boolean; override; procedure SetupFirst(SL: TStringList; const AName, AParent, Prefix: string); override; - function SetupParams(const AName, AParent: string): string; override; + function SetupParams(const AName, AParent: TDelphiString): TDelphiString; override; procedure SetupConstruct(SL: TStringList; const AName, AParent, Prefix: string); override; public constructor Create(AOwner: TComponent); override; @@ -502,7 +502,7 @@ begin SL.Add(Prefix + AName + '.SelEnd := ' + IntToStr(SelEnd) + ';'); end; -function TKOLTrackBar.SetupParams(const AName, AParent: string): string; +function TKOLTrackBar.SetupParams(const AName, AParent: TDelphiString): TDelphiString; var S : string; begin diff --git a/Addons/mckEcmListEdit.pas b/Addons/mckEcmListEdit.pas index c3fcdb8..811ba0a 100644 --- a/Addons/mckEcmListEdit.pas +++ b/Addons/mckEcmListEdit.pas @@ -46,7 +46,7 @@ type procedure SetupFirst( SL: TStringList; const AName, AParent, Prefix: String ); override; procedure SetupLast( SL: TStringList; const AName, AParent, Prefix: String ); override; procedure AssignEvents( SL: TStringList; const AName: String ); override; - function SetupParams( const AName, AParent: String ): String; override; + function SetupParams( const AName, AParent: TDelphiString ): TDelphiString; override; function GetCaption: string; function GetStyle: TKOLListViewStyle; function GetOptions: TKOLListViewOptions; @@ -207,7 +207,7 @@ begin end; end; -function TKOLEcmListEdit.SetupParams(const AName, AParent: String): String; +function TKOLEcmListEdit.SetupParams(const AName, AParent: TDelphiString): TDelphiString; begin Result := inherited SetupParams(AName,AParent) end; diff --git a/Addons/tinyPNG.pas b/Addons/tinyPNG.pas index e541fd3..7e1fb7c 100644 --- a/Addons/tinyPNG.pas +++ b/Addons/tinyPNG.pas @@ -192,7 +192,7 @@ type HasPallete: boolean; end; - TChunkType = array[0..3] of Char; + TChunkType = array[0..3] of AnsiChar; TPNGChunkHeader = packed record Length: cardinal;