diff --git a/extern/lzo/include/lzo/lzo1.h b/extern/lzo/include/lzo/lzo1.h index b5a67b6..b641076 100644 --- a/extern/lzo/include/lzo/lzo1.h +++ b/extern/lzo/include/lzo/lzo1.h @@ -51,14 +51,14 @@ extern "C" { LZO_EXTERN(int) -lzo1_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1_decompress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1_decompress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /*********************************************************************** @@ -68,9 +68,9 @@ lzo1_decompress ( const lzo_bytep src, lzo_uint src_len, #define LZO1_99_MEM_COMPRESS ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t)) LZO_EXTERN(int) -lzo1_99_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1_99_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); diff --git a/extern/lzo/include/lzo/lzo1a.h b/extern/lzo/include/lzo/lzo1a.h index ca761e5..4e09626 100644 --- a/extern/lzo/include/lzo/lzo1a.h +++ b/extern/lzo/include/lzo/lzo1a.h @@ -51,14 +51,14 @@ extern "C" { LZO_EXTERN(int) -lzo1a_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1a_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1a_decompress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1a_decompress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /*********************************************************************** @@ -68,9 +68,9 @@ lzo1a_decompress ( const lzo_bytep src, lzo_uint src_len, #define LZO1A_99_MEM_COMPRESS ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t)) LZO_EXTERN(int) -lzo1a_99_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1a_99_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); diff --git a/extern/lzo/include/lzo/lzo1b.h b/extern/lzo/include/lzo/lzo1b.h index bbfd754..ec3e7b9 100644 --- a/extern/lzo/include/lzo/lzo1b.h +++ b/extern/lzo/include/lzo/lzo1b.h @@ -57,22 +57,22 @@ extern "C" { LZO_EXTERN(int) -lzo1b_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - int compression_level ); +lzo1b_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + int compression_level); /* decompression */ LZO_EXTERN(int) -lzo1b_decompress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1b_decompress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /* safe decompression with overrun testing */ LZO_EXTERN(int) -lzo1b_decompress_safe ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1b_decompress_safe(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /*********************************************************************** @@ -80,41 +80,41 @@ lzo1b_decompress_safe ( const lzo_bytep src, lzo_uint src_len, ************************************************************************/ LZO_EXTERN(int) -lzo1b_1_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1b_1_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1b_2_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1b_2_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1b_3_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1b_3_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1b_4_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1b_4_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1b_5_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1b_5_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1b_6_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1b_6_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1b_7_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1b_7_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1b_8_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1b_8_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1b_9_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1b_9_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); /*********************************************************************** @@ -124,17 +124,17 @@ lzo1b_9_compress ( const lzo_bytep src, lzo_uint src_len, #define LZO1B_99_MEM_COMPRESS ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t)) LZO_EXTERN(int) -lzo1b_99_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1b_99_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); #define LZO1B_999_MEM_COMPRESS ((lzo_uint32_t) (3 * 65536L * sizeof(lzo_xint))) LZO_EXTERN(int) -lzo1b_999_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1b_999_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); diff --git a/extern/lzo/include/lzo/lzo1c.h b/extern/lzo/include/lzo/lzo1c.h index 2001082..c3580ab 100644 --- a/extern/lzo/include/lzo/lzo1c.h +++ b/extern/lzo/include/lzo/lzo1c.h @@ -57,22 +57,22 @@ extern "C" { LZO_EXTERN(int) -lzo1c_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - int compression_level ); +lzo1c_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + int compression_level); /* decompression */ LZO_EXTERN(int) -lzo1c_decompress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1c_decompress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /* safe decompression with overrun testing */ LZO_EXTERN(int) -lzo1c_decompress_safe ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1c_decompress_safe(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /*********************************************************************** @@ -80,41 +80,41 @@ lzo1c_decompress_safe ( const lzo_bytep src, lzo_uint src_len, ************************************************************************/ LZO_EXTERN(int) -lzo1c_1_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1c_1_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1c_2_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1c_2_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1c_3_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1c_3_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1c_4_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1c_4_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1c_5_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1c_5_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1c_6_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1c_6_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1c_7_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1c_7_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1c_8_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1c_8_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) -lzo1c_9_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1c_9_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); /*********************************************************************** @@ -124,17 +124,17 @@ lzo1c_9_compress ( const lzo_bytep src, lzo_uint src_len, #define LZO1C_99_MEM_COMPRESS ((lzo_uint32_t) (65536L * lzo_sizeof_dict_t)) LZO_EXTERN(int) -lzo1c_99_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1c_99_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); #define LZO1C_999_MEM_COMPRESS ((lzo_uint32_t) (5 * 16384L * sizeof(short))) LZO_EXTERN(int) -lzo1c_999_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1c_999_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); diff --git a/extern/lzo/include/lzo/lzo1f.h b/extern/lzo/include/lzo/lzo1f.h index 504e523..01e865d 100644 --- a/extern/lzo/include/lzo/lzo1f.h +++ b/extern/lzo/include/lzo/lzo1f.h @@ -52,15 +52,15 @@ extern "C" { /* decompression */ LZO_EXTERN(int) -lzo1f_decompress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1f_decompress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /* safe decompression with overrun testing */ LZO_EXTERN(int) -lzo1f_decompress_safe ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1f_decompress_safe(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /*********************************************************************** @@ -68,9 +68,9 @@ lzo1f_decompress_safe ( const lzo_bytep src, lzo_uint src_len, ************************************************************************/ LZO_EXTERN(int) -lzo1f_1_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1f_1_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); /*********************************************************************** @@ -80,9 +80,9 @@ lzo1f_1_compress ( const lzo_bytep src, lzo_uint src_len, #define LZO1F_999_MEM_COMPRESS ((lzo_uint32_t) (5 * 16384L * sizeof(short))) LZO_EXTERN(int) -lzo1f_999_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1f_999_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); diff --git a/extern/lzo/include/lzo/lzo1x.h b/extern/lzo/include/lzo/lzo1x.h index f1599a6..db1195e 100644 --- a/extern/lzo/include/lzo/lzo1x.h +++ b/extern/lzo/include/lzo/lzo1x.h @@ -53,15 +53,15 @@ extern "C" { /* decompression */ LZO_EXTERN(int) -lzo1x_decompress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1x_decompress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /* safe decompression with overrun testing */ LZO_EXTERN(int) -lzo1x_decompress_safe ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1x_decompress_safe(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /*********************************************************************** @@ -71,9 +71,9 @@ lzo1x_decompress_safe ( const lzo_bytep src, lzo_uint src_len, #define LZO1X_1_MEM_COMPRESS ((lzo_uint32_t) (16384L * lzo_sizeof_dict_t)) LZO_EXTERN(int) -lzo1x_1_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1x_1_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); /*********************************************************************** @@ -84,27 +84,27 @@ lzo1x_1_compress ( const lzo_bytep src, lzo_uint src_len, #define LZO1X_1_11_MEM_COMPRESS ((lzo_uint32_t) (2048L * lzo_sizeof_dict_t)) LZO_EXTERN(int) -lzo1x_1_11_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1x_1_11_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); /* this version needs 16 KiB work memory */ #define LZO1X_1_12_MEM_COMPRESS ((lzo_uint32_t) (4096L * lzo_sizeof_dict_t)) LZO_EXTERN(int) -lzo1x_1_12_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1x_1_12_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); /* use this version if you need a little more compression speed */ #define LZO1X_1_15_MEM_COMPRESS ((lzo_uint32_t) (32768L * lzo_sizeof_dict_t)) LZO_EXTERN(int) -lzo1x_1_15_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1x_1_15_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); /*********************************************************************** @@ -114,9 +114,9 @@ lzo1x_1_15_compress ( const lzo_bytep src, lzo_uint src_len, #define LZO1X_999_MEM_COMPRESS ((lzo_uint32_t) (14 * 16384L * sizeof(short))) LZO_EXTERN(int) -lzo1x_999_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1x_999_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); /*********************************************************************** @@ -124,24 +124,24 @@ lzo1x_999_compress ( const lzo_bytep src, lzo_uint src_len, ************************************************************************/ LZO_EXTERN(int) -lzo1x_999_compress_dict ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len ); +lzo1x_999_compress_dict(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len); LZO_EXTERN(int) -lzo1x_999_compress_level ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len, - lzo_callback_p cb, - int compression_level ); +lzo1x_999_compress_level(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len, + lzo_callback_p cb, + int compression_level); LZO_EXTERN(int) -lzo1x_decompress_dict_safe ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */, - const lzo_bytep dict, lzo_uint dict_len ); +lzo1x_decompress_dict_safe(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */, + const lzo_bytep dict, lzo_uint dict_len); /*********************************************************************** @@ -149,9 +149,9 @@ lzo1x_decompress_dict_safe ( const lzo_bytep src, lzo_uint src_len, ************************************************************************/ LZO_EXTERN(int) -lzo1x_optimize ( lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1x_optimize(lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); diff --git a/extern/lzo/include/lzo/lzo1y.h b/extern/lzo/include/lzo/lzo1y.h index da199c0..364fa96 100644 --- a/extern/lzo/include/lzo/lzo1y.h +++ b/extern/lzo/include/lzo/lzo1y.h @@ -53,15 +53,15 @@ extern "C" { /* decompression */ LZO_EXTERN(int) -lzo1y_decompress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1y_decompress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /* safe decompression with overrun testing */ LZO_EXTERN(int) -lzo1y_decompress_safe ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1y_decompress_safe(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /*********************************************************************** @@ -69,9 +69,9 @@ lzo1y_decompress_safe ( const lzo_bytep src, lzo_uint src_len, ************************************************************************/ LZO_EXTERN(int) -lzo1y_1_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1y_1_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); /*********************************************************************** @@ -81,9 +81,9 @@ lzo1y_1_compress ( const lzo_bytep src, lzo_uint src_len, #define LZO1Y_999_MEM_COMPRESS ((lzo_uint32_t) (14 * 16384L * sizeof(short))) LZO_EXTERN(int) -lzo1y_999_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1y_999_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); @@ -92,24 +92,24 @@ lzo1y_999_compress ( const lzo_bytep src, lzo_uint src_len, ************************************************************************/ LZO_EXTERN(int) -lzo1y_999_compress_dict ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len ); +lzo1y_999_compress_dict(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len); LZO_EXTERN(int) -lzo1y_999_compress_level ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len, - lzo_callback_p cb, - int compression_level ); +lzo1y_999_compress_level(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len, + lzo_callback_p cb, + int compression_level); LZO_EXTERN(int) -lzo1y_decompress_dict_safe ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */, - const lzo_bytep dict, lzo_uint dict_len ); +lzo1y_decompress_dict_safe(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */, + const lzo_bytep dict, lzo_uint dict_len); /*********************************************************************** @@ -117,9 +117,9 @@ lzo1y_decompress_dict_safe ( const lzo_bytep src, lzo_uint src_len, ************************************************************************/ LZO_EXTERN(int) -lzo1y_optimize ( lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1y_optimize(lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); diff --git a/extern/lzo/include/lzo/lzo1z.h b/extern/lzo/include/lzo/lzo1z.h index 5adb905..eb16c3d 100644 --- a/extern/lzo/include/lzo/lzo1z.h +++ b/extern/lzo/include/lzo/lzo1z.h @@ -51,15 +51,15 @@ extern "C" { /* decompression */ LZO_EXTERN(int) -lzo1z_decompress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1z_decompress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /* safe decompression with overrun testing */ LZO_EXTERN(int) -lzo1z_decompress_safe ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo1z_decompress_safe(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /*********************************************************************** @@ -69,9 +69,9 @@ lzo1z_decompress_safe ( const lzo_bytep src, lzo_uint src_len, #define LZO1Z_999_MEM_COMPRESS ((lzo_uint32_t) (14 * 16384L * sizeof(short))) LZO_EXTERN(int) -lzo1z_999_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo1z_999_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); /*********************************************************************** @@ -79,24 +79,24 @@ lzo1z_999_compress ( const lzo_bytep src, lzo_uint src_len, ************************************************************************/ LZO_EXTERN(int) -lzo1z_999_compress_dict ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len ); +lzo1z_999_compress_dict(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len); LZO_EXTERN(int) -lzo1z_999_compress_level ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len, - lzo_callback_p cb, - int compression_level ); +lzo1z_999_compress_level(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len, + lzo_callback_p cb, + int compression_level); LZO_EXTERN(int) -lzo1z_decompress_dict_safe ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */, - const lzo_bytep dict, lzo_uint dict_len ); +lzo1z_decompress_dict_safe(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */, + const lzo_bytep dict, lzo_uint dict_len); #ifdef __cplusplus diff --git a/extern/lzo/include/lzo/lzo2a.h b/extern/lzo/include/lzo/lzo2a.h index ded7f9e..ff2d39f 100644 --- a/extern/lzo/include/lzo/lzo2a.h +++ b/extern/lzo/include/lzo/lzo2a.h @@ -46,15 +46,15 @@ extern "C" { /* decompression */ LZO_EXTERN(int) -lzo2a_decompress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo2a_decompress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /* safe decompression with overrun testing */ LZO_EXTERN(int) -lzo2a_decompress_safe ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem /* NOT USED */ ); +lzo2a_decompress_safe(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem /* NOT USED */); /*********************************************************************** @@ -64,9 +64,9 @@ lzo2a_decompress_safe ( const lzo_bytep src, lzo_uint src_len, #define LZO2A_999_MEM_COMPRESS ((lzo_uint32_t) (8 * 16384L * sizeof(short))) LZO_EXTERN(int) -lzo2a_999_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +lzo2a_999_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); diff --git a/extern/lzo/include/lzo/lzo_asm.h b/extern/lzo/include/lzo/lzo_asm.h index 5a654bf..a5794f2 100644 --- a/extern/lzo/include/lzo/lzo_asm.h +++ b/extern/lzo/include/lzo/lzo_asm.h @@ -56,56 +56,56 @@ extern "C" { ************************************************************************/ LZO_EXTERN(int) lzo1c_decompress_asm - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) lzo1c_decompress_asm_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) lzo1f_decompress_asm_fast - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) lzo1f_decompress_asm_fast_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) lzo1x_decompress_asm - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) lzo1x_decompress_asm_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) lzo1x_decompress_asm_fast - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) lzo1x_decompress_asm_fast_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) lzo1y_decompress_asm - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) lzo1y_decompress_asm_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) lzo1y_decompress_asm_fast - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_EXTERN(int) lzo1y_decompress_asm_fast_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); /*********************************************************************** @@ -122,10 +122,10 @@ LZO_EXTERN(lzo_uint32_t) lzo_crc32_asm_small(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len); LZO_EXTERN(int) -lzo_cpuid_asm(lzo_uint32_tp /* lzo_uint32_t info[16] */ ); +lzo_cpuid_asm(lzo_uint32_tp /* lzo_uint32_t info[16] */); LZO_EXTERN(lzo_uint32_t) -lzo_rdtsc_asm(lzo_uint32_tp /* lzo_uint32_t ticks[2] */ ); +lzo_rdtsc_asm(lzo_uint32_tp /* lzo_uint32_t ticks[2] */); #endif diff --git a/extern/lzo/include/lzo/lzoconf.h b/extern/lzo/include/lzo/lzoconf.h index 64ef279..acb7b0c 100644 --- a/extern/lzo/include/lzo/lzoconf.h +++ b/extern/lzo/include/lzo/lzoconf.h @@ -92,12 +92,12 @@ extern "C" { #if !defined(LZO_UINT_MAX) # if (LZO_ABI_LLP64) # if (LZO_OS_WIN64) - typedef unsigned __int64 lzo_uint; - typedef __int64 lzo_int; +typedef unsigned __int64 lzo_uint; +typedef __int64 lzo_int; # define LZO_TYPEOF_LZO_INT LZO_TYPEOF___INT64 # else - typedef lzo_ullong_t lzo_uint; - typedef lzo_llong_t lzo_int; +typedef lzo_ullong_t lzo_uint; +typedef lzo_llong_t lzo_int; # define LZO_TYPEOF_LZO_INT LZO_TYPEOF_LONG_LONG # endif # define LZO_SIZEOF_LZO_INT 8 @@ -105,16 +105,16 @@ extern "C" { # define LZO_INT_MAX 9223372036854775807LL # define LZO_INT_MIN (-1LL - LZO_INT_MAX) # elif (LZO_ABI_IP32L64) /* MIPS R5900 */ - typedef unsigned int lzo_uint; - typedef int lzo_int; +typedef unsigned int lzo_uint; +typedef int lzo_int; # define LZO_SIZEOF_LZO_INT LZO_SIZEOF_INT # define LZO_TYPEOF_LZO_INT LZO_TYPEOF_INT # define LZO_UINT_MAX UINT_MAX # define LZO_INT_MAX INT_MAX # define LZO_INT_MIN INT_MIN # elif (ULONG_MAX >= LZO_0xffffffffL) - typedef unsigned long lzo_uint; - typedef long lzo_int; +typedef unsigned long lzo_uint; +typedef long lzo_int; # define LZO_SIZEOF_LZO_INT LZO_SIZEOF_LONG # define LZO_TYPEOF_LZO_INT LZO_TYPEOF_LONG # define LZO_UINT_MAX ULONG_MAX @@ -191,11 +191,11 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) >= 4) LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) == sizeof(size_t)) LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) == sizeof(ptrdiff_t)) LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint) == sizeof(lzo_uintptr_t)) -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void *) == sizeof(lzo_uintptr_t)) -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char *) == sizeof(lzo_uintptr_t)) -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(long *) == sizeof(lzo_uintptr_t)) -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void *) == sizeof(lzo_voidp)) -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char *) == sizeof(lzo_bytep)) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void*) == sizeof(lzo_uintptr_t)) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char*) == sizeof(lzo_uintptr_t)) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(long*) == sizeof(lzo_uintptr_t)) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(void*) == sizeof(lzo_voidp)) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char*) == sizeof(lzo_bytep)) /*********************************************************************** @@ -237,31 +237,31 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(char *) == sizeof(lzo_bytep)) /* function types */ typedef int -(__LZO_CDECL *lzo_compress_t) ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +(__LZO_CDECL* lzo_compress_t)(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); typedef int -(__LZO_CDECL *lzo_decompress_t) ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +(__LZO_CDECL* lzo_decompress_t)(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); typedef int -(__LZO_CDECL *lzo_optimize_t) ( lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem ); +(__LZO_CDECL* lzo_optimize_t)(lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); typedef int -(__LZO_CDECL *lzo_compress_dict_t)(const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len ); +(__LZO_CDECL* lzo_compress_dict_t)(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len); typedef int -(__LZO_CDECL *lzo_decompress_dict_t)(const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len ); +(__LZO_CDECL* lzo_decompress_dict_t)(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len); /* Callback interface. Currently only the progress indicator ("nprogress") @@ -272,14 +272,14 @@ typedef struct lzo_callback_t lzo_callback_t; #define lzo_callback_p lzo_callback_t __LZO_MMODEL * /* malloc & free function types */ -typedef lzo_voidp (__LZO_CDECL *lzo_alloc_func_t) - (lzo_callback_p self, lzo_uint items, lzo_uint size); -typedef void (__LZO_CDECL *lzo_free_func_t) - (lzo_callback_p self, lzo_voidp ptr); +typedef lzo_voidp(__LZO_CDECL* lzo_alloc_func_t) +(lzo_callback_p self, lzo_uint items, lzo_uint size); +typedef void (__LZO_CDECL* lzo_free_func_t) +(lzo_callback_p self, lzo_voidp ptr); /* a progress indicator callback function */ -typedef void (__LZO_CDECL *lzo_progress_func_t) - (lzo_callback_p, lzo_uint, lzo_uint, int); +typedef void (__LZO_CDECL* lzo_progress_func_t) +(lzo_callback_p, lzo_uint, lzo_uint, int); struct lzo_callback_t { @@ -337,38 +337,47 @@ struct lzo_callback_t (int)sizeof(long),(int)sizeof(lzo_uint32_t),(int)sizeof(lzo_uint),\ (int)lzo_sizeof_dict_t,(int)sizeof(char *),(int)sizeof(lzo_voidp),\ (int)sizeof(lzo_callback_t)) -LZO_EXTERN(int) __lzo_init_v2(unsigned,int,int,int,int,int,int,int,int,int); +LZO_EXTERN(int) __lzo_init_v2(unsigned, int, int, int, int, int, int, int, int, int); /* version functions (useful for shared libraries) */ LZO_EXTERN(unsigned) lzo_version(void); -LZO_EXTERN(const char *) lzo_version_string(void); -LZO_EXTERN(const char *) lzo_version_date(void); +LZO_EXTERN(const char*) lzo_version_string(void); +LZO_EXTERN(const char*) lzo_version_date(void); LZO_EXTERN(const lzo_charp) _lzo_version_string(void); LZO_EXTERN(const lzo_charp) _lzo_version_date(void); /* string functions */ LZO_EXTERN(int) - lzo_memcmp(const lzo_voidp a, const lzo_voidp b, lzo_uint len); +lzo_memcmp(const lzo_voidp a, const lzo_voidp b, lzo_uint len); LZO_EXTERN(lzo_voidp) - lzo_memcpy(lzo_voidp dst, const lzo_voidp src, lzo_uint len); +lzo_memcpy(lzo_voidp dst, const lzo_voidp src, lzo_uint len); LZO_EXTERN(lzo_voidp) - lzo_memmove(lzo_voidp dst, const lzo_voidp src, lzo_uint len); +lzo_memmove(lzo_voidp dst, const lzo_voidp src, lzo_uint len); LZO_EXTERN(lzo_voidp) - lzo_memset(lzo_voidp buf, int c, lzo_uint len); +lzo_memset(lzo_voidp buf, int c, lzo_uint len); /* checksum functions */ LZO_EXTERN(lzo_uint32_t) - lzo_adler32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len); +lzo_adler32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len); LZO_EXTERN(lzo_uint32_t) - lzo_crc32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len); +lzo_crc32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len); LZO_EXTERN(const lzo_uint32_tp) - lzo_get_crc32_table(void); +lzo_get_crc32_table(void); /* misc. */ LZO_EXTERN(int) _lzo_config_check(void); -typedef union { - lzo_voidp a00; lzo_bytep a01; lzo_uint a02; lzo_xint a03; lzo_uintptr_t a04; - void *a05; unsigned char *a06; unsigned long a07; size_t a08; ptrdiff_t a09; +typedef union +{ + lzo_voidp a00; + lzo_bytep a01; + lzo_uint a02; + lzo_xint a03; + lzo_uintptr_t a04; + void* a05; + unsigned char* a06; + unsigned long a07; + size_t a08; + ptrdiff_t a09; #if defined(lzo_int64_t) lzo_uint64_t a10; #endif diff --git a/extern/lzo/include/lzo/lzodefs.h b/extern/lzo/include/lzo/lzodefs.h index 1535c1e..21f75ad 100644 --- a/extern/lzo/include/lzo/lzodefs.h +++ b/extern/lzo/include/lzo/lzodefs.h @@ -1114,21 +1114,21 @@ extern "C" { #endif #if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0200)) - extern void __near __cdecl _AHSHIFT(void); +extern void __near __cdecl _AHSHIFT(void); # define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) #elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) - extern void __near __cdecl _AHSHIFT(void); +extern void __near __cdecl _AHSHIFT(void); # define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) #elif (LZO_CC_MSC || LZO_CC_TOPSPEEDC) - extern void __near __cdecl _AHSHIFT(void); +extern void __near __cdecl _AHSHIFT(void); # define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) #elif (LZO_CC_TURBOC && (__TURBOC__ >= 0x0295)) - extern void __near __cdecl _AHSHIFT(void); +extern void __near __cdecl _AHSHIFT(void); # define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT) #elif ((LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_TURBOC) && LZO_OS_DOS16) # define LZO_MM_AHSHIFT 12 #elif (LZO_CC_WATCOMC) - extern unsigned char _HShift; +extern unsigned char _HShift; # define LZO_MM_AHSHIFT ((unsigned) _HShift) #else # error "FIXME - implement LZO_MM_AHSHIFT" @@ -2317,7 +2317,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(long) == 8) #if !defined(LZO_SIZEOF_VOID_P) # define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG #endif -LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_VOID_P == sizeof(void *)) +LZO_COMPILE_TIME_ASSERT_HEADER(LZO_SIZEOF_VOID_P == sizeof(void*)) #if !defined(LZO_SIZEOF_SIZE_T) #if (LZO_ARCH_I086 || LZO_ARCH_M16C) # define LZO_SIZEOF_SIZE_T 2 @@ -2741,8 +2741,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; # define lzo_uint16e_t unsigned short int # define LZO_TYPEOF_LZO_INT16E_T LZO_TYPEOF_SHORT #elif 1 && !(LZO_CFG_TYPE_NO_MODE_HI) && (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x025f00ul) || LZO_CC_LLVM) - typedef int lzo_int16e_hi_t__ __attribute__((__mode__(__HI__))); - typedef unsigned int lzo_uint16e_hi_t__ __attribute__((__mode__(__HI__))); +typedef int lzo_int16e_hi_t__ __attribute__((__mode__(__HI__))); +typedef unsigned int lzo_uint16e_hi_t__ __attribute__((__mode__(__HI__))); # define lzo_int16e_t lzo_int16e_hi_t__ # define lzo_uint16e_t lzo_uint16e_hi_t__ # define LZO_TYPEOF_LZO_INT16E_T LZO_TYPEOF___MODE_HI @@ -2755,8 +2755,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; #endif #if defined(lzo_int16e_t) # define LZO_SIZEOF_LZO_INT16E_T 2 - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int16e_t) == 2) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int16e_t) == LZO_SIZEOF_LZO_INT16E_T) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int16e_t) == 2) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int16e_t) == LZO_SIZEOF_LZO_INT16E_T) #endif #if !defined(lzo_int32e_t) #if (LZO_SIZEOF_LONG == 4) @@ -2776,14 +2776,14 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; # define lzo_uint32e_t lzo_ullong_t # define LZO_TYPEOF_LZO_INT32E_T LZO_TYPEOF_LONG_LONG #elif 1 && !(LZO_CFG_TYPE_NO_MODE_SI) && (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x025f00ul) || LZO_CC_LLVM) && (__INT_MAX__+0 > 2147483647L) - typedef int lzo_int32e_si_t__ __attribute__((__mode__(__SI__))); - typedef unsigned int lzo_uint32e_si_t__ __attribute__((__mode__(__SI__))); +typedef int lzo_int32e_si_t__ __attribute__((__mode__(__SI__))); +typedef unsigned int lzo_uint32e_si_t__ __attribute__((__mode__(__SI__))); # define lzo_int32e_t lzo_int32e_si_t__ # define lzo_uint32e_t lzo_uint32e_si_t__ # define LZO_TYPEOF_LZO_INT32E_T LZO_TYPEOF___MODE_SI #elif 1 && !(LZO_CFG_TYPE_NO_MODE_SI) && (LZO_CC_GNUC >= 0x025f00ul) && defined(__AVR__) && (__LONG_MAX__+0 == 32767L) - typedef int lzo_int32e_si_t__ __attribute__((__mode__(__SI__))); - typedef unsigned int lzo_uint32e_si_t__ __attribute__((__mode__(__SI__))); +typedef int lzo_int32e_si_t__ __attribute__((__mode__(__SI__))); +typedef unsigned int lzo_uint32e_si_t__ __attribute__((__mode__(__SI__))); # define lzo_int32e_t lzo_int32e_si_t__ # define lzo_uint32e_t lzo_uint32e_si_t__ # define LZO_INT32_C(c) (c##LL) @@ -2798,8 +2798,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; #endif #if defined(lzo_int32e_t) # define LZO_SIZEOF_LZO_INT32E_T 4 - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32e_t) == 4) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32e_t) == LZO_SIZEOF_LZO_INT32E_T) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32e_t) == 4) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32e_t) == LZO_SIZEOF_LZO_INT32E_T) #endif #if !defined(lzo_int64e_t) #if (LZO_SIZEOF___INT64 == 8) @@ -2845,8 +2845,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; #endif #if defined(lzo_int64e_t) # define LZO_SIZEOF_LZO_INT64E_T 8 - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64e_t) == 8) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64e_t) == LZO_SIZEOF_LZO_INT64E_T) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64e_t) == 8) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64e_t) == LZO_SIZEOF_LZO_INT64E_T) #endif #if !defined(lzo_int32l_t) #if defined(lzo_int32e_t) @@ -2869,8 +2869,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; #endif #endif #if 1 - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32l_t) >= 4) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32l_t) == LZO_SIZEOF_LZO_INT32L_T) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32l_t) >= 4) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32l_t) == LZO_SIZEOF_LZO_INT32L_T) #endif #if !defined(lzo_int64l_t) #if defined(lzo_int64e_t) @@ -2882,8 +2882,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; #endif #endif #if defined(lzo_int64l_t) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64l_t) >= 8) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64l_t) == LZO_SIZEOF_LZO_INT64L_T) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64l_t) >= 8) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64l_t) == LZO_SIZEOF_LZO_INT64L_T) #endif #if !defined(lzo_int32f_t) #if (LZO_SIZEOF_SIZE_T >= 8) @@ -2899,8 +2899,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; #endif #endif #if 1 - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32f_t) >= 4) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32f_t) == LZO_SIZEOF_LZO_INT32F_T) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32f_t) >= 4) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int32f_t) == LZO_SIZEOF_LZO_INT32F_T) #endif #if !defined(lzo_int64f_t) #if defined(lzo_int64l_t) @@ -2912,21 +2912,21 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; #endif #endif #if defined(lzo_int64f_t) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64f_t) >= 8) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64f_t) == LZO_SIZEOF_LZO_INT64F_T) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64f_t) >= 8) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_int64f_t) == LZO_SIZEOF_LZO_INT64F_T) #endif #if !defined(lzo_intptr_t) #if 1 && (LZO_OS_OS400 && (LZO_SIZEOF_VOID_P == 16)) # define __LZO_INTPTR_T_IS_POINTER 1 - typedef char * lzo_intptr_t; - typedef char * lzo_uintptr_t; +typedef char* lzo_intptr_t; +typedef char* lzo_uintptr_t; # define lzo_intptr_t lzo_intptr_t # define lzo_uintptr_t lzo_uintptr_t # define LZO_SIZEOF_LZO_INTPTR_T LZO_SIZEOF_VOID_P # define LZO_TYPEOF_LZO_INTPTR_T LZO_TYPEOF_CHAR_P #elif (LZO_CC_MSC && (_MSC_VER >= 1300) && (LZO_SIZEOF_VOID_P == 4) && (LZO_SIZEOF_INT == 4)) - typedef __w64 int lzo_intptr_t; - typedef __w64 unsigned int lzo_uintptr_t; +typedef __w64 int lzo_intptr_t; +typedef __w64 unsigned int lzo_uintptr_t; # define lzo_intptr_t lzo_intptr_t # define lzo_uintptr_t lzo_uintptr_t # define LZO_SIZEOF_LZO_INTPTR_T LZO_SIZEOF_INT @@ -2956,8 +2956,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; #endif #endif #if 1 - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_intptr_t) >= sizeof(void *)) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_intptr_t) == sizeof(lzo_uintptr_t)) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_intptr_t) >= sizeof(void*)) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_intptr_t) == sizeof(lzo_uintptr_t)) #endif #if !defined(lzo_word_t) #if defined(LZO_WORDSIZE) && (LZO_WORDSIZE+0 > 0) @@ -2993,8 +2993,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; # define LZO_TYPEOF_LZO_WORD_T LZO_SIZEOF_LZO_INT64L_T #elif (LZO_ARCH_SPU) && (LZO_CC_GNUC) #if 0 - typedef unsigned lzo_word_t __attribute__((__mode__(__V16QI__))); - typedef int lzo_sword_t __attribute__((__mode__(__V16QI__))); +typedef unsigned lzo_word_t __attribute__((__mode__(__V16QI__))); +typedef int lzo_sword_t __attribute__((__mode__(__V16QI__))); # define lzo_word_t lzo_word_t # define lzo_sword_t lzo_sword_t # define LZO_SIZEOF_LZO_WORD_T 16 @@ -3006,8 +3006,8 @@ __lzo_gnuc_extension__ typedef unsigned long long lzo_ullong_t__; #endif #endif #if 1 && defined(lzo_word_t) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_word_t) == LZO_WORDSIZE) - LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_sword_t) == LZO_WORDSIZE) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_word_t) == LZO_WORDSIZE) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_sword_t) == LZO_WORDSIZE) #endif #if 1 #define lzo_int8_t signed char diff --git a/extern/lzo/src/compr1b.h b/extern/lzo/src/compr1b.h index 8c23fe8..c1f0f54 100644 --- a/extern/lzo/src/compr1b.h +++ b/extern/lzo/src/compr1b.h @@ -57,11 +57,11 @@ const lzo_compress_t LZO_COMPRESS_FUNC = do_compress; LZO_PUBLIC(int) -LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +LZO_COMPRESS(const lzo_bytep in, lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { - return _lzo1b_do_compress(in,in_len,out,out_len,wrkmem,do_compress); + return _lzo1b_do_compress(in, in_len, out, out_len, wrkmem, do_compress); } diff --git a/extern/lzo/src/compr1c.h b/extern/lzo/src/compr1c.h index b5e8fb3..b13dd03 100644 --- a/extern/lzo/src/compr1c.h +++ b/extern/lzo/src/compr1c.h @@ -57,11 +57,11 @@ const lzo_compress_t LZO_COMPRESS_FUNC = do_compress; LZO_PUBLIC(int) -LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +LZO_COMPRESS(const lzo_bytep in, lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { - return _lzo1c_do_compress(in,in_len,out,out_len,wrkmem,do_compress); + return _lzo1c_do_compress(in, in_len, out, out_len, wrkmem, do_compress); } diff --git a/extern/lzo/src/lzo1.c b/extern/lzo/src/lzo1.c index 96c159e..993a4e7 100644 --- a/extern/lzo/src/lzo1.c +++ b/extern/lzo/src/lzo1.c @@ -153,15 +153,17 @@ RBITS | MBITS MIN THR. MSIZE MAXS MINL MAXL MAXO R0MAX R0FAST // get algorithm info, return memory required for compression ************************************************************************/ -LZO_EXTERN(lzo_uint) lzo1_info ( int *rbits, int *clevel ); +LZO_EXTERN(lzo_uint) lzo1_info(int* rbits, int* clevel); LZO_PUBLIC(lzo_uint) -lzo1_info ( int *rbits, int *clevel ) +lzo1_info(int* rbits, int* clevel) { if (rbits) *rbits = RBITS; + if (clevel) *clevel = CLEVEL; + return D_SIZE * lzo_sizeof(lzo_bytep); } @@ -190,9 +192,9 @@ lzo1_info ( int *rbits, int *clevel ) ************************************************************************/ LZO_PUBLIC(int) -lzo1_decompress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +lzo1_decompress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { lzo_bytep op; const lzo_bytep ip; @@ -203,6 +205,7 @@ lzo1_decompress ( const lzo_bytep in , lzo_uint in_len, op = out; ip = in; + while (ip < ip_end) { t = *ip++; /* get marker */ @@ -212,9 +215,11 @@ lzo1_decompress ( const lzo_bytep in , lzo_uint in_len, if (t == 0) /* a R0 literal run */ { t = *ip++; + if (t >= R0FAST - R0MIN) /* a long R0 run */ { t -= R0FAST - R0MIN; + if (t == 0) t = R0FAST; else @@ -224,23 +229,30 @@ lzo1_decompress ( const lzo_bytep in , lzo_uint in_len, #else /* help the optimizer */ lzo_uint tt = 256; - do tt <<= 1; while (--t > 0); + + do tt <<= 1; + + while (--t > 0); + t = tt; #endif } - MEMCPY8_DS(op,ip,t); + + MEMCPY8_DS(op, ip, t); continue; } + t += R0MIN; } - MEMCPY_DS(op,ip,t); + + MEMCPY_DS(op, ip, t); } else /* a match */ { lzo_uint tt; /* get match offset */ const lzo_bytep m_pos = op - 1; - m_pos -= (lzo_uint)(t & OMASK) | (((lzo_uint) *ip++) << OBITS); + m_pos -= (lzo_uint)(t & OMASK) | (((lzo_uint) * ip++) << OBITS); /* get match len */ if (t >= ((MSIZE - 1) << OBITS)) /* all m-bits set */ @@ -253,7 +265,7 @@ lzo1_decompress ( const lzo_bytep in , lzo_uint in_len, /* a half unrolled loop */ *op++ = *m_pos++; *op++ = *m_pos++; - MEMCPY_DS(op,m_pos,tt); + MEMCPY_DS(op, m_pos, tt); } } @@ -261,7 +273,7 @@ lzo1_decompress ( const lzo_bytep in , lzo_uint in_len, /* the next line is the only check in the decompressor ! */ return (ip == ip_end ? LZO_E_OK : - (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); + (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); } @@ -282,26 +294,33 @@ store_run(lzo_bytep op, const lzo_bytep ii, lzo_uint r_len) if (r_len >= 512) { unsigned r_bits = 7; /* 256 << 7 == 32768 */ - do { + + do + { while (r_len >= (256u << r_bits)) { r_len -= (256u << r_bits); - *op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits); + *op++ = 0; + *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits); MEMCPY8_DS(op, ii, (256u << r_bits)); } - } while (--r_bits > 0); + } + while (--r_bits > 0); } + while (r_len >= R0FAST) { r_len -= R0FAST; - *op++ = 0; *op++ = R0FAST - R0MIN; + *op++ = 0; + *op++ = R0FAST - R0MIN; MEMCPY8_DS(op, ii, R0FAST); } if (r_len >= R0MIN) { /* code a short R0 run */ - *op++ = 0; *op++ = LZO_BYTE(r_len - R0MIN); + *op++ = 0; + *op++ = LZO_BYTE(r_len - R0MIN); MEMCPY_DS(op, ii, r_len); } else if (r_len > 0) @@ -326,9 +345,9 @@ store_run(lzo_bytep op, const lzo_bytep ii, lzo_uint r_len) ************************************************************************/ static int -do_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +do_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { const lzo_bytep ip; #if defined(__LZO_HASH_INCREMENTAL) @@ -336,8 +355,8 @@ do_compress ( const lzo_bytep in , lzo_uint in_len, #endif lzo_bytep op; const lzo_bytep m_pos; - const lzo_bytep const ip_end = in+in_len - DVAL_LEN - MIN_MATCH_LONG; - const lzo_bytep const in_end = in+in_len - DVAL_LEN; + const lzo_bytep const ip_end = in + in_len - DVAL_LEN - MIN_MATCH_LONG; + const lzo_bytep const in_end = in + in_len - DVAL_LEN; const lzo_bytep ii; lzo_dict_p const dict = (lzo_dict_p) wrkmem; @@ -348,60 +367,72 @@ do_compress ( const lzo_bytep in , lzo_uint in_len, op = out; ip = in; ii = ip; /* point to start of literal run */ + if (in_len <= MIN_MATCH_LONG + DVAL_LEN + 1) goto the_end; /* init dictionary */ #if (LZO_DETERMINISTIC) - BZERO8_PTR(wrkmem,sizeof(lzo_dict_t),D_SIZE); + BZERO8_PTR(wrkmem, sizeof(lzo_dict_t), D_SIZE); #endif - DVAL_FIRST(dv,ip); - UPDATE_D(dict,0,dv,ip,in); + DVAL_FIRST(dv, ip); + UPDATE_D(dict, 0, dv, ip, in); ip++; - DVAL_NEXT(dv,ip); + DVAL_NEXT(dv, ip); - do { + do + { LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0); lzo_uint dindex; - DINDEX1(dindex,ip); - GINDEX(m_pos,m_off,dict,dindex,in); - if (LZO_CHECK_MPOS(m_pos,m_off,in,ip,MAX_OFFSET)) + DINDEX1(dindex, ip); + GINDEX(m_pos, m_off, dict, dindex, in); + + if (LZO_CHECK_MPOS(m_pos, m_off, in, ip, MAX_OFFSET)) goto literal; + if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2]) goto match; - DINDEX2(dindex,ip); - GINDEX(m_pos,m_off,dict,dindex,in); - if (LZO_CHECK_MPOS(m_pos,m_off,in,ip,MAX_OFFSET)) + + DINDEX2(dindex, ip); + GINDEX(m_pos, m_off, dict, dindex, in); + + if (LZO_CHECK_MPOS(m_pos, m_off, in, ip, MAX_OFFSET)) goto literal; + if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2]) goto match; + goto literal; literal: - UPDATE_I(dict,0,dindex,ip,in); + UPDATE_I(dict, 0, dindex, ip, in); + if (++ip >= ip_end) break; + continue; match: - UPDATE_I(dict,0,dindex,ip,in); + UPDATE_I(dict, 0, dindex, ip, in); #if !defined(NDEBUG) && (LZO_DICT_USE_PTR) m_pos_sav = m_pos; #endif m_pos += 3; { - /* we have found a match (of at least length 3) */ + /* we have found a match (of at least length 3) */ #if !defined(NDEBUG) && !(LZO_DICT_USE_PTR) assert((m_pos_sav = ip - m_off) == (m_pos - 3)); #endif + /* 1) store the current literal run */ - if (pd(ip,ii) > 0) + if (pd(ip, ii) > 0) { - lzo_uint t = pd(ip,ii); + lzo_uint t = pd(ip, ii); #if 1 + /* OPTIMIZED: inline the copying of a short run */ if (t < R0MIN) { @@ -410,7 +441,7 @@ match: } else #endif - op = store_run(op,ii,t); + op = store_run(op, ii, t); } /* 2a) compute match len */ @@ -427,33 +458,34 @@ match: #define PS *m_pos++ != *ip++ #if (MIN_MATCH_LONG - MIN_MATCH == 2) /* MBITS == 2 */ + if (PS || PS) #elif (MIN_MATCH_LONG - MIN_MATCH == 6) /* MBITS == 3 */ if (PS || PS || PS || PS || PS || PS) #elif (MIN_MATCH_LONG - MIN_MATCH == 14) /* MBITS == 4 */ if (PS || PS || PS || PS || PS || PS || PS || - PS || PS || PS || PS || PS || PS || PS) + PS || PS || PS || PS || PS || PS || PS) #elif (MIN_MATCH_LONG - MIN_MATCH == 30) /* MBITS == 5 */ if (PS || PS || PS || PS || PS || PS || PS || PS || - PS || PS || PS || PS || PS || PS || PS || PS || - PS || PS || PS || PS || PS || PS || PS || PS || - PS || PS || PS || PS || PS || PS) + PS || PS || PS || PS || PS || PS || PS || PS || + PS || PS || PS || PS || PS || PS || PS || PS || + PS || PS || PS || PS || PS || PS) #else # error "MBITS not yet implemented" #endif { lzo_uint m_len; - /* 2b) code a short match */ - assert(pd(ip,m_pos) == m_off); + /* 2b) code a short match */ + assert(pd(ip, m_pos) == m_off); --ip; /* ran one too far, point back to non-match */ m_len = pd(ip, ii); - assert(m_len >= MIN_MATCH_SHORT); - assert(m_len <= MAX_MATCH_SHORT); - assert(m_off > 0); - assert(m_off <= MAX_OFFSET); - assert(ii-m_off == m_pos_sav); - assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0); + assert(m_len >= MIN_MATCH_SHORT); + assert(m_len <= MAX_MATCH_SHORT); + assert(m_off > 0); + assert(m_off <= MAX_OFFSET); + assert(ii - m_off == m_pos_sav); + assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0); --m_off; /* code short match len + low offset bits */ *op++ = LZO_BYTE(((m_len - THRESHOLD) << OBITS) | @@ -462,41 +494,45 @@ match: *op++ = LZO_BYTE(m_off >> OBITS); - /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ + /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ #define SI /* nothing */ #define DI ++ii; DVAL_NEXT(dv,ii); UPDATE_D(dict,0,dv,ii,in); #define XI assert(ii < ip); ii = ip; DVAL_FIRST(dv,(ip)); #if (CLEVEL == 9) || (CLEVEL >= 7 && MBITS <= 4) || (CLEVEL >= 5 && MBITS <= 3) - /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ + /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ ++ii; - do { - DVAL_NEXT(dv,ii); - UPDATE_D(dict,0,dv,ii,in); - } while (++ii < ip); - DVAL_NEXT(dv,ii); + + do + { + DVAL_NEXT(dv, ii); + UPDATE_D(dict, 0, dv, ii, in); + } + while (++ii < ip); + + DVAL_NEXT(dv, ii); assert(ii == ip); - DVAL_ASSERT(dv,ip); + DVAL_ASSERT(dv, ip); #elif (CLEVEL >= 3) SI DI DI XI #elif (CLEVEL >= 2) SI DI XI #else - XI + XI #endif } else { - /* we've found a long match - see how far we can still go */ + /* we've found a long match - see how far we can still go */ const lzo_bytep end; lzo_uint m_len; assert(ip <= in_end); assert(ii == ip - MIN_MATCH_LONG); - if (pd(in_end,ip) <= (MAX_MATCH_LONG - MIN_MATCH_LONG)) + if (pd(in_end, ip) <= (MAX_MATCH_LONG - MIN_MATCH_LONG)) end = in_end; else { @@ -506,17 +542,18 @@ match: while (ip < end && *m_pos == *ip) m_pos++, ip++; + assert(ip <= in_end); - /* 2b) code the long match */ + /* 2b) code the long match */ m_len = pd(ip, ii); - assert(m_len >= MIN_MATCH_LONG); - assert(m_len <= MAX_MATCH_LONG); - assert(m_off > 0); - assert(m_off <= MAX_OFFSET); - assert(ii-m_off == m_pos_sav); - assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0); - assert(pd(ip,m_pos) == m_off); + assert(m_len >= MIN_MATCH_LONG); + assert(m_len <= MAX_MATCH_LONG); + assert(m_off > 0); + assert(m_off <= MAX_OFFSET); + assert(ii - m_off == m_pos_sav); + assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0); + assert(pd(ip, m_pos) == m_off); --m_off; /* code long match flag + low offset bits */ *op++ = LZO_BYTE(((MSIZE - 1) << OBITS) | (m_off & OMASK)); @@ -526,18 +563,22 @@ match: *op++ = LZO_BYTE(m_len - MIN_MATCH_LONG); - /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ + /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ #if (CLEVEL == 9) - /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ - /* This is not recommended because it is slow. */ + /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ + /* This is not recommended because it is slow. */ ++ii; - do { - DVAL_NEXT(dv,ii); - UPDATE_D(dict,0,dv,ii,in); - } while (++ii < ip); - DVAL_NEXT(dv,ii); + + do + { + DVAL_NEXT(dv, ii); + UPDATE_D(dict, 0, dv, ii, in); + } + while (++ii < ip); + + DVAL_NEXT(dv, ii); assert(ii == ip); - DVAL_ASSERT(dv,ip); + DVAL_ASSERT(dv, ip); #elif (CLEVEL >= 8) SI DI DI DI DI DI DI DI DI XI #elif (CLEVEL >= 7) @@ -553,14 +594,15 @@ match: #elif (CLEVEL >= 2) SI DI XI #else - XI + XI #endif } /* ii now points to the start of next literal run */ assert(ii == ip); } - } while (ip < ip_end); + } + while (ip < ip_end); @@ -569,6 +611,7 @@ the_end: #if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE) + /* return -1 if op == out to indicate that we * couldn't compress and didn't copy anything. */ @@ -577,12 +620,13 @@ the_end: *out_len = 0; return LZO_E_NOT_COMPRESSIBLE; } + #endif /* store the final literal run */ - if (pd(in_end+DVAL_LEN,ii) > 0) - op = store_run(op,ii,pd(in_end+DVAL_LEN,ii)); + if (pd(in_end + DVAL_LEN, ii) > 0) + op = store_run(op, ii, pd(in_end + DVAL_LEN, ii)); *out_len = pd(op, out); return 0; /* compression went ok */ @@ -594,9 +638,9 @@ the_end: ************************************************************************/ LZO_PUBLIC(int) -lzo1_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +lzo1_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { int r = LZO_E_OK; @@ -608,11 +652,11 @@ lzo1_compress ( const lzo_bytep in , lzo_uint in_len, #if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE) r = LZO_E_NOT_COMPRESSIBLE; #else - *out_len = pd(store_run(out,in,in_len), out); + *out_len = pd(store_run(out, in, in_len), out); #endif } else - r = do_compress(in,in_len,out,out_len,wrkmem); + r = do_compress(in, in_len, out, out_len, wrkmem); return r; } diff --git a/extern/lzo/src/lzo1_99.c b/extern/lzo/src/lzo1_99.c index 506add2..0d2d014 100644 --- a/extern/lzo/src/lzo1_99.c +++ b/extern/lzo/src/lzo1_99.c @@ -46,10 +46,10 @@ ************************************************************************/ static int -_lzo1_do_compress ( const lzo_bytep in, lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_compress_t func ) +_lzo1_do_compress(const lzo_bytep in, lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_compress_t func) { int r; @@ -65,12 +65,12 @@ _lzo1_do_compress ( const lzo_bytep in, lzo_uint in_len, *out_len = 0; r = LZO_E_NOT_COMPRESSIBLE; #else - *out_len = pd(STORE_RUN(out,in,in_len), out); + *out_len = pd(STORE_RUN(out, in, in_len), out); r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR; #endif } else - r = func(in,in_len,out,out_len,wrkmem); + r = func(in, in_len, out, out_len, wrkmem); return r; } @@ -105,11 +105,11 @@ _lzo1_do_compress ( const lzo_bytep in, lzo_uint in_len, ************************************************************************/ LZO_PUBLIC(int) -LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +LZO_COMPRESS(const lzo_bytep in, lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { - return _lzo1_do_compress(in,in_len,out,out_len,wrkmem,do_compress); + return _lzo1_do_compress(in, in_len, out, out_len, wrkmem, do_compress); } diff --git a/extern/lzo/src/lzo1_d.ch b/extern/lzo/src/lzo1_d.ch index 2e15a4a..b1067a5 100644 --- a/extern/lzo/src/lzo1_d.ch +++ b/extern/lzo/src/lzo1_d.ch @@ -105,7 +105,7 @@ #if !defined(LZO_EOF_CODE) && !defined(TEST_IP) - /* if we have no EOF code, we have to test for the end of the input */ +/* if we have no EOF code, we have to test for the end of the input */ # define TEST_IP (ip < ip_end) #endif diff --git a/extern/lzo/src/lzo1a.c b/extern/lzo/src/lzo1a.c index 1af4dba..b6e9ce3 100644 --- a/extern/lzo/src/lzo1a.c +++ b/extern/lzo/src/lzo1a.c @@ -91,8 +91,8 @@ #if (LZO_COLLECT_STATS) - static lzo1a_stats_t lzo_statistics; - lzo1a_stats_t *lzo1a_stats = &lzo_statistics; +static lzo1a_stats_t lzo_statistics; +lzo1a_stats_t* lzo1a_stats = &lzo_statistics; # define lzo_stats lzo1a_stats #endif @@ -101,15 +101,17 @@ // get algorithm info, return memory required for compression ************************************************************************/ -LZO_EXTERN(lzo_uint) lzo1a_info ( int *rbits, int *clevel ); +LZO_EXTERN(lzo_uint) lzo1a_info(int* rbits, int* clevel); LZO_PUBLIC(lzo_uint) -lzo1a_info ( int *rbits, int *clevel ) +lzo1a_info(int* rbits, int* clevel) { if (rbits) *rbits = RBITS; + if (clevel) *clevel = CLEVEL; + return D_SIZE * lzo_sizeof(lzo_bytep); } @@ -121,9 +123,9 @@ lzo1a_info ( int *rbits, int *clevel ) ************************************************************************/ LZO_PUBLIC(int) -lzo1a_decompress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +lzo1a_decompress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { lzo_bytep op; const lzo_bytep ip; @@ -135,6 +137,7 @@ lzo1a_decompress ( const lzo_bytep in , lzo_uint in_len, op = out; ip = in; + while (ip < ip_end) { t = *ip++; /* get marker */ @@ -143,9 +146,11 @@ lzo1a_decompress ( const lzo_bytep in , lzo_uint in_len, if (t == 0) /* a R0 literal run */ { t = *ip++; + if (t >= R0FAST - R0MIN) /* a long R0 run */ { t -= R0FAST - R0MIN; + if (t == 0) t = R0FAST; else @@ -155,33 +160,41 @@ lzo1a_decompress ( const lzo_bytep in , lzo_uint in_len, #else /* help the optimizer */ lzo_uint tt = 256; - do tt <<= 1; while (--t > 0); + + do tt <<= 1; + + while (--t > 0); + t = tt; #endif } - MEMCPY8_DS(op,ip,t); + + MEMCPY8_DS(op, ip, t); continue; } + t += R0MIN; goto literal; } else if (t < R0MIN) /* a short literal run */ { literal: - MEMCPY_DS(op,ip,t); + MEMCPY_DS(op, ip, t); - /* after a literal a match must follow */ + /* after a literal a match must follow */ while (ip < ip_end) { t = *ip++; /* get R1 marker */ + if (t >= R0MIN) goto match; - /* R1 match - a context sensitive 3 byte match + 1 byte literal */ + /* R1 match - a context sensitive 3 byte match + 1 byte literal */ assert((t & OMASK) == t); m_pos = op - MIN_OFFSET; - m_pos -= t | (((lzo_uint) *ip++) << OBITS); - assert(m_pos >= out); assert(m_pos < op); + m_pos -= t | (((lzo_uint) * ip++) << OBITS); + assert(m_pos >= out); + assert(m_pos < op); *op++ = m_pos[0]; *op++ = m_pos[1]; *op++ = m_pos[2]; @@ -193,8 +206,9 @@ literal: match: /* get match offset */ m_pos = op - MIN_OFFSET; - m_pos -= (t & OMASK) | (((lzo_uint) *ip++) << OBITS); - assert(m_pos >= out); assert(m_pos < op); + m_pos -= (t & OMASK) | (((lzo_uint) * ip++) << OBITS); + assert(m_pos >= out); + assert(m_pos < op); /* get match len */ if (t < ((MSIZE - 1) << OBITS)) /* a short match */ @@ -202,7 +216,7 @@ match: t >>= OBITS; *op++ = *m_pos++; *op++ = *m_pos++; - MEMCPY_DS(op,m_pos,t); + MEMCPY_DS(op, m_pos, t); } else /* a long match */ { @@ -213,13 +227,16 @@ match: #endif *op++ = *m_pos++; *op++ = *m_pos++; - MEMCPY_DS(op,m_pos,t); + MEMCPY_DS(op, m_pos, t); #if (LBITS < 8) /* a very short literal following a long match */ t = ip[-1] >> LBITS; + if (t) do - *op++ = *ip++; - while (--t); + *op++ = *ip++; + + while (--t); + #endif } } @@ -229,7 +246,7 @@ match: /* the next line is the only check in the decompressor */ return (ip == ip_end ? LZO_E_OK : - (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); + (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); } @@ -243,9 +260,9 @@ match: #include "lzo1a_cr.ch" static int -do_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +do_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { const lzo_bytep ip; #if defined(__LZO_HASH_INCREMENTAL) @@ -253,8 +270,8 @@ do_compress ( const lzo_bytep in , lzo_uint in_len, #endif const lzo_bytep m_pos; lzo_bytep op; - const lzo_bytep const ip_end = in+in_len - DVAL_LEN - MIN_MATCH_LONG; - const lzo_bytep const in_end = in+in_len - DVAL_LEN; + const lzo_bytep const ip_end = in + in_len - DVAL_LEN - MIN_MATCH_LONG; + const lzo_bytep const in_end = in + in_len - DVAL_LEN; const lzo_bytep ii; lzo_dict_p const dict = (lzo_dict_p) wrkmem; const lzo_bytep r1 = ip_end; /* pointer for R1 match (none yet) */ @@ -272,45 +289,56 @@ do_compress ( const lzo_bytep in , lzo_uint in_len, /* init dictionary */ #if (LZO_DETERMINISTIC) - BZERO8_PTR(wrkmem,sizeof(lzo_dict_t),D_SIZE); + BZERO8_PTR(wrkmem, sizeof(lzo_dict_t), D_SIZE); #endif - DVAL_FIRST(dv,ip); UPDATE_D(dict,0,dv,ip,in); ip++; - DVAL_NEXT(dv,ip); + DVAL_FIRST(dv, ip); + UPDATE_D(dict, 0, dv, ip, in); + ip++; + DVAL_NEXT(dv, ip); - do { + do + { LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0); lzo_uint dindex; - DINDEX1(dindex,ip); - GINDEX(m_pos,m_off,dict,dindex,in); - if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,MAX_OFFSET)) + DINDEX1(dindex, ip); + GINDEX(m_pos, m_off, dict, dindex, in); + + if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, MAX_OFFSET)) goto literal; + if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2]) goto match; - DINDEX2(dindex,ip); - GINDEX(m_pos,m_off,dict,dindex,in); - if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,MAX_OFFSET)) + + DINDEX2(dindex, ip); + GINDEX(m_pos, m_off, dict, dindex, in); + + if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, MAX_OFFSET)) goto literal; + if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2]) goto match; + goto literal; literal: - UPDATE_I(dict,0,dindex,ip,in); + UPDATE_I(dict, 0, dindex, ip, in); + if (++ip >= ip_end) break; + continue; match: - UPDATE_I(dict,0,dindex,ip,in); + UPDATE_I(dict, 0, dindex, ip, in); #if !defined(NDEBUG) && (LZO_DICT_USE_PTR) assert(m_pos == NULL || m_pos >= in); m_pos_sav = m_pos; #endif m_pos += 3; { - /* we have found a match (of at least length 3) */ + /* we have found a match (of at least length 3) */ #if !defined(NDEBUG) && !(LZO_DICT_USE_PTR) assert((m_pos_sav = ip - m_off) == (m_pos - 3)); @@ -320,22 +348,22 @@ match: assert(ip < ip_end); /* 1) store the current literal run */ - if (pd(ip,ii) > 0) + if (pd(ip, ii) > 0) { - lzo_uint t = pd(ip,ii); + lzo_uint t = pd(ip, ii); if (ip - r1 == MIN_MATCH + 1) { - /* Code a context sensitive R1 match. - * This is tricky and somewhat difficult to explain: - * multiplex a literal run of length 1 into the previous - * short match of length MIN_MATCH. - * The key idea is: - * - after a short run a match MUST follow - * - therefore the value m = 000 in the mmmooooo marker is free - * - use 000ooooo to indicate a MIN_MATCH match (this - * is already coded) plus a 1 byte literal - */ + /* Code a context sensitive R1 match. + * This is tricky and somewhat difficult to explain: + * multiplex a literal run of length 1 into the previous + * short match of length MIN_MATCH. + * The key idea is: + * - after a short run a match MUST follow + * - therefore the value m = 000 in the mmmooooo marker is free + * - use 000ooooo to indicate a MIN_MATCH match (this + * is already coded) plus a 1 byte literal + */ assert(t == 1); /* modify marker byte */ assert((op[-2] >> OBITS) == (MIN_MATCH - THRESHOLD)); @@ -350,11 +378,11 @@ match: { /* inline the copying of a short run */ #if (LBITS < 8) - if (t < (1 << (8-LBITS)) && ii - im >= MIN_MATCH_LONG) + if (t < (1 << (8 - LBITS)) && ii - im >= MIN_MATCH_LONG) { - /* Code a very short literal run into the - * previous long match length byte. - */ + /* Code a very short literal run into the + * previous long match length byte. + */ LZO_STATS(lzo_stats->lit_runs_after_long_match++); LZO_STATS(lzo_stats->lit_run_after_long_match[t]++); assert(ii - im <= MAX_MATCH_LONG); @@ -376,13 +404,15 @@ match: { /* inline the copying of a short R0 run */ LZO_STATS(lzo_stats->r0short_runs++); - *op++ = 0; *op++ = LZO_BYTE(t - R0MIN); + *op++ = 0; + *op++ = LZO_BYTE(t - R0MIN); MEMCPY_DS(op, ii, t); r1 = ip; /* set new R1 pointer */ } else - op = store_run(op,ii,t); + op = store_run(op, ii, t); } + #if (LBITS < 8) im = ip; #endif @@ -402,37 +432,38 @@ match: #define PS *m_pos++ != *ip++ #if (MIN_MATCH_LONG - MIN_MATCH == 2) /* MBITS == 2 */ + if (PS || PS) #elif (MIN_MATCH_LONG - MIN_MATCH == 6) /* MBITS == 3 */ if (PS || PS || PS || PS || PS || PS) #elif (MIN_MATCH_LONG - MIN_MATCH == 14) /* MBITS == 4 */ if (PS || PS || PS || PS || PS || PS || PS || - PS || PS || PS || PS || PS || PS || PS) + PS || PS || PS || PS || PS || PS || PS) #elif (MIN_MATCH_LONG - MIN_MATCH == 30) /* MBITS == 5 */ if (PS || PS || PS || PS || PS || PS || PS || PS || - PS || PS || PS || PS || PS || PS || PS || PS || - PS || PS || PS || PS || PS || PS || PS || PS || - PS || PS || PS || PS || PS || PS) + PS || PS || PS || PS || PS || PS || PS || PS || + PS || PS || PS || PS || PS || PS || PS || PS || + PS || PS || PS || PS || PS || PS) #else # error "MBITS not yet implemented" #endif { - /* we've found a short match */ + /* we've found a short match */ lzo_uint m_len; - /* 2a) compute match parameters */ - assert(ip-m_pos == (int)m_off); + /* 2a) compute match parameters */ + assert(ip - m_pos == (int)m_off); --ip; /* ran one too far, point back to non-match */ m_len = pd(ip, ii); - assert(m_len >= MIN_MATCH_SHORT); - assert(m_len <= MAX_MATCH_SHORT); - assert(m_off >= MIN_OFFSET); - assert(m_off <= MAX_OFFSET); - assert(ii-m_off == m_pos_sav); - assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0); + assert(m_len >= MIN_MATCH_SHORT); + assert(m_len <= MAX_MATCH_SHORT); + assert(m_off >= MIN_OFFSET); + assert(m_off <= MAX_OFFSET); + assert(ii - m_off == m_pos_sav); + assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0); m_off -= MIN_OFFSET; - /* 2b) code a short match */ + /* 2b) code a short match */ /* code short match len + low offset bits */ *op++ = LZO_BYTE(((m_len - THRESHOLD) << OBITS) | (m_off & OMASK)); @@ -443,50 +474,58 @@ match: #if (LZO_COLLECT_STATS) lzo_stats->short_matches++; lzo_stats->short_match[m_len]++; + if (m_off < OSIZE) lzo_stats->short_match_offset_osize[m_len]++; + if (m_off < 256) lzo_stats->short_match_offset_256[m_len]++; + if (m_off < 1024) lzo_stats->short_match_offset_1024[m_len]++; + #endif - /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ + /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ #define SI /* nothing */ #define DI ++ii; DVAL_NEXT(dv,ii); UPDATE_D(dict,0,dv,ii,in); #define XI assert(ii < ip); ii = ip; DVAL_FIRST(dv,(ip)); #if (CLEVEL == 9) || (CLEVEL >= 7 && MBITS <= 4) || (CLEVEL >= 5 && MBITS <= 3) - /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ + /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ ++ii; - do { - DVAL_NEXT(dv,ii); - UPDATE_D(dict,0,dv,ii,in); - } while (++ii < ip); - DVAL_NEXT(dv,ii); + + do + { + DVAL_NEXT(dv, ii); + UPDATE_D(dict, 0, dv, ii, in); + } + while (++ii < ip); + + DVAL_NEXT(dv, ii); assert(ii == ip); - DVAL_ASSERT(dv,ip); + DVAL_ASSERT(dv, ip); #elif (CLEVEL >= 3) SI DI DI XI #elif (CLEVEL >= 2) SI DI XI #else - XI + XI #endif } else { - /* we've found a long match - see how far we can still go */ + /* we've found a long match - see how far we can still go */ const lzo_bytep end; lzo_uint m_len; assert(ip <= in_end); assert(ii == ip - MIN_MATCH_LONG); - if (pd(in_end,ip) <= (MAX_MATCH_LONG - MIN_MATCH_LONG)) + if (pd(in_end, ip) <= (MAX_MATCH_LONG - MIN_MATCH_LONG)) end = in_end; else { @@ -496,20 +535,21 @@ match: while (ip < end && *m_pos == *ip) m_pos++, ip++; + assert(ip <= in_end); - /* 2a) compute match parameters */ + /* 2a) compute match parameters */ m_len = pd(ip, ii); - assert(m_len >= MIN_MATCH_LONG); - assert(m_len <= MAX_MATCH_LONG); - assert(m_off >= MIN_OFFSET); - assert(m_off <= MAX_OFFSET); - assert(ii-m_off == m_pos_sav); - assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0); - assert(pd(ip,m_pos) == m_off); + assert(m_len >= MIN_MATCH_LONG); + assert(m_len <= MAX_MATCH_LONG); + assert(m_off >= MIN_OFFSET); + assert(m_off <= MAX_OFFSET); + assert(ii - m_off == m_pos_sav); + assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0); + assert(pd(ip, m_pos) == m_off); m_off -= MIN_OFFSET; - /* 2b) code the long match */ + /* 2b) code the long match */ /* code long match flag + low offset bits */ *op++ = LZO_BYTE(((MSIZE - 1) << OBITS) | (m_off & OMASK)); /* code high offset bits */ @@ -524,18 +564,22 @@ match: #endif - /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ + /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ #if (CLEVEL == 9) - /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ - /* This is not recommended because it is slow. */ + /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ + /* This is not recommended because it is slow. */ ++ii; - do { - DVAL_NEXT(dv,ii); - UPDATE_D(dict,0,dv,ii,in); - } while (++ii < ip); - DVAL_NEXT(dv,ii); + + do + { + DVAL_NEXT(dv, ii); + UPDATE_D(dict, 0, dv, ii, in); + } + while (++ii < ip); + + DVAL_NEXT(dv, ii); assert(ii == ip); - DVAL_ASSERT(dv,ip); + DVAL_ASSERT(dv, ip); #elif (CLEVEL >= 8) SI DI DI DI DI DI DI DI DI XI #elif (CLEVEL >= 7) @@ -551,7 +595,7 @@ match: #elif (CLEVEL >= 2) SI DI XI #else - XI + XI #endif } @@ -559,12 +603,14 @@ match: assert(ii == ip); } - } while (ip < ip_end); + } + while (ip < ip_end); assert(ip <= in_end); #if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE) + /* return -1 if op == out to indicate that we * couldn't compress and didn't copy anything. */ @@ -573,11 +619,12 @@ match: *out_len = 0; return LZO_E_NOT_COMPRESSIBLE; } + #endif /* store the final literal run */ - if (pd(in_end+DVAL_LEN,ii) > 0) - op = store_run(op,ii,pd(in_end+DVAL_LEN,ii)); + if (pd(in_end + DVAL_LEN, ii) > 0) + op = store_run(op, ii, pd(in_end + DVAL_LEN, ii)); *out_len = pd(op, out); return 0; /* compression went ok */ @@ -589,15 +636,15 @@ match: ************************************************************************/ LZO_PUBLIC(int) -lzo1a_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +lzo1a_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { int r = LZO_E_OK; #if (LZO_COLLECT_STATS) - lzo_memset(lzo_stats,0,sizeof(*lzo_stats)); + lzo_memset(lzo_stats, 0, sizeof(*lzo_stats)); lzo_stats->rbits = RBITS; lzo_stats->clevel = CLEVEL; lzo_stats->dbits = DBITS; @@ -623,11 +670,11 @@ lzo1a_compress ( const lzo_bytep in , lzo_uint in_len, #if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE) r = LZO_E_NOT_COMPRESSIBLE; #else - *out_len = pd(store_run(out,in,in_len), out); + *out_len = pd(store_run(out, in, in_len), out); #endif } else - r = do_compress(in,in_len,out,out_len,wrkmem); + r = do_compress(in, in_len, out, out_len, wrkmem); #if (LZO_COLLECT_STATS) diff --git a/extern/lzo/src/lzo1a_99.c b/extern/lzo/src/lzo1a_99.c index 75579d4..6b0d0b9 100644 --- a/extern/lzo/src/lzo1a_99.c +++ b/extern/lzo/src/lzo1a_99.c @@ -46,10 +46,10 @@ ************************************************************************/ static int -_lzo1a_do_compress ( const lzo_bytep in, lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_compress_t func ) +_lzo1a_do_compress(const lzo_bytep in, lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_compress_t func) { int r; @@ -65,12 +65,12 @@ _lzo1a_do_compress ( const lzo_bytep in, lzo_uint in_len, *out_len = 0; r = LZO_E_NOT_COMPRESSIBLE; #else - *out_len = pd(STORE_RUN(out,in,in_len), out); + *out_len = pd(STORE_RUN(out, in, in_len), out); r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR; #endif } else - r = func(in,in_len,out,out_len,wrkmem); + r = func(in, in_len, out, out_len, wrkmem); return r; } @@ -105,11 +105,11 @@ _lzo1a_do_compress ( const lzo_bytep in, lzo_uint in_len, ************************************************************************/ LZO_PUBLIC(int) -LZO_COMPRESS ( const lzo_bytep in, lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +LZO_COMPRESS(const lzo_bytep in, lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { - return _lzo1a_do_compress(in,in_len,out,out_len,wrkmem,do_compress); + return _lzo1a_do_compress(in, in_len, out, out_len, wrkmem, do_compress); } diff --git a/extern/lzo/src/lzo1a_cm.ch b/extern/lzo/src/lzo1a_cm.ch index 1b36e3c..1260a92 100644 --- a/extern/lzo/src/lzo1a_cm.ch +++ b/extern/lzo/src/lzo1a_cm.ch @@ -47,182 +47,191 @@ #if (DD_BITS == 0) - /* we already matched M2_MIN_LEN bytes, - * m_pos also already advanced M2_MIN_LEN bytes */ - ip += M2_MIN_LEN; - assert(m_pos < ip); +/* we already matched M2_MIN_LEN bytes, + * m_pos also already advanced M2_MIN_LEN bytes */ +ip += M2_MIN_LEN; +assert(m_pos < ip); - /* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes - * to see if we get more than a M2 match */ +/* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes + * to see if we get more than a M2 match */ #define M2_OR_M3 (MATCH_M2) #else /* (DD_BITS == 0) */ - /* we already matched m_len bytes */ - assert(m_len >= M2_MIN_LEN); - ip += m_len; - assert(ip <= in_end); +/* we already matched m_len bytes */ +assert(m_len >= M2_MIN_LEN); +ip += m_len; +assert(ip <= in_end); #define M2_OR_M3 (m_len <= M2_MAX_LEN) #endif /* (DD_BITS == 0) */ - if (M2_OR_M3) - { - /* we've found a short match */ - assert(ip <= in_end); +if (M2_OR_M3) +{ + /* we've found a short match */ + assert(ip <= in_end); - /* 2a) compute match parameters */ + /* 2a) compute match parameters */ #if (DD_BITS == 0) - assert(pd(ip,m_pos) == m_off); - --ip; /* ran one too far, point back to non-match */ - m_len = ip - ii; + assert(pd(ip, m_pos) == m_off); + --ip; /* ran one too far, point back to non-match */ + m_len = ip - ii; #endif - assert(m_len >= M2_MIN_LEN); - assert(m_len <= M2_MAX_LEN); + assert(m_len >= M2_MIN_LEN); + assert(m_len <= M2_MAX_LEN); - assert(m_off >= M2_MIN_OFFSET); - assert(m_off <= M2_MAX_OFFSET); - assert(ii-m_off == m_pos_sav); - assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0); + assert(m_off >= M2_MIN_OFFSET); + assert(m_off <= M2_MAX_OFFSET); + assert(ii - m_off == m_pos_sav); + assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0); - /* 2b) code the match */ - m_off -= M2_MIN_OFFSET; - /* code short match len + low offset bits */ - *op++ = LZO_BYTE(((m_len - THRESHOLD) << M2O_BITS) | - (m_off & M2O_MASK)); - /* code high offset bits */ - *op++ = LZO_BYTE(m_off >> M2O_BITS); + /* 2b) code the match */ + m_off -= M2_MIN_OFFSET; + /* code short match len + low offset bits */ + *op++ = LZO_BYTE(((m_len - THRESHOLD) << M2O_BITS) | + (m_off & M2O_MASK)); + /* code high offset bits */ + *op++ = LZO_BYTE(m_off >> M2O_BITS); - if (ip >= ip_end) - { - ii = ip; - break; - } + if (ip >= ip_end) + { + ii = ip; + break; + } - /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ + /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ #if (CLEVEL == 9) || (CLEVEL >= 7 && M2L_BITS <= 4) || (CLEVEL >= 5 && M2L_BITS <= 3) - /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ - ++ii; - do { - DVAL_NEXT(dv,ii); + /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ + ++ii; + + do + { + DVAL_NEXT(dv, ii); #if 0 - UPDATE_D(dict,drun,dv,ii,in); + UPDATE_D(dict, drun, dv, ii, in); #else - dict[ DINDEX(dv,ii) ] = DENTRY(ii,in); + dict[ DINDEX(dv, ii) ] = DENTRY(ii, in); #endif - MI - } while (++ii < ip); - DVAL_NEXT(dv,ii); - assert(ii == ip); - DVAL_ASSERT(dv,ip); + MI + } + while (++ii < ip); + + DVAL_NEXT(dv, ii); + assert(ii == ip); + DVAL_ASSERT(dv, ip); #elif (CLEVEL >= 3) - SI DI DI XI + SI DI DI XI #elif (CLEVEL >= 2) - SI DI XI + SI DI XI #else - XI + XI #endif - } +} - else +else - { - /* we've found a long match - see how far we can still go */ - const lzo_bytep end; +{ + /* we've found a long match - see how far we can still go */ + const lzo_bytep end; - assert(ip <= in_end); - assert(ii == ip - (M2_MAX_LEN + 1)); - assert(lzo_memcmp(m_pos_sav,ii,(lzo_uint)(ip-ii)) == 0); + assert(ip <= in_end); + assert(ii == ip - (M2_MAX_LEN + 1)); + assert(lzo_memcmp(m_pos_sav, ii, (lzo_uint)(ip - ii)) == 0); #if (DD_BITS > 0) - assert(m_len == (lzo_uint)(ip-ii)); - m_pos = ip - m_off; - assert(m_pos == m_pos_sav + m_len); + assert(m_len == (lzo_uint)(ip - ii)); + m_pos = ip - m_off; + assert(m_pos == m_pos_sav + m_len); #endif - if (pd(in_end,ip) <= (M3_MAX_LEN - M3_MIN_LEN)) - end = in_end; - else - { - end = ip + (M3_MAX_LEN - M3_MIN_LEN); - assert(end < in_end); - } + if (pd(in_end, ip) <= (M3_MAX_LEN - M3_MIN_LEN)) + end = in_end; + else + { + end = ip + (M3_MAX_LEN - M3_MIN_LEN); + assert(end < in_end); + } - while (ip < end && *m_pos == *ip) - m_pos++, ip++; - assert(ip <= in_end); + while (ip < end && *m_pos == *ip) + m_pos++, ip++; - /* 2a) compute match parameters */ - m_len = pd(ip, ii); - assert(m_len >= M3_MIN_LEN); - assert(m_len <= M3_MAX_LEN); + assert(ip <= in_end); - assert(m_off >= M3_MIN_OFFSET); - assert(m_off <= M3_MAX_OFFSET); - assert(ii-m_off == m_pos_sav); - assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0); - assert(pd(ip,m_pos) == m_off); + /* 2a) compute match parameters */ + m_len = pd(ip, ii); + assert(m_len >= M3_MIN_LEN); + assert(m_len <= M3_MAX_LEN); - /* 2b) code the match */ - m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET; - /* code long match flag + low offset bits */ - *op++ = LZO_BYTE(((MSIZE - 1) << M3O_BITS) | (m_off & M3O_MASK)); - /* code high offset bits */ - *op++ = LZO_BYTE(m_off >> M3O_BITS); - /* code match len */ - *op++ = LZO_BYTE(m_len - M3_MIN_LEN); + assert(m_off >= M3_MIN_OFFSET); + assert(m_off <= M3_MAX_OFFSET); + assert(ii - m_off == m_pos_sav); + assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0); + assert(pd(ip, m_pos) == m_off); + + /* 2b) code the match */ + m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET; + /* code long match flag + low offset bits */ + *op++ = LZO_BYTE(((MSIZE - 1) << M3O_BITS) | (m_off & M3O_MASK)); + /* code high offset bits */ + *op++ = LZO_BYTE(m_off >> M3O_BITS); + /* code match len */ + *op++ = LZO_BYTE(m_len - M3_MIN_LEN); - if (ip >= ip_end) - { - ii = ip; - break; - } + if (ip >= ip_end) + { + ii = ip; + break; + } - /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ + /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ #if (CLEVEL == 9) - /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ - /* This is not recommended because it can be slow. */ - ++ii; - do { - DVAL_NEXT(dv,ii); -#if 0 - UPDATE_D(dict,drun,dv,ii,in); -#else - dict[ DINDEX(dv,ii) ] = DENTRY(ii,in); -#endif - MI - } while (++ii < ip); - DVAL_NEXT(dv,ii); - assert(ii == ip); - DVAL_ASSERT(dv,ip); -#elif (CLEVEL >= 8) - SI DI DI DI DI DI DI DI DI XI -#elif (CLEVEL >= 7) - SI DI DI DI DI DI DI DI XI -#elif (CLEVEL >= 6) - SI DI DI DI DI DI DI XI -#elif (CLEVEL >= 5) - SI DI DI DI DI XI -#elif (CLEVEL >= 4) - SI DI DI DI XI -#elif (CLEVEL >= 3) - SI DI DI XI -#elif (CLEVEL >= 2) - SI DI XI -#else - XI -#endif - } + /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ + /* This is not recommended because it can be slow. */ + ++ii; - /* ii now points to the start of the next literal run */ - assert(ii == ip); + do + { + DVAL_NEXT(dv, ii); +#if 0 + UPDATE_D(dict, drun, dv, ii, in); +#else + dict[ DINDEX(dv, ii) ] = DENTRY(ii, in); +#endif + MI + } + while (++ii < ip); + + DVAL_NEXT(dv, ii); + assert(ii == ip); + DVAL_ASSERT(dv, ip); +#elif (CLEVEL >= 8) + SI DI DI DI DI DI DI DI DI XI +#elif (CLEVEL >= 7) + SI DI DI DI DI DI DI DI XI +#elif (CLEVEL >= 6) + SI DI DI DI DI DI DI XI +#elif (CLEVEL >= 5) + SI DI DI DI DI XI +#elif (CLEVEL >= 4) + SI DI DI DI XI +#elif (CLEVEL >= 3) + SI DI DI XI +#elif (CLEVEL >= 2) + SI DI XI +#else + XI +#endif +} + +/* ii now points to the start of the next literal run */ +assert(ii == ip); /* vim:set ts=4 sw=4 et: */ diff --git a/extern/lzo/src/lzo1a_cr.ch b/extern/lzo/src/lzo1a_cr.ch index eef584b..d5b9e89 100644 --- a/extern/lzo/src/lzo1a_cr.ch +++ b/extern/lzo/src/lzo1a_cr.ch @@ -60,37 +60,48 @@ store_run(lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len) while (r_len >= (t = tt)) { r_len -= t; - *op++ = 0; *op++ = (R0MAX - R0MIN); + *op++ = 0; + *op++ = (R0MAX - R0MIN); MEMCPY8_DS(op, ip, t); LZO_STATS(lzo_stats->r0long_runs++); } + tt >>= 1; - do { + + do + { if (r_len >= (t = tt)) { r_len -= t; - *op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits); + *op++ = 0; + *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits); MEMCPY8_DS(op, ip, t); LZO_STATS(lzo_stats->r0long_runs++); } + tt >>= 1; - } while (--r_bits > 0); + } + while (--r_bits > 0); } + assert(r_len < 512); while (r_len >= (t = R0FAST)) { r_len -= t; - *op++ = 0; *op++ = (R0FAST - R0MIN); + *op++ = 0; + *op++ = (R0FAST - R0MIN); MEMCPY8_DS(op, ip, t); LZO_STATS(lzo_stats->r0fast_runs++); } t = r_len; + if (t >= R0MIN) { /* code a short R0 run */ - *op++ = 0; *op++ = LZO_BYTE(t - R0MIN); + *op++ = 0; + *op++ = LZO_BYTE(t - R0MIN); MEMCPY_DS(op, ip, t); LZO_STATS(lzo_stats->r0short_runs++); } diff --git a/extern/lzo/src/lzo1b_9x.c b/extern/lzo/src/lzo1b_9x.c index 285caad..3024064 100644 --- a/extern/lzo/src/lzo1b_9x.c +++ b/extern/lzo/src/lzo1b_9x.c @@ -50,7 +50,7 @@ ************************************************************************/ static lzo_bytep -code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) +code_match(LZO_COMPRESS_T* c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off) { if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) { @@ -60,7 +60,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) m_off -= M2_MIN_OFFSET; /* code match len + low offset bits */ *op++ = LZO_BYTE(((m_len - (M2_MIN_LEN - 2)) << M2O_BITS) | - (m_off & M2O_MASK)); + (m_off & M2O_MASK)); /* code high offset bits */ *op++ = LZO_BYTE(m_off >> M2O_BITS); c->m2_m++; @@ -71,6 +71,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) assert(m_off <= M3_MAX_OFFSET); m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET; + /* code match len */ if (m_len <= M3_MAX_LEN) *op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1))); @@ -81,14 +82,17 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) *op++ = M4_MARKER; /* code match len */ m_len -= M4_MIN_LEN - 1; + while (m_len > 255) { m_len -= 255; *op++ = 0; } + assert(m_len > 0); *op++ = LZO_BYTE(m_len); } + /* code low offset bits */ *op++ = LZO_BYTE(m_off & M3O_MASK); /* code high offset bits */ @@ -97,6 +101,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) c->r1_m_len = 0; c->m3_m++; } + return op; } @@ -106,25 +111,25 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) ************************************************************************/ LZO_EXTERN(int) -lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_callback_p cb, - lzo_uint max_chain ); +lzo1b_999_compress_callback(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_callback_p cb, + lzo_uint max_chain); LZO_PUBLIC(int) -lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_callback_p cb, - lzo_uint max_chain ) +lzo1b_999_compress_callback(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_callback_p cb, + lzo_uint max_chain) { lzo_bytep op; const lzo_bytep ii; lzo_uint lit; lzo_uint m_len, m_off; LZO_COMPRESS_T cc; - LZO_COMPRESS_T * const c = &cc; + LZO_COMPRESS_T* const c = &cc; lzo_swd_p const swd = (lzo_swd_p) wrkmem; int r; @@ -142,15 +147,19 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, lit = 0; c->r1_m_len = 0; - r = init_match(c,swd,NULL,0,0); + r = init_match(c, swd, NULL, 0, 0); + if (r != 0) return r; + if (max_chain > 0) swd->max_chain = max_chain; - r = find_match(c,swd,0,0); + r = find_match(c, swd, 0, 0); + if (r != 0) return r; + while (c->look > 0) { int lazy_match_min_gain = -1; @@ -160,18 +169,20 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, m_off = c->m_off; #if 0 - printf("%5ld: %5d len:%3d off:%5d\n", (c->ip-c->look)-in, c->look, - m_len, m_off); + printf("%5ld: %5d len:%3d off:%5d\n", (c->ip - c->look) - in, c->look, + m_len, m_off); #endif assert(c->ip - c->look >= in); + if (lit == 0) ii = c->ip - c->look; + assert(ii + lit == c->ip - c->look); assert(swd->b_char == *(c->ip - c->look)); if ((m_len < M2_MIN_LEN) || - (m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET)) + (m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET)) { m_len = 0; } @@ -192,20 +203,24 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, lazy_match_min_gain = 1; #if (M2_MIN_LEN == 2) + if (m_len == 2) { /* don't code a match of len 2 if we have to code a literal run. Code a literal instead. */ m_len = 0; } + #endif #if (M2_MIN_LEN == M3_MIN_LEN) + if (m_len == M2_MIN_LEN && m_off > M2_MAX_OFFSET) { /* don't code a M3 match of len 3 if we have to code a literal run. Code a literal instead. */ m_len = 0; } + #endif } else @@ -223,16 +238,18 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, /* try a lazy match */ if (m_len == 0) lazy_match_min_gain = -1; + if (lazy_match_min_gain >= 0 && c->look > m_len) { assert(m_len > 0); - r = find_match(c,swd,1,0); - assert(r == 0); LZO_UNUSED(r); + r = find_match(c, swd, 1, 0); + assert(r == 0); + LZO_UNUSED(r); assert(c->look > 0); if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET && - c->m_off > M2_MAX_OFFSET) + c->m_off > M2_MAX_OFFSET) lazy_match_min_gain += 1; if (c->m_len >= m_len + lazy_match_min_gain) @@ -253,8 +270,10 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, ahead = 1; assert(ii + lit + 1 == c->ip - c->look); } + assert(m_len > 0); } + assert(ii + lit + ahead == c->ip - c->look); @@ -262,8 +281,9 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, { /* a literal */ lit++; - r = find_match(c,swd,1,0); - assert(r == 0); LZO_UNUSED(r); + r = find_match(c, swd, 1, 0); + assert(r == 0); + LZO_UNUSED(r); } else { @@ -284,21 +304,24 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, } else { - op = STORE_RUN(op,ii,lit); + op = STORE_RUN(op, ii, lit); } + if (lit < R0FAST) c->r1_m_len = m_len; else c->r1_m_len = 0; + lit = 0; } else c->r1_m_len = 0; /* 2 - code match */ - op = code_match(c,op,m_len,m_off); - r = find_match(c,swd,m_len,1+ahead); - assert(r == 0); LZO_UNUSED(r); + op = code_match(c, op, m_len, m_off); + r = find_match(c, swd, m_len, 1 + ahead); + assert(r == 0); + LZO_UNUSED(r); } c->codesize = pd(op, out); @@ -307,7 +330,7 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, /* store final run */ if (lit > 0) - op = STORE_RUN(op,ii,lit); + op = STORE_RUN(op, ii, lit); #if defined(LZO_EOF_CODE) *op++ = M3_MARKER | 1; @@ -325,8 +348,8 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, #if 0 printf("%ld %ld -> %ld: %ld %ld %ld %ld %ld\n", - (long) c->textsize, (long)in_len, (long) c->codesize, - c->r1_r, c->m3_r, c->m2_m, c->m3_m, c->lazy); + (long) c->textsize, (long)in_len, (long) c->codesize, + c->r1_r, c->m3_r, c->m2_m, c->m3_m, c->lazy); #endif return LZO_E_OK; } @@ -338,11 +361,11 @@ lzo1b_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, ************************************************************************/ LZO_PUBLIC(int) -lzo1b_999_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +lzo1b_999_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { - return lzo1b_999_compress_callback(in,in_len,out,out_len,wrkmem, + return lzo1b_999_compress_callback(in, in_len, out, out_len, wrkmem, (lzo_callback_p) 0, 0); } diff --git a/extern/lzo/src/lzo1b_c.ch b/extern/lzo/src/lzo1b_c.ch index f13a812..1d5aef1 100644 --- a/extern/lzo/src/lzo1b_c.ch +++ b/extern/lzo/src/lzo1b_c.ch @@ -63,9 +63,9 @@ extern "C" { #endif LZO_PRIVATE(int) -do_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +do_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { const lzo_bytep ip; #if (DD_BITS > 0) @@ -101,7 +101,7 @@ do_compress ( const lzo_bytep in , lzo_uint in_len, /* init dictionary */ #if (LZO_DETERMINISTIC) - BZERO8_PTR(wrkmem,sizeof(lzo_dict_t),D_SIZE); + BZERO8_PTR(wrkmem, sizeof(lzo_dict_t), D_SIZE); #endif @@ -111,15 +111,16 @@ do_compress ( const lzo_bytep in , lzo_uint in_len, #if (DD_BITS > 0) - DVAL_FIRST(dv,ip); - UPDATE_D(dict,drun,dv,ip,in); + DVAL_FIRST(dv, ip); + UPDATE_D(dict, drun, dv, ip, in); ip++; - DVAL_NEXT(dv,ip); + DVAL_NEXT(dv, ip); #else ip++; #endif assert(ip < ip_end); + for (;;) { const lzo_bytep m_pos; @@ -133,9 +134,9 @@ do_compress ( const lzo_bytep in , lzo_uint in_len, lzo_uint m_len; -/*********************************************************************** -// search for a match -************************************************************************/ + /*********************************************************************** + // search for a match + ************************************************************************/ #if !defined(LZO_SEARCH_MATCH_INCLUDE_FILE) # define LZO_SEARCH_MATCH_INCLUDE_FILE "lzo1b_sm.ch" @@ -152,32 +153,34 @@ do_compress ( const lzo_bytep in , lzo_uint in_len, -/*********************************************************************** -// found a literal -************************************************************************/ + /*********************************************************************** + // found a literal + ************************************************************************/ - /* a literal */ + /* a literal */ literal: #if (DD_BITS == 0) - UPDATE_I(dict,0,dindex,ip,in); + UPDATE_I(dict, 0, dindex, ip, in); #endif + if (++ip >= ip_end) break; + #if (DD_BITS > 0) - DVAL_NEXT(dv,ip); + DVAL_NEXT(dv, ip); #endif continue; -/*********************************************************************** -// found a match -************************************************************************/ + /*********************************************************************** + // found a match + ************************************************************************/ match: #if (DD_BITS == 0) - UPDATE_I(dict,0,dindex,ip,in); + UPDATE_I(dict, 0, dindex, ip, in); #endif /* we have found a match of at least M2_MIN_LEN */ @@ -193,9 +196,9 @@ match: assert(ii == ip); -/*********************************************************************** -// code the match -************************************************************************/ + /*********************************************************************** + // code the match + ************************************************************************/ #if !defined(LZO_CODE_MATCH_INCLUDE_FILE) # define LZO_CODE_MATCH_INCLUDE_FILE "lzo1b_cm.ch" @@ -210,9 +213,9 @@ match: } -/*********************************************************************** -// end of block -************************************************************************/ + /*********************************************************************** + // end of block + ************************************************************************/ assert(ip <= in_end); @@ -224,9 +227,11 @@ match: for (i = 0; i < D_SIZE; i++) { p = dict[i]; + if (BOUNDS_CHECKING_OFF_IN_EXPR(p == NULL || p < in || p > in_end)) lzo_stats->unused_dict_entries++; } + lzo_stats->unused_dict_entries_percent = 100.0 * lzo_stats->unused_dict_entries / D_SIZE; } @@ -234,6 +239,7 @@ match: #if defined(LZO_RETURN_IF_NOT_COMPRESSIBLE) + /* return if op == out to indicate that we * couldn't compress and didn't copy anything. */ @@ -242,13 +248,14 @@ match: *out_len = 0; return LZO_E_NOT_COMPRESSIBLE; } + #endif /* store the final literal run */ - if (pd(in_end,ii) > 0) + if (pd(in_end, ii) > 0) { - lzo_uint t = pd(in_end,ii); - op = STORE_RUN(op,ii,t); + lzo_uint t = pd(in_end, ii); + op = STORE_RUN(op, ii, t); } *out_len = pd(op, out); diff --git a/extern/lzo/src/lzo1b_cc.c b/extern/lzo/src/lzo1b_cc.c index c3318ce..f27165e 100644 --- a/extern/lzo/src/lzo1b_cc.c +++ b/extern/lzo/src/lzo1b_cc.c @@ -35,10 +35,10 @@ ************************************************************************/ LZO_LOCAL_IMPL(int) -_lzo1b_do_compress ( const lzo_bytep in, lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_compress_t func ) +_lzo1b_do_compress(const lzo_bytep in, lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_compress_t func) { int r; #if defined(LZO_TEST_COMPRESS_OVERRUN) @@ -64,19 +64,22 @@ _lzo1b_do_compress ( const lzo_bytep in, lzo_uint in_len, *out_len = 0; r = LZO_E_NOT_COMPRESSIBLE; #else - *out_len = pd(STORE_RUN(out,in,in_len), out); + *out_len = pd(STORE_RUN(out, in, in_len), out); r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR; #endif } else - r = func(in,in_len,out,out_len,wrkmem); + r = func(in, in_len, out, out_len, wrkmem); #if defined(LZO_EOF_CODE) #if defined(LZO_TEST_COMPRESS_OVERRUN) + if (r == LZO_E_OK && avail_out - *out_len < 3) r = LZO_E_COMPRESS_OVERRUN; + #endif + if (r == LZO_E_OK) { lzo_bytep op = out + *out_len; @@ -85,14 +88,15 @@ _lzo1b_do_compress ( const lzo_bytep in, lzo_uint in_len, op[2] = 0; *out_len += 3; } + #endif #if (LZO_COLLECT_STATS) lzo_stats->out_len = *out_len; lzo_stats->match_bytes = - 1 * lzo_stats->m1_matches + 2 * lzo_stats->m2_matches + - 3 * lzo_stats->m3_matches + 4 * lzo_stats->m4_matches; + 1 * lzo_stats->m1_matches + 2 * lzo_stats->m2_matches + + 3 * lzo_stats->m3_matches + 4 * lzo_stats->m4_matches; _lzo1b_stats_calc(lzo_stats); #endif @@ -112,30 +116,30 @@ _lzo1b_do_compress ( const lzo_bytep in, lzo_uint in_len, #if (LZO_COLLECT_STATS) static lzo_stats_t lzo_statistics; -lzo_stats_t * const lzo1b_stats = &lzo_statistics; +lzo_stats_t* const lzo1b_stats = &lzo_statistics; -void _lzo1b_stats_init(lzo_stats_t *lzo_stats) +void _lzo1b_stats_init(lzo_stats_t* lzo_stats) { - lzo_memset(lzo_stats,0,sizeof(*lzo_stats)); + lzo_memset(lzo_stats, 0, sizeof(*lzo_stats)); } -void _lzo1b_stats_calc(lzo_stats_t *lzo_stats) +void _lzo1b_stats_calc(lzo_stats_t* lzo_stats) { lzo_stats->matches = - lzo_stats->m1_matches + lzo_stats->m2_matches + - lzo_stats->m3_matches + lzo_stats->m4_matches; + lzo_stats->m1_matches + lzo_stats->m2_matches + + lzo_stats->m3_matches + lzo_stats->m4_matches; lzo_stats->literal_overhead = lzo_stats->lit_runs + - 2 * (lzo_stats->r0short_runs + lzo_stats->r0fast_runs + - lzo_stats->r0long_runs); + 2 * (lzo_stats->r0short_runs + lzo_stats->r0fast_runs + + lzo_stats->r0long_runs); lzo_stats->literal_bytes = lzo_stats->literals + - lzo_stats->literal_overhead; + lzo_stats->literal_overhead; #if 0 assert(lzo_stats->match_bytes + lzo_stats->literal_bytes == - lzo_stats->out_len); + lzo_stats->out_len); #endif lzo_stats->m2_matches -= lzo_stats->r1_matches; @@ -143,7 +147,7 @@ void _lzo1b_stats_calc(lzo_stats_t *lzo_stats) if (lzo_stats->literals > 0) lzo_stats->literal_overhead_percent = - 100.0 * lzo_stats->literal_overhead / lzo_stats->literals; + 100.0 * lzo_stats->literal_overhead / lzo_stats->literals; } diff --git a/extern/lzo/src/lzo1b_cc.h b/extern/lzo/src/lzo1b_cc.h index 403025f..7bc2532 100644 --- a/extern/lzo/src/lzo1b_cc.h +++ b/extern/lzo/src/lzo1b_cc.h @@ -57,18 +57,18 @@ extern const lzo_compress_t _lzo1b_99_compress_func; // ************************************************************************/ -LZO_LOCAL_DECL(lzo_bytep ) -_lzo1b_store_run ( lzo_bytep const oo, const lzo_bytep const ii, - lzo_uint r_len); +LZO_LOCAL_DECL(lzo_bytep) +_lzo1b_store_run(lzo_bytep const oo, const lzo_bytep const ii, + lzo_uint r_len); #define STORE_RUN _lzo1b_store_run LZO_LOCAL_DECL(int) -_lzo1b_do_compress ( const lzo_bytep in, lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_compress_t func ); +_lzo1b_do_compress(const lzo_bytep in, lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_compress_t func); #endif /* already included */ diff --git a/extern/lzo/src/lzo1b_cm.ch b/extern/lzo/src/lzo1b_cm.ch index ccfa869..63533f7 100644 --- a/extern/lzo/src/lzo1b_cm.ch +++ b/extern/lzo/src/lzo1b_cm.ch @@ -39,21 +39,21 @@ #if (DD_BITS == 0) - /* we already matched M2_MIN_LEN bytes, - * m_pos also already advanced M2_MIN_LEN bytes */ - ip += M2_MIN_LEN; - assert(m_pos < ip); +/* we already matched M2_MIN_LEN bytes, + * m_pos also already advanced M2_MIN_LEN bytes */ +ip += M2_MIN_LEN; +assert(m_pos < ip); - /* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes - * to see if we get more than a M2 match */ +/* try to match another M2_MAX_LEN + 1 - M2_MIN_LEN bytes + * to see if we get more than a M2 match */ #define M2_OR_M3 (MATCH_M2) #else /* (DD_BITS == 0) */ - /* we already matched m_len bytes */ - assert(m_len >= M2_MIN_LEN); - ip += m_len; - assert(ip <= in_end); +/* we already matched m_len bytes */ +assert(m_len >= M2_MIN_LEN); +ip += m_len; +assert(ip <= in_end); #define M2_OR_M3 (m_len <= M2_MAX_LEN) @@ -61,220 +61,234 @@ - if (M2_OR_M3) - { - /* we've found a M2 or M3 match */ - assert(ip <= in_end); +if (M2_OR_M3) +{ + /* we've found a M2 or M3 match */ + assert(ip <= in_end); - /* 2a) compute match parameters */ + /* 2a) compute match parameters */ #if (DD_BITS == 0) - assert(pd(ip,m_pos) == m_off); - --ip; /* ran one too far, point back to non-match */ - m_len = pd(ip, ii); + assert(pd(ip, m_pos) == m_off); + --ip; /* ran one too far, point back to non-match */ + m_len = pd(ip, ii); #endif - /* 2a2) verify match parameters */ - assert(m_len >= M2_MIN_LEN); - assert(m_len <= M2_MAX_LEN); - assert(m_len <= M3_MAX_LEN); + /* 2a2) verify match parameters */ + assert(m_len >= M2_MIN_LEN); + assert(m_len <= M2_MAX_LEN); + assert(m_len <= M3_MAX_LEN); - assert(m_off >= M2_MIN_OFFSET); - assert(m_off >= M3_MIN_OFFSET); - assert(m_off <= M3_MAX_OFFSET); - assert(ii-m_off == m_pos_sav); - assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0); + assert(m_off >= M2_MIN_OFFSET); + assert(m_off >= M3_MIN_OFFSET); + assert(m_off <= M3_MAX_OFFSET); + assert(ii - m_off == m_pos_sav); + assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0); - /* 2b) code the match */ + /* 2b) code the match */ #if (_M2_MAX_OFFSET != _M3_MAX_OFFSET) - if (m_off <= M2_MAX_OFFSET) - { + + if (m_off <= M2_MAX_OFFSET) + { #else - assert(m_off <= M2_MAX_OFFSET); + assert(m_off <= M2_MAX_OFFSET); #endif - m_off -= M2_MIN_OFFSET; - /* code match len + low offset bits */ - *op++ = LZO_BYTE(((m_len - (M2_MIN_LEN - 2)) << M2O_BITS) | - (m_off & M2O_MASK)); - /* code high offset bits */ - *op++ = LZO_BYTE(m_off >> M2O_BITS); - LZO_STATS(lzo_stats->m2_matches++); - LZO_STATS(lzo_stats->m2_match[m_len]++); + m_off -= M2_MIN_OFFSET; + /* code match len + low offset bits */ + *op++ = LZO_BYTE(((m_len - (M2_MIN_LEN - 2)) << M2O_BITS) | + (m_off & M2O_MASK)); + /* code high offset bits */ + *op++ = LZO_BYTE(m_off >> M2O_BITS); + LZO_STATS(lzo_stats->m2_matches++); + LZO_STATS(lzo_stats->m2_match[m_len]++); #if (_M2_MAX_OFFSET != _M3_MAX_OFFSET) - } - else - { + } + else + { #if defined(LZO_HAVE_R1) #if (M3_MIN_LEN == M2_MIN_LEN) - r1 = ip_end; /* invalidate R1 pointer */ + r1 = ip_end; /* invalidate R1 pointer */ #endif #endif - assert(m_len >= M3_MIN_LEN); - m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET; - /* code match len */ - *op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1))); - /* code low offset bits */ - *op++ = LZO_BYTE(m_off & M3O_MASK); - /* code high offset bits */ - *op++ = LZO_BYTE(m_off >> M3O_BITS); - LZO_STATS(lzo_stats->m3_matches++); - LZO_STATS(lzo_stats->m3_match[m_len]++); + assert(m_len >= M3_MIN_LEN); + m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET; + /* code match len */ + *op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1))); + /* code low offset bits */ + *op++ = LZO_BYTE(m_off & M3O_MASK); + /* code high offset bits */ + *op++ = LZO_BYTE(m_off >> M3O_BITS); + LZO_STATS(lzo_stats->m3_matches++); + LZO_STATS(lzo_stats->m3_match[m_len]++); #if defined(LZO_HAVE_M3) - m3 = op; /* set M3 pointer */ + m3 = op; /* set M3 pointer */ #endif - } + } + #endif /* (_M2_MAX_OFFSET != _M3_MAX_OFFSET) */ - if (ip >= ip_end) - { - ii = ip; - break; - } + if (ip >= ip_end) + { + ii = ip; + break; + } - /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ + /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ #if (CLEVEL == 9) || (CLEVEL >= 7 && M2L_BITS <= 4) || (CLEVEL >= 5 && M2L_BITS <= 3) - /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ - ++ii; - do { - DVAL_NEXT(dv,ii); + /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ + ++ii; + + do + { + DVAL_NEXT(dv, ii); #if 0 - UPDATE_D(dict,drun,dv,ii,in); + UPDATE_D(dict, drun, dv, ii, in); #else - dict[ DINDEX(dv,ii) ] = DENTRY(ii,in); + dict[ DINDEX(dv, ii) ] = DENTRY(ii, in); #endif - MI - } while (++ii < ip); - DVAL_NEXT(dv,ii); - assert(ii == ip); - DVAL_ASSERT(dv,ip); + MI + } + while (++ii < ip); + + DVAL_NEXT(dv, ii); + assert(ii == ip); + DVAL_ASSERT(dv, ip); #elif (CLEVEL >= 3) - SI DI DI XI + SI DI DI XI #elif (CLEVEL >= 2) - SI DI XI + SI DI XI #else - XI + XI #endif +} + +else + +{ + /* we've found a M3 or M4 match - see how far we can still go */ + assert(ip <= in_end); + assert(lzo_memcmp(m_pos_sav, ii, (lzo_uint)(ip - ii)) == 0); + + /* 2a) compute match parameters */ +#if !defined(MATCH_IP_END) + assert(ii == ip - (M2_MAX_LEN + 1)); +#if (DD_BITS > 0) + assert(m_len == (lzo_uint)(ip - ii)); + m_pos = ip - m_off; + assert(m_pos == m_pos_sav + m_len); +#endif + { + const lzo_bytep end; + end = in_end; + + while (ip < end && *m_pos == *ip) + m_pos++, ip++; + + assert(ip <= in_end); + m_len = pd(ip, ii); + } + assert(pd(ip, m_pos) == m_off); +#endif + + /* 2a2) verify match parameters */ + assert(m_len >= M3_MIN_LEN); + + assert(m_off >= M3_MIN_OFFSET); + assert(m_off >= M4_MIN_OFFSET); + assert(m_off <= M3_MAX_OFFSET); + assert(m_off <= M4_MAX_OFFSET); + assert(ii - m_off == m_pos_sav); + assert(lzo_memcmp(m_pos_sav, ii, m_len) == 0); + + /* 2b) code the match */ + if (m_len <= M3_MAX_LEN) + { + /* code match len */ + *op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1))); + LZO_STATS(lzo_stats->m3_matches++); + LZO_STATS(lzo_stats->m3_match[m_len]++); + } + else + { + assert(m_len >= M4_MIN_LEN); + /* code M4 match len flag */ + *op++ = M4_MARKER; + /* code match len */ + m_len -= M4_MIN_LEN - 1; + + while (m_len > 255) + { + m_len -= 255; + *op++ = 0; } - else + assert(m_len > 0); + *op++ = LZO_BYTE(m_len); + LZO_STATS(lzo_stats->m4_matches++); + } - { - /* we've found a M3 or M4 match - see how far we can still go */ - assert(ip <= in_end); - assert(lzo_memcmp(m_pos_sav,ii,(lzo_uint)(ip-ii)) == 0); - - /* 2a) compute match parameters */ -#if !defined(MATCH_IP_END) - assert(ii == ip - (M2_MAX_LEN + 1)); -#if (DD_BITS > 0) - assert(m_len == (lzo_uint)(ip-ii)); - m_pos = ip - m_off; - assert(m_pos == m_pos_sav + m_len); -#endif - { - const lzo_bytep end; - end = in_end; - while (ip < end && *m_pos == *ip) - m_pos++, ip++; - assert(ip <= in_end); - m_len = pd(ip, ii); - } - assert(pd(ip,m_pos) == m_off); -#endif - - /* 2a2) verify match parameters */ - assert(m_len >= M3_MIN_LEN); - - assert(m_off >= M3_MIN_OFFSET); - assert(m_off >= M4_MIN_OFFSET); - assert(m_off <= M3_MAX_OFFSET); - assert(m_off <= M4_MAX_OFFSET); - assert(ii-m_off == m_pos_sav); - assert(lzo_memcmp(m_pos_sav,ii,m_len) == 0); - - /* 2b) code the match */ - if (m_len <= M3_MAX_LEN) - { - /* code match len */ - *op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1))); - LZO_STATS(lzo_stats->m3_matches++); - LZO_STATS(lzo_stats->m3_match[m_len]++); - } - else - { - assert(m_len >= M4_MIN_LEN); - /* code M4 match len flag */ - *op++ = M4_MARKER; - /* code match len */ - m_len -= M4_MIN_LEN - 1; - while (m_len > 255) - { - m_len -= 255; - *op++ = 0; - } - assert(m_len > 0); - *op++ = LZO_BYTE(m_len); - LZO_STATS(lzo_stats->m4_matches++); - } - - m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET; - /* code low offset bits */ - *op++ = LZO_BYTE(m_off & M3O_MASK); - /* code high offset bits */ - *op++ = LZO_BYTE(m_off >> M3O_BITS); + m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET; + /* code low offset bits */ + *op++ = LZO_BYTE(m_off & M3O_MASK); + /* code high offset bits */ + *op++ = LZO_BYTE(m_off >> M3O_BITS); #if defined(LZO_HAVE_M3) - m3 = op; /* set M3 pointer */ + m3 = op; /* set M3 pointer */ #endif - if (ip >= ip_end) - { - ii = ip; - break; - } + if (ip >= ip_end) + { + ii = ip; + break; + } - /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ + /* 2c) Insert phrases (beginning with ii+1) into the dictionary. */ #if (CLEVEL == 9) - /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ - /* This is not recommended because it can be slow. */ - ++ii; - do { - DVAL_NEXT(dv,ii); -#if 0 - UPDATE_D(dict,drun,dv,ii,in); -#else - dict[ DINDEX(dv,ii) ] = DENTRY(ii,in); -#endif - MI - } while (++ii < ip); - DVAL_NEXT(dv,ii); - assert(ii == ip); - DVAL_ASSERT(dv,ip); -#elif (CLEVEL >= 8) - SI DI DI DI DI DI DI DI DI XI -#elif (CLEVEL >= 7) - SI DI DI DI DI DI DI DI XI -#elif (CLEVEL >= 6) - SI DI DI DI DI DI DI XI -#elif (CLEVEL >= 5) - SI DI DI DI DI XI -#elif (CLEVEL >= 4) - SI DI DI DI XI -#elif (CLEVEL >= 3) - SI DI DI XI -#elif (CLEVEL >= 2) - SI DI XI -#else - XI -#endif - } + /* Insert the whole match (ii+1)..(ip-1) into dictionary. */ + /* This is not recommended because it can be slow. */ + ++ii; - /* ii now points to the start of the next literal run */ - assert(ii == ip); + do + { + DVAL_NEXT(dv, ii); +#if 0 + UPDATE_D(dict, drun, dv, ii, in); +#else + dict[ DINDEX(dv, ii) ] = DENTRY(ii, in); +#endif + MI + } + while (++ii < ip); + + DVAL_NEXT(dv, ii); + assert(ii == ip); + DVAL_ASSERT(dv, ip); +#elif (CLEVEL >= 8) + SI DI DI DI DI DI DI DI DI XI +#elif (CLEVEL >= 7) + SI DI DI DI DI DI DI DI XI +#elif (CLEVEL >= 6) + SI DI DI DI DI DI DI XI +#elif (CLEVEL >= 5) + SI DI DI DI DI XI +#elif (CLEVEL >= 4) + SI DI DI DI XI +#elif (CLEVEL >= 3) + SI DI DI XI +#elif (CLEVEL >= 2) + SI DI XI +#else + XI +#endif +} + +/* ii now points to the start of the next literal run */ +assert(ii == ip); /* vim:set ts=4 sw=4 et: */ diff --git a/extern/lzo/src/lzo1b_cr.ch b/extern/lzo/src/lzo1b_cr.ch index 844ce94..4f4dd6a 100644 --- a/extern/lzo/src/lzo1b_cr.ch +++ b/extern/lzo/src/lzo1b_cr.ch @@ -37,76 +37,81 @@ // store the current literal run ************************************************************************/ - assert(ip < ip_end); - if (pd(ip,ii) > 0) - { - lzo_uint t = pd(ip,ii); +assert(ip < ip_end); + +if (pd(ip, ii) > 0) +{ + lzo_uint t = pd(ip, ii); #if defined(LZO_HAVE_R1) - if (ip == r1) - { - /* Code a context sensitive R1 match. */ - LZO_STATS(lzo_stats->literals += t); - LZO_STATS(lzo_stats->r1_matches++); - assert(t == 1); - /* modify marker byte */ - assert((op[-2] >> M2O_BITS) == (M2_MARKER >> M2O_BITS)); - op[-2] &= M2O_MASK; - assert((op[-2] >> M2O_BITS) == 0); - /* copy 1 literal */ - *op++ = *ii++; - r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */ - } - else + + if (ip == r1) + { + /* Code a context sensitive R1 match. */ + LZO_STATS(lzo_stats->literals += t); + LZO_STATS(lzo_stats->r1_matches++); + assert(t == 1); + /* modify marker byte */ + assert((op[-2] >> M2O_BITS) == (M2_MARKER >> M2O_BITS)); + op[-2] &= M2O_MASK; + assert((op[-2] >> M2O_BITS) == 0); + /* copy 1 literal */ + *op++ = *ii++; + r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */ + } + else #endif - if (t < R0MIN) - { - /* inline the copying of a short run */ - LZO_STATS(lzo_stats->literals += t); - LZO_STATS(lzo_stats->lit_runs++); - LZO_STATS(lzo_stats->lit_run[t]++); + if (t < R0MIN) + { + /* inline the copying of a short run */ + LZO_STATS(lzo_stats->literals += t); + LZO_STATS(lzo_stats->lit_runs++); + LZO_STATS(lzo_stats->lit_run[t]++); #if defined(LZO_HAVE_M3) - if (t < LZO_SIZE(8-M3O_BITS) && op == m3) - { + + if (t < LZO_SIZE(8 - M3O_BITS) && op == m3) + { /* Code a very short literal run into the low offset bits * of the previous M3/M4 match. */ - LZO_STATS(lzo_stats->lit_runs_after_m3_match++); - LZO_STATS(lzo_stats->lit_run_after_m3_match[t]++); - assert((m3[-2] >> M3O_BITS) == 0); - m3[-2] = LZO_BYTE(m3[-2] | (t << M3O_BITS)); - } - else -#endif - { - *op++ = LZO_BYTE(t); - } - MEMCPY_DS(op, ii, t); -#if defined(LZO_HAVE_R1) - r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */ -#endif - } - else if (t < R0FAST) - { - /* inline the copying of a short R0 run */ - LZO_STATS(lzo_stats->literals += t); - LZO_STATS(lzo_stats->r0short_runs++); - *op++ = 0; *op++ = LZO_BYTE(t - R0MIN); - MEMCPY_DS(op, ii, t); -#if defined(LZO_HAVE_R1) - r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */ -#endif + LZO_STATS(lzo_stats->lit_runs_after_m3_match++); + LZO_STATS(lzo_stats->lit_run_after_m3_match[t]++); + assert((m3[-2] >> M3O_BITS) == 0); + m3[-2] = LZO_BYTE(m3[-2] | (t << M3O_BITS)); } else +#endif { - op = STORE_RUN(op,ii,t); - ii = ip; + *op++ = LZO_BYTE(t); } + + MEMCPY_DS(op, ii, t); +#if defined(LZO_HAVE_R1) + r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */ +#endif } + else if (t < R0FAST) + { + /* inline the copying of a short R0 run */ + LZO_STATS(lzo_stats->literals += t); + LZO_STATS(lzo_stats->r0short_runs++); + *op++ = 0; + *op++ = LZO_BYTE(t - R0MIN); + MEMCPY_DS(op, ii, t); +#if defined(LZO_HAVE_R1) + r1 = ip + (M2_MIN_LEN + 1); /* set new R1 pointer */ +#endif + } + else + { + op = STORE_RUN(op, ii, t); + ii = ip; + } +} - /* ii now points to the start of the current match */ - assert(ii == ip); +/* ii now points to the start of the current match */ +assert(ii == ip); /* vim:set ts=4 sw=4 et: */ diff --git a/extern/lzo/src/lzo1b_d.ch b/extern/lzo/src/lzo1b_d.ch index 4fe164f..c53164b 100644 --- a/extern/lzo/src/lzo1b_d.ch +++ b/extern/lzo/src/lzo1b_d.ch @@ -34,9 +34,9 @@ ************************************************************************/ LZO_PUBLIC(int) -DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +DO_DECOMPRESS(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { lzo_bytep op; const lzo_bytep ip; @@ -63,9 +63,11 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, { NEED_IP(1); t = *ip++; + if (t >= R0FAST - R0MIN) /* a long R0 run */ { t -= R0FAST - R0MIN; + if (t == 0) t = R0FAST; else @@ -75,37 +77,57 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, #else /* help the optimizer */ lzo_uint tt = 256; - do tt <<= 1; while (--t > 0); + + do tt <<= 1; + + while (--t > 0); + t = tt; #endif } - NEED_IP(t); NEED_OP(t); + NEED_IP(t); + NEED_OP(t); #if 1 && (LZO_OPT_UNALIGNED32) - do { - UA_COPY4(op+0, ip+0); - UA_COPY4(op+4, ip+4); - op += 8; ip += 8; + + do + { + UA_COPY4(op + 0, ip + 0); + UA_COPY4(op + 4, ip + 4); + op += 8; + ip += 8; t -= 8; - } while (t > 0); + } + while (t > 0); + #else - MEMCPY8_DS(op,ip,t); + MEMCPY8_DS(op, ip, t); #endif continue; } + t += R0MIN; /* a short R0 run */ } - NEED_IP(t); NEED_OP(t); + NEED_IP(t); + NEED_OP(t); /* copy literal run */ #if 1 && (LZO_OPT_UNALIGNED32) + if (t >= 4) { - do { + do + { UA_COPY4(op, ip); - op += 4; ip += 4; t -= 4; - } while (t >= 4); - if (t > 0) do *op++ = *ip++; while (--t > 0); + op += 4; + ip += 4; + t -= 4; + } + while (t >= 4); + + if (t > 0) do* op++ = *ip++; + + while (--t > 0); } else #endif @@ -113,7 +135,10 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, #if (M3O_BITS < 7) literal1: #endif - do *op++ = *ip++; while (--t > 0); + + do* op++ = *ip++; + + while (--t > 0); } #if (M3O_BITS == 7) @@ -124,16 +149,19 @@ literal2: while (TEST_IP_AND_TEST_OP) { t = *ip++; /* get R1 marker */ + if (t >= R0MIN) goto match; - NEED_IP(2); NEED_OP(M2_MIN_LEN + 1); + NEED_IP(2); + NEED_OP(M2_MIN_LEN + 1); - /* R1 match - a M2_MIN_LEN match + 1 byte literal */ + /* R1 match - a M2_MIN_LEN match + 1 byte literal */ assert((t & M2O_MASK) == t); m_pos = op - M2_MIN_OFFSET; - m_pos -= t | (((lzo_uint) *ip++) << M2O_BITS); - assert(m_pos >= out); assert(m_pos < op); + m_pos -= t | (((lzo_uint) * ip++) << M2O_BITS); + assert(m_pos >= out); + assert(m_pos < op); TEST_LB(m_pos); COPY_M2; *op++ = *ip++; @@ -151,23 +179,26 @@ match: /* get match offset */ NEED_IP(1); m_pos = op - M2_MIN_OFFSET; - m_pos -= (t & M2O_MASK) | (((lzo_uint) *ip++) << M2O_BITS); - assert(m_pos >= out); assert(m_pos < op); + m_pos -= (t & M2O_MASK) | (((lzo_uint) * ip++) << M2O_BITS); + assert(m_pos >= out); + assert(m_pos < op); TEST_LB(m_pos); /* get match len */ t = (t >> M2O_BITS) - 1; NEED_OP(t + M2_MIN_LEN - 1); COPY_M2X; - MEMCPY_DS(op,m_pos,t); + MEMCPY_DS(op, m_pos, t); } else /* a M3 or M4 match */ { /* get match len */ t &= M3L_MASK; + if (t == 0) /* a M4 match */ { NEED_IP(1); + while (*ip == 0) { t += 255; @@ -175,6 +206,7 @@ match: TEST_OV(t); NEED_IP(1); } + t += (M4_MIN_LEN - M3_MIN_LEN) + *ip++; } @@ -184,47 +216,68 @@ match: m_pos -= *ip++ & M3O_MASK; m_pos -= (lzo_uint)(*ip++) << M3O_BITS; #if defined(LZO_EOF_CODE) + if (m_pos == op) goto eof_found; + #endif /* copy match */ - assert(m_pos >= out); assert(m_pos < op); - TEST_LB(m_pos); NEED_OP(t + M3_MIN_LEN - 1); + assert(m_pos >= out); + assert(m_pos < op); + TEST_LB(m_pos); + NEED_OP(t + M3_MIN_LEN - 1); #if (LZO_OPT_UNALIGNED32) + if (t >= 2 * 4 - (M3_MIN_LEN - 1) && (op - m_pos) >= 4) { UA_COPY4(op, m_pos); - op += 4; m_pos += 4; t -= 4 - (M3_MIN_LEN - 1); - do { + op += 4; + m_pos += 4; + t -= 4 - (M3_MIN_LEN - 1); + + do + { UA_COPY4(op, m_pos); - op += 4; m_pos += 4; t -= 4; - } while (t >= 4); - if (t > 0) do *op++ = *m_pos++; while (--t > 0); + op += 4; + m_pos += 4; + t -= 4; + } + while (t >= 4); + + if (t > 0) do* op++ = *m_pos++; + + while (--t > 0); } else #endif { - COPY_M3X; - MEMCPY_DS(op,m_pos,t); + COPY_M3X; + MEMCPY_DS(op, m_pos, t); } #if (M3O_BITS < 7) t = ip[-2] >> M3O_BITS; + if (t) { - NEED_IP(t); NEED_OP(t); + NEED_IP(t); + NEED_OP(t); goto literal1; } + #elif (M3O_BITS == 7) + /* optimized version */ if (ip[-2] & (1 << M3O_BITS)) { - NEED_IP(1); NEED_OP(1); + NEED_IP(1); + NEED_OP(1); *op++ = *ip++; goto literal2; } + #endif } } @@ -242,7 +295,7 @@ eof_found: #endif *out_len = pd(op, out); return (ip == ip_end ? LZO_E_OK : - (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); + (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); #if defined(HAVE_NEED_IP) diff --git a/extern/lzo/src/lzo1b_r.ch b/extern/lzo/src/lzo1b_r.ch index 827a67d..f1d2bd6 100644 --- a/extern/lzo/src/lzo1b_r.ch +++ b/extern/lzo/src/lzo1b_r.ch @@ -30,8 +30,8 @@ // store a literal run (internal) ************************************************************************/ -LZO_LOCAL_IMPL(lzo_bytep ) -STORE_RUN ( lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len) +LZO_LOCAL_IMPL(lzo_bytep) +STORE_RUN(lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len) { lzo_bytep op; const lzo_bytep ip; @@ -52,37 +52,48 @@ STORE_RUN ( lzo_bytep const oo, const lzo_bytep const ii, lzo_uint r_len) while (r_len >= (t = tt)) { r_len -= t; - *op++ = 0; *op++ = (R0FAST - R0MIN) + 7; + *op++ = 0; + *op++ = (R0FAST - R0MIN) + 7; MEMCPY8_DS(op, ip, t); LZO_STATS(lzo_stats->r0long_runs++); } + tt >>= 1; - do { + + do + { if (r_len >= (t = tt)) { r_len -= t; - *op++ = 0; *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits); + *op++ = 0; + *op++ = LZO_BYTE((R0FAST - R0MIN) + r_bits); MEMCPY8_DS(op, ip, t); LZO_STATS(lzo_stats->r0long_runs++); } + tt >>= 1; - } while (--r_bits > 0); + } + while (--r_bits > 0); } + assert(r_len < 512); while (r_len >= (t = R0FAST)) { r_len -= t; - *op++ = 0; *op++ = (R0FAST - R0MIN); + *op++ = 0; + *op++ = (R0FAST - R0MIN); MEMCPY8_DS(op, ip, t); LZO_STATS(lzo_stats->r0fast_runs++); } t = r_len; + if (t >= R0MIN) { /* code a short R0 run */ - *op++ = 0; *op++ = LZO_BYTE(t - R0MIN); + *op++ = 0; + *op++ = LZO_BYTE(t - R0MIN); MEMCPY_DS(op, ip, t); LZO_STATS(lzo_stats->r0short_runs++); } diff --git a/extern/lzo/src/lzo1b_sm.ch b/extern/lzo/src/lzo1b_sm.ch index 06a83e2..1817a3f 100644 --- a/extern/lzo/src/lzo1b_sm.ch +++ b/extern/lzo/src/lzo1b_sm.ch @@ -39,156 +39,181 @@ #if (DD_BITS == 0) - /* search ip in the dictionary */ - DINDEX1(dindex,ip); - GINDEX(m_pos,m_off,dict,dindex,in); - if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET)) - goto literal; +/* search ip in the dictionary */ +DINDEX1(dindex, ip); +GINDEX(m_pos, m_off, dict, dindex, in); + +if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M3_MAX_OFFSET)) + goto literal; + #if 1 - if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) - goto try_match; - DINDEX2(dindex,ip); + +if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) + goto try_match; + +DINDEX2(dindex, ip); #endif - GINDEX(m_pos,m_off,dict,dindex,in); - if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET)) - goto literal; - if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) - goto try_match; - goto literal; +GINDEX(m_pos, m_off, dict, dindex, in); + +if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M3_MAX_OFFSET)) + goto literal; + +if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) + goto try_match; + +goto literal; #else /* (DD_BITS == 0) */ - /* search ip in the deepened dictionary */ - { - lzo_dict_p d = &dict [ DINDEX(dv,ip) ]; - const lzo_bytep ip_sav; - unsigned j = DD_SIZE; - lzo_uint x_len; - LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, x_off, 0); +/* search ip in the deepened dictionary */ +{ + lzo_dict_p d = &dict [ DINDEX(dv, ip) ]; + const lzo_bytep ip_sav; + unsigned j = DD_SIZE; + lzo_uint x_len; + LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, x_off, 0); - DVAL_ASSERT(dv,ip); + DVAL_ASSERT(dv, ip); - ip_sav = ip; - m_len = 0; - do { + ip_sav = ip; + m_len = 0; + + do + { #if !defined(NDEBUG) - const lzo_bytep z_pos = NULL; + const lzo_bytep z_pos = NULL; #endif #if (LZO_DICT_USE_PTR) - m_pos = *d; - assert((z_pos = m_pos) == *d); + m_pos = *d; + assert((z_pos = m_pos) == *d); #if (LZO_DETERMINISTIC) - assert(m_pos == NULL || m_pos >= in); - assert(m_pos == NULL || m_pos < ip); + assert(m_pos == NULL || m_pos >= in); + assert(m_pos == NULL || m_pos < ip); #endif #else - x_off = *d; + x_off = *d; #endif - assert(ip == ip_sav); + assert(ip == ip_sav); - if (LZO_CHECK_MPOS(m_pos,x_off,in,ip,MAX_OFFSET)) + if (LZO_CHECK_MPOS(m_pos, x_off, in, ip, MAX_OFFSET)) #if (CLEVEL == 9) - *d = DENTRY(ip,in); + *d = DENTRY(ip, in); + #else - ((void)(0)); + ((void)(0)); #endif - else if (m_pos[m_len] != ip[m_len]) - ((void)(0)); - else if (*m_pos++ == *ip++ && *m_pos++ == *ip++ && *m_pos++ == *ip++) - { + else if (m_pos[m_len] != ip[m_len]) + ((void)(0)); + else if (*m_pos++ == *ip++ && *m_pos++ == *ip++ && *m_pos++ == *ip++) + { #if !(LZO_DICT_USE_PTR) - assert((z_pos = ip - 3 - x_off) == (m_pos - 3)); + assert((z_pos = ip - 3 - x_off) == (m_pos - 3)); #endif - /* a match */ - if (MATCH_M2) - { - x_len = pd((ip - 1), ip_sav); - if (x_len > m_len) - { - m_len = x_len; - m_off = x_off; - assert((m_pos_sav = z_pos) != NULL); - } + + /* a match */ + if (MATCH_M2) + { + x_len = pd((ip - 1), ip_sav); + + if (x_len > m_len) + { + m_len = x_len; + m_off = x_off; + assert((m_pos_sav = z_pos) != NULL); + } + #if (CLEVEL == 9) - /* try to find a closer match */ - else if (x_len == m_len && x_off < m_off) - { - m_off = x_off; - assert((m_pos_sav = z_pos) != NULL); - } + /* try to find a closer match */ + else if (x_len == m_len && x_off < m_off) + { + m_off = x_off; + assert((m_pos_sav = z_pos) != NULL); + } + #endif - } - else - { - assert((ip - ip_sav) == M2_MAX_LEN + 1); + } + else + { + assert((ip - ip_sav) == M2_MAX_LEN + 1); #if (CLEVEL == 9) #if defined(MATCH_IP_END) - { - const lzo_bytep end; - end = MATCH_IP_END; - while (ip < end && *m_pos == *ip) - m_pos++, ip++; - assert(ip <= in_end); - x_len = pd(ip, ip_sav); - } - if (x_len > m_len) - { - m_len = x_len; - m_off = x_off; - assert((m_pos_sav = z_pos) != NULL); - if (ip >= MATCH_IP_END) - { - ip = ip_sav; -#if 0 - /* not needed - we are at the end */ - d -= DD_SIZE - j; - assert(d == &dict [ DINDEX(dv,ip) ]); - UPDATE_P(d,drun,ip,in); -#endif - goto match; - } - } - else if (x_len == m_len && x_off < m_off) - { - m_off = x_off; - assert((m_pos_sav = z_pos) != NULL); - } -#else - /* try to find a closer match */ - if (m_len < M2_MAX_LEN + 1 || x_off < m_off) - { - m_len = M2_MAX_LEN + 1; - m_off = x_off; - assert((m_pos_sav = z_pos) != NULL); - } -#endif -#else - /* don't search for a longer/closer match */ - m_len = M2_MAX_LEN + 1; - m_off = x_off; - assert((m_pos_sav = z_pos) != NULL); - ip = ip_sav; - d -= DD_SIZE - j; - assert(d == &dict [ DINDEX(dv,ip) ]); - UPDATE_P(d,drun,ip,in); - goto match; -#endif - } - ip = ip_sav; - } - else - ip = ip_sav; - d++; - } while (--j > 0); - assert(ip == ip_sav); + { + const lzo_bytep end; + end = MATCH_IP_END; - d -= DD_SIZE; - assert(d == &dict [ DINDEX(dv,ip) ]); - UPDATE_P(d,drun,ip,in); + while (ip < end && *m_pos == *ip) + m_pos++, ip++; + + assert(ip <= in_end); + x_len = pd(ip, ip_sav); + } + + if (x_len > m_len) + { + m_len = x_len; + m_off = x_off; + assert((m_pos_sav = z_pos) != NULL); + + if (ip >= MATCH_IP_END) + { + ip = ip_sav; +#if 0 + /* not needed - we are at the end */ + d -= DD_SIZE - j; + assert(d == &dict [ DINDEX(dv, ip) ]); + UPDATE_P(d, drun, ip, in); +#endif + goto match; + } + } + else if (x_len == m_len && x_off < m_off) + { + m_off = x_off; + assert((m_pos_sav = z_pos) != NULL); + } + +#else + + /* try to find a closer match */ + if (m_len < M2_MAX_LEN + 1 || x_off < m_off) + { + m_len = M2_MAX_LEN + 1; + m_off = x_off; + assert((m_pos_sav = z_pos) != NULL); + } + +#endif +#else + /* don't search for a longer/closer match */ + m_len = M2_MAX_LEN + 1; + m_off = x_off; + assert((m_pos_sav = z_pos) != NULL); + ip = ip_sav; + d -= DD_SIZE - j; + assert(d == &dict [ DINDEX(dv, ip) ]); + UPDATE_P(d, drun, ip, in); + goto match; +#endif + } + + ip = ip_sav; } + else + ip = ip_sav; + + d++; + } + while (--j > 0); + + assert(ip == ip_sav); + + d -= DD_SIZE; + assert(d == &dict [ DINDEX(dv, ip) ]); + UPDATE_P(d, drun, ip, in); +} #endif /* (DD_BITS == 0) */ diff --git a/extern/lzo/src/lzo1b_tm.ch b/extern/lzo/src/lzo1b_tm.ch index a2da025..7eec33c 100644 --- a/extern/lzo/src/lzo1b_tm.ch +++ b/extern/lzo/src/lzo1b_tm.ch @@ -43,39 +43,46 @@ try_match: #if !defined(NDEBUG) && (LZO_DICT_USE_PTR) #if (LZO_DETERMINISTIC) - assert(m_pos == NULL || m_pos >= in); - assert(m_pos == NULL || m_pos < ip); +assert(m_pos == NULL || m_pos >= in); +assert(m_pos == NULL || m_pos < ip); #endif - m_pos_sav = m_pos; +m_pos_sav = m_pos; #endif - if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2]) - { - m_pos += 3; - goto match; - } + +if (m_pos[0] == ip[0] && m_pos[1] == ip[1] && m_pos[2] == ip[2]) +{ + m_pos += 3; + goto match; +} #else /* (DD_BITS == 0) */ - /* test potential match */ +/* test potential match */ - if (m_len > M2_MIN_LEN) - goto match; - if (m_len == M2_MIN_LEN) - { +if (m_len > M2_MIN_LEN) + goto match; + +if (m_len == M2_MIN_LEN) +{ #if (_MAX_OFFSET == _M2_MAX_OFFSET) - goto match; + goto match; #else - if (m_off <= M2_MAX_OFFSET) - goto match; + + if (m_off <= M2_MAX_OFFSET) + goto match; + #if 0 && (M3_MIN_LEN == M2_MIN_LEN) - if (ip == ii) - goto match; + + if (ip == ii) + goto match; + #endif #endif - } - goto literal; +} + +goto literal; #endif /* (DD_BITS == 0) */ diff --git a/extern/lzo/src/lzo1b_xx.c b/extern/lzo/src/lzo1b_xx.c index 56f3006..1dce746 100644 --- a/extern/lzo/src/lzo1b_xx.c +++ b/extern/lzo/src/lzo1b_xx.c @@ -33,7 +33,7 @@ // ************************************************************************/ -static const lzo_compress_t * const c_funcs [9] = +static const lzo_compress_t* const c_funcs [9] = { &_lzo1b_1_compress_func, &_lzo1b_2_compress_func, @@ -49,7 +49,7 @@ static const lzo_compress_t * const c_funcs [9] = static lzo_compress_t lzo1b_get_compress_func(int clevel) { - const lzo_compress_t *f; + const lzo_compress_t* f; if (clevel < LZO1B_BEST_SPEED || clevel > LZO1B_BEST_COMPRESSION) { @@ -58,24 +58,27 @@ static lzo_compress_t lzo1b_get_compress_func(int clevel) else return (lzo_compress_t) 0; } - f = c_funcs[clevel-1]; + + f = c_funcs[clevel - 1]; assert(f && *f); return *f; } LZO_PUBLIC(int) -lzo1b_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - int clevel ) +lzo1b_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + int clevel) { lzo_compress_t f; f = lzo1b_get_compress_func(clevel); + if (!f) return LZO_E_ERROR; - return _lzo1b_do_compress(src,src_len,dst,dst_len,wrkmem,f); + + return _lzo1b_do_compress(src, src_len, dst, dst_len, wrkmem, f); } diff --git a/extern/lzo/src/lzo1c_9x.c b/extern/lzo/src/lzo1c_9x.c index cbc4e51..037ab38 100644 --- a/extern/lzo/src/lzo1c_9x.c +++ b/extern/lzo/src/lzo1c_9x.c @@ -50,7 +50,7 @@ ************************************************************************/ static lzo_bytep -code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) +code_match(LZO_COMPRESS_T* c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off) { if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) { @@ -60,7 +60,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) m_off -= M2_MIN_OFFSET; /* code match len + low offset bits */ *op++ = LZO_BYTE(((m_len - (M2_MIN_LEN - 2)) << M2O_BITS) | - (m_off & M2O_MASK)); + (m_off & M2O_MASK)); /* code high offset bits */ *op++ = LZO_BYTE(m_off >> M2O_BITS); c->m2_m++; @@ -71,6 +71,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) assert(m_off <= M3_MAX_OFFSET); m_off -= M3_MIN_OFFSET - M3_EOF_OFFSET; + /* code match len */ if (m_len <= M3_MAX_LEN) *op++ = LZO_BYTE(M3_MARKER | (m_len - (M3_MIN_LEN - 1))); @@ -81,14 +82,17 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) *op++ = M4_MARKER; /* code match len */ m_len -= M4_MIN_LEN - 1; + while (m_len > 255) { m_len -= 255; *op++ = 0; } + assert(m_len > 0); *op++ = LZO_BYTE(m_len); } + /* code low offset bits */ *op++ = LZO_BYTE(m_off & M3O_MASK); /* code high offset bits */ @@ -98,6 +102,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) c->m3 = op; c->m3_m++; } + return op; } @@ -107,25 +112,25 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) ************************************************************************/ LZO_EXTERN(int) -lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_callback_p cb, - lzo_uint max_chain ); +lzo1c_999_compress_callback(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_callback_p cb, + lzo_uint max_chain); LZO_PUBLIC(int) -lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_callback_p cb, - lzo_uint max_chain ) +lzo1c_999_compress_callback(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_callback_p cb, + lzo_uint max_chain) { lzo_bytep op; const lzo_bytep ii; lzo_uint lit; lzo_uint m_len, m_off; LZO_COMPRESS_T cc; - LZO_COMPRESS_T * const c = &cc; + LZO_COMPRESS_T* const c = &cc; lzo_swd_p const swd = (lzo_swd_p) wrkmem; int r; @@ -144,15 +149,19 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, c->r1_m_len = 0; c->m3 = out + 1; /* pointer after last m3/m4 match */ - r = init_match(c,swd,NULL,0,0); + r = init_match(c, swd, NULL, 0, 0); + if (r != 0) return r; + if (max_chain > 0) swd->max_chain = max_chain; - r = find_match(c,swd,0,0); + r = find_match(c, swd, 0, 0); + if (r != 0) return r; + while (c->look > 0) { int lazy_match_min_gain = -1; @@ -162,18 +171,20 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, m_off = c->m_off; #if 0 - printf("%5ld: %5d len:%3d off:%5d\n", (c->ip-c->look)-in, c->look, - m_len, m_off); + printf("%5ld: %5d len:%3d off:%5d\n", (c->ip - c->look) - in, c->look, + m_len, m_off); #endif assert(c->ip - c->look >= in); + if (lit == 0) ii = c->ip - c->look; + assert(ii + lit == c->ip - c->look); assert(swd->b_char == *(c->ip - c->look)); if ((m_len < M2_MIN_LEN) || - (m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET)) + (m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET)) { m_len = 0; } @@ -198,20 +209,24 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, lazy_match_min_gain = 1; #if (M2_MIN_LEN == 2) + if (m_len == 2) { /* don't code a match of len 2 if we have to code a literal run. Code a literal instead. */ m_len = 0; } + #endif #if (M2_MIN_LEN == M3_MIN_LEN) + if (m_len == M2_MIN_LEN && m_off > M2_MAX_OFFSET) { /* don't code a M3 match of len 3 if we have to code a literal run. Code a literal instead. */ m_len = 0; } + #endif } else @@ -229,16 +244,18 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, /* try a lazy match */ if (m_len == 0) lazy_match_min_gain = -1; + if (lazy_match_min_gain >= 0 && c->look > m_len) { assert(m_len > 0); - r = find_match(c,swd,1,0); - assert(r == 0); LZO_UNUSED(r); + r = find_match(c, swd, 1, 0); + assert(r == 0); + LZO_UNUSED(r); assert(c->look > 0); if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET && - c->m_off > M2_MAX_OFFSET) + c->m_off > M2_MAX_OFFSET) lazy_match_min_gain += 1; if (c->m_len >= m_len + lazy_match_min_gain) @@ -259,8 +276,10 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, ahead = 1; assert(ii + lit + 1 == c->ip - c->look); } + assert(m_len > 0); } + assert(ii + lit + ahead == c->ip - c->look); @@ -268,8 +287,9 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, { /* a literal */ lit++; - r = find_match(c,swd,1,0); - assert(r == 0); LZO_UNUSED(r); + r = find_match(c, swd, 1, 0); + assert(r == 0); + LZO_UNUSED(r); } else { @@ -298,21 +318,24 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, } else { - op = STORE_RUN(op,ii,lit); + op = STORE_RUN(op, ii, lit); } + if (lit < R0FAST) c->r1_m_len = m_len; else c->r1_m_len = 0; + lit = 0; } else c->r1_m_len = 0; /* 2 - code match */ - op = code_match(c,op,m_len,m_off); - r = find_match(c,swd,m_len,1+ahead); - assert(r == 0); LZO_UNUSED(r); + op = code_match(c, op, m_len, m_off); + r = find_match(c, swd, m_len, 1 + ahead); + assert(r == 0); + LZO_UNUSED(r); } c->codesize = pd(op, out); @@ -321,7 +344,7 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, /* store final run */ if (lit > 0) - op = STORE_RUN(op,ii,lit); + op = STORE_RUN(op, ii, lit); #if defined(LZO_EOF_CODE) *op++ = M3_MARKER | 1; @@ -339,8 +362,8 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, #if 0 printf("%ld %ld -> %ld: %ld %ld %ld %ld %ld\n", - (long) c->textsize, (long)in_len, (long) c->codesize, - c->r1_r, c->m3_r, c->m2_m, c->m3_m, c->lazy); + (long) c->textsize, (long)in_len, (long) c->codesize, + c->r1_r, c->m3_r, c->m2_m, c->m3_m, c->lazy); #endif return LZO_E_OK; } @@ -352,11 +375,11 @@ lzo1c_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, ************************************************************************/ LZO_PUBLIC(int) -lzo1c_999_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +lzo1c_999_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { - return lzo1c_999_compress_callback(in,in_len,out,out_len,wrkmem, + return lzo1c_999_compress_callback(in, in_len, out, out_len, wrkmem, (lzo_callback_p) 0, 0); } diff --git a/extern/lzo/src/lzo1c_cc.c b/extern/lzo/src/lzo1c_cc.c index f704425..100bede 100644 --- a/extern/lzo/src/lzo1c_cc.c +++ b/extern/lzo/src/lzo1c_cc.c @@ -35,10 +35,10 @@ ************************************************************************/ LZO_LOCAL_IMPL(int) -_lzo1c_do_compress ( const lzo_bytep in, lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_compress_t func ) +_lzo1c_do_compress(const lzo_bytep in, lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_compress_t func) { int r; #if defined(LZO_TEST_COMPRESS_OVERRUN) @@ -64,19 +64,22 @@ _lzo1c_do_compress ( const lzo_bytep in, lzo_uint in_len, *out_len = 0; r = LZO_E_NOT_COMPRESSIBLE; #else - *out_len = pd(STORE_RUN(out,in,in_len), out); + *out_len = pd(STORE_RUN(out, in, in_len), out); r = (*out_len > in_len) ? LZO_E_OK : LZO_E_ERROR; #endif } else - r = func(in,in_len,out,out_len,wrkmem); + r = func(in, in_len, out, out_len, wrkmem); #if defined(LZO_EOF_CODE) #if defined(LZO_TEST_COMPRESS_OVERRUN) + if (r == LZO_E_OK && avail_out - *out_len < 3) r = LZO_E_COMPRESS_OVERRUN; + #endif + if (r == LZO_E_OK) { lzo_bytep op = out + *out_len; @@ -85,14 +88,15 @@ _lzo1c_do_compress ( const lzo_bytep in, lzo_uint in_len, op[2] = 0; *out_len += 3; } + #endif #if (LZO_COLLECT_STATS) lzo_stats->out_len = *out_len; lzo_stats->match_bytes = - 1 * lzo_stats->m1_matches + 2 * lzo_stats->m2_matches + - 3 * lzo_stats->m3_matches + 4 * lzo_stats->m4_matches; + 1 * lzo_stats->m1_matches + 2 * lzo_stats->m2_matches + + 3 * lzo_stats->m3_matches + 4 * lzo_stats->m4_matches; _lzo1c_stats_calc(lzo_stats); #endif @@ -112,30 +116,30 @@ _lzo1c_do_compress ( const lzo_bytep in, lzo_uint in_len, #if (LZO_COLLECT_STATS) static lzo_stats_t lzo_statistics; -lzo_stats_t * const lzo1c_stats = &lzo_statistics; +lzo_stats_t* const lzo1c_stats = &lzo_statistics; -void _lzo1c_stats_init(lzo_stats_t *lzo_stats) +void _lzo1c_stats_init(lzo_stats_t* lzo_stats) { - lzo_memset(lzo_stats,0,sizeof(*lzo_stats)); + lzo_memset(lzo_stats, 0, sizeof(*lzo_stats)); } -void _lzo1c_stats_calc(lzo_stats_t *lzo_stats) +void _lzo1c_stats_calc(lzo_stats_t* lzo_stats) { lzo_stats->matches = - lzo_stats->m1_matches + lzo_stats->m2_matches + - lzo_stats->m3_matches + lzo_stats->m4_matches; + lzo_stats->m1_matches + lzo_stats->m2_matches + + lzo_stats->m3_matches + lzo_stats->m4_matches; lzo_stats->literal_overhead = lzo_stats->lit_runs + - 2 * (lzo_stats->r0short_runs + lzo_stats->r0fast_runs + - lzo_stats->r0long_runs); + 2 * (lzo_stats->r0short_runs + lzo_stats->r0fast_runs + + lzo_stats->r0long_runs); lzo_stats->literal_bytes = lzo_stats->literals + - lzo_stats->literal_overhead; + lzo_stats->literal_overhead; #if 0 assert(lzo_stats->match_bytes + lzo_stats->literal_bytes == - lzo_stats->out_len); + lzo_stats->out_len); #endif lzo_stats->m2_matches -= lzo_stats->r1_matches; @@ -143,7 +147,7 @@ void _lzo1c_stats_calc(lzo_stats_t *lzo_stats) if (lzo_stats->literals > 0) lzo_stats->literal_overhead_percent = - 100.0 * lzo_stats->literal_overhead / lzo_stats->literals; + 100.0 * lzo_stats->literal_overhead / lzo_stats->literals; } diff --git a/extern/lzo/src/lzo1c_cc.h b/extern/lzo/src/lzo1c_cc.h index f8b7d83..0837617 100644 --- a/extern/lzo/src/lzo1c_cc.h +++ b/extern/lzo/src/lzo1c_cc.h @@ -57,18 +57,18 @@ extern const lzo_compress_t _lzo1c_99_compress_func; // ************************************************************************/ -LZO_LOCAL_DECL(lzo_bytep ) -_lzo1c_store_run ( lzo_bytep const oo, const lzo_bytep const ii, - lzo_uint r_len); +LZO_LOCAL_DECL(lzo_bytep) +_lzo1c_store_run(lzo_bytep const oo, const lzo_bytep const ii, + lzo_uint r_len); #define STORE_RUN _lzo1c_store_run LZO_LOCAL_DECL(int) -_lzo1c_do_compress ( const lzo_bytep in, lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_compress_t func ); +_lzo1c_do_compress(const lzo_bytep in, lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_compress_t func); #endif /* already included */ diff --git a/extern/lzo/src/lzo1c_d2.c b/extern/lzo/src/lzo1c_d2.c index fa83cdd..45f3efe 100644 --- a/extern/lzo/src/lzo1c_d2.c +++ b/extern/lzo/src/lzo1c_d2.c @@ -35,13 +35,13 @@ #if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM) LZO_EXTERN(int) lzo1c_decompress_asm_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_PUBLIC(int) lzo1c_decompress_asm_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem) +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem) { return lzo1c_decompress_safe(src, src_len, dst, dst_len, wrkmem); } diff --git a/extern/lzo/src/lzo1c_xx.c b/extern/lzo/src/lzo1c_xx.c index 8b46509..150a12e 100644 --- a/extern/lzo/src/lzo1c_xx.c +++ b/extern/lzo/src/lzo1c_xx.c @@ -33,7 +33,7 @@ // ************************************************************************/ -static const lzo_compress_t * const c_funcs [9] = +static const lzo_compress_t* const c_funcs [9] = { &_lzo1c_1_compress_func, &_lzo1c_2_compress_func, @@ -49,7 +49,7 @@ static const lzo_compress_t * const c_funcs [9] = static lzo_compress_t lzo1c_get_compress_func(int clevel) { - const lzo_compress_t *f; + const lzo_compress_t* f; if (clevel < LZO1C_BEST_SPEED || clevel > LZO1C_BEST_COMPRESSION) { @@ -58,24 +58,27 @@ static lzo_compress_t lzo1c_get_compress_func(int clevel) else return (lzo_compress_t) 0; } - f = c_funcs[clevel-1]; + + f = c_funcs[clevel - 1]; assert(f && *f); return *f; } LZO_PUBLIC(int) -lzo1c_compress ( const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem, - int clevel ) +lzo1c_compress(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem, + int clevel) { lzo_compress_t f; f = lzo1c_get_compress_func(clevel); + if (!f) return LZO_E_ERROR; - return _lzo1c_do_compress(src,src_len,dst,dst_len,wrkmem,f); + + return _lzo1c_do_compress(src, src_len, dst, dst_len, wrkmem, f); } diff --git a/extern/lzo/src/lzo1f_1.c b/extern/lzo/src/lzo1f_1.c index 44a138c..b906414 100644 --- a/extern/lzo/src/lzo1f_1.c +++ b/extern/lzo/src/lzo1f_1.c @@ -53,9 +53,9 @@ ************************************************************************/ static __lzo_noinline -int do_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +int do_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { const lzo_bytep ip; lzo_bytep op; @@ -69,6 +69,7 @@ int do_compress ( const lzo_bytep in , lzo_uint in_len, ii = ip; ip++; + for (;;) { const lzo_bytep m_pos; @@ -77,25 +78,33 @@ int do_compress ( const lzo_bytep in , lzo_uint in_len, lzo_uint dindex; lzo_uint lit; - DINDEX1(dindex,ip); - GINDEX(m_pos,m_off,dict,dindex,in); - if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET)) + DINDEX1(dindex, ip); + GINDEX(m_pos, m_off, dict, dindex, in); + + if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M3_MAX_OFFSET)) goto literal; + #if 1 + if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) goto try_match; - DINDEX2(dindex,ip); + + DINDEX2(dindex, ip); #endif - GINDEX(m_pos,m_off,dict,dindex,in); - if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M3_MAX_OFFSET)) + GINDEX(m_pos, m_off, dict, dindex, in); + + if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M3_MAX_OFFSET)) goto literal; + if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) goto try_match; + goto literal; try_match: #if 0 && (LZO_OPT_UNALIGNED16) + if (UA_GET_NE16(m_pos) != UA_GET_NE16(ip)) #else if (m_pos[0] != ip[0] || m_pos[1] != ip[1]) @@ -108,16 +117,23 @@ try_match: { m_pos += 3; #if 0 + if (m_off <= M2_MAX_OFFSET) goto match; + if (lit <= 3) goto match; + if (lit == 3) /* better compression, but slower */ { - assert(op - 2 > out); op[-2] |= LZO_BYTE(3); - *op++ = *ii++; *op++ = *ii++; *op++ = *ii++; + assert(op - 2 > out); + op[-2] |= LZO_BYTE(3); + *op++ = *ii++; + *op++ = *ii++; + *op++ = *ii++; goto code_match; } + if (*m_pos == ip[3]) #endif goto match; @@ -125,19 +141,22 @@ try_match: } - /* a literal */ + /* a literal */ literal: - UPDATE_I(dict,0,dindex,ip,in); + UPDATE_I(dict, 0, dindex, ip, in); + if (++ip >= ip_end) break; + continue; - /* a match */ + /* a match */ match: - UPDATE_I(dict,0,dindex,ip,in); + UPDATE_I(dict, 0, dindex, ip, in); /* store current literal run */ - lit = pd(ip,ii); + lit = pd(ip, ii); + if (lit > 0) { lzo_uint t = lit; @@ -151,28 +170,36 @@ match: lzo_uint tt = t - 31; *op++ = 0; + while (tt > 255) { tt -= 255; UA_SET1(op, 0); op++; } + assert(tt > 0); *op++ = LZO_BYTE(tt); } - do *op++ = *ii++; while (--t > 0); + + do* op++ = *ii++; + + while (--t > 0); } + assert(ii == ip); /* code the match */ ip += 3; + if (*m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++ || - *m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++) + *m_pos++ != *ip++ || *m_pos++ != *ip++ || *m_pos++ != *ip++) { --ip; m_len = pd(ip, ii); - assert(m_len >= 3); assert(m_len <= 8); + assert(m_len >= 3); + assert(m_len <= 8); if (m_off <= M2_MAX_OFFSET) { @@ -180,7 +207,7 @@ match: *op++ = LZO_BYTE(((m_len - 2) << 5) | ((m_off & 7) << 2)); *op++ = LZO_BYTE(m_off >> 3); } - else if (m_len == 3 && m_off <= 2*M2_MAX_OFFSET && lit > 0) + else if (m_len == 3 && m_off <= 2 * M2_MAX_OFFSET && lit > 0) { m_off -= 1; /* m_off -= M2_MAX_OFFSET; */ @@ -199,8 +226,10 @@ match: { const lzo_bytep end; end = in_end; + while (ip < end && *m_pos == *ip) m_pos++, ip++; + m_len = pd(ip, ii); } assert(m_len >= 3); @@ -211,29 +240,33 @@ match: { m_len -= 33; *op++ = M3_MARKER | 0; + while (m_len > 255) { m_len -= 255; UA_SET1(op, 0); op++; } + assert(m_len > 0); *op++ = LZO_BYTE(m_len); } + *op++ = LZO_BYTE((m_off & 63) << 2); *op++ = LZO_BYTE(m_off >> 6); } ii = ip; + if (ip >= ip_end) break; } /* store final literal run */ - if (pd(in_end,ii) > 0) + if (pd(in_end, ii) > 0) { - lzo_uint t = pd(in_end,ii); + lzo_uint t = pd(in_end, ii); if (t < 4 && op > out) op[-2] = LZO_BYTE(op[-2] | t); @@ -244,15 +277,18 @@ match: lzo_uint tt = t - 31; *op++ = 0; + while (tt > 255) { tt -= 255; UA_SET1(op, 0); op++; } + assert(tt > 0); *op++ = LZO_BYTE(tt); } + UA_COPYN(op, ii, t); op += t; } @@ -267,9 +303,9 @@ match: ************************************************************************/ LZO_PUBLIC(int) -lzo1f_1_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +lzo1f_1_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { lzo_bytep op = out; int r = LZO_E_OK; @@ -279,11 +315,15 @@ lzo1f_1_compress ( const lzo_bytep in , lzo_uint in_len, else if (in_len <= 10) { *op++ = LZO_BYTE(in_len); - do *op++ = *in++; while (--in_len > 0); + + do* op++ = *in++; + + while (--in_len > 0); + *out_len = pd(op, out); } else - r = do_compress(in,in_len,out,out_len,wrkmem); + r = do_compress(in, in_len, out, out_len, wrkmem); if (r == LZO_E_OK) { diff --git a/extern/lzo/src/lzo1f_9x.c b/extern/lzo/src/lzo1f_9x.c index 353aca0..a2c8d11 100644 --- a/extern/lzo/src/lzo1f_9x.c +++ b/extern/lzo/src/lzo1f_9x.c @@ -50,7 +50,7 @@ ************************************************************************/ static lzo_bytep -code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) +code_match(LZO_COMPRESS_T* c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off) { if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) { @@ -76,14 +76,17 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) { m_len -= M3_MAX_LEN; *op++ = M3_MARKER | 0; + while (m_len > 255) { m_len -= 255; *op++ = 0; } + assert(m_len > 0); *op++ = LZO_BYTE(m_len); } + *op++ = LZO_BYTE((m_off & 63) << 2); *op++ = LZO_BYTE(m_off >> 6); c->m3_m++; @@ -94,7 +97,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) static lzo_bytep -STORE_RUN ( lzo_bytep op, const lzo_bytep ii, lzo_uint t, lzo_bytep out ) +STORE_RUN(lzo_bytep op, const lzo_bytep ii, lzo_uint t, lzo_bytep out) { if (t < 4 && op > out) op[-2] = LZO_BYTE(op[-2] | t); @@ -105,15 +108,20 @@ STORE_RUN ( lzo_bytep op, const lzo_bytep ii, lzo_uint t, lzo_bytep out ) lzo_uint tt = t - 31; *op++ = 0; + while (tt > 255) { tt -= 255; *op++ = 0; } + assert(tt > 0); *op++ = LZO_BYTE(tt); } - do *op++ = *ii++; while (--t > 0); + + do* op++ = *ii++; + + while (--t > 0); return op; } @@ -124,25 +132,25 @@ STORE_RUN ( lzo_bytep op, const lzo_bytep ii, lzo_uint t, lzo_bytep out ) ************************************************************************/ LZO_EXTERN(int) -lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_callback_p cb, - lzo_uint max_chain ); +lzo1f_999_compress_callback(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_callback_p cb, + lzo_uint max_chain); LZO_PUBLIC(int) -lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_callback_p cb, - lzo_uint max_chain ) +lzo1f_999_compress_callback(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_callback_p cb, + lzo_uint max_chain) { lzo_bytep op; const lzo_bytep ii; lzo_uint lit; lzo_uint m_len, m_off; LZO_COMPRESS_T cc; - LZO_COMPRESS_T * const c = &cc; + LZO_COMPRESS_T* const c = &cc; lzo_swd_p const swd = (lzo_swd_p) wrkmem; int r; @@ -160,15 +168,19 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, lit = 0; c->r1_lit = c->r1_m_len = 0; - r = init_match(c,swd,NULL,0,0); + r = init_match(c, swd, NULL, 0, 0); + if (r != 0) return r; + if (max_chain > 0) swd->max_chain = max_chain; - r = find_match(c,swd,0,0); + r = find_match(c, swd, 0, 0); + if (r != 0) return r; + while (c->look > 0) { int lazy_match_min_gain = -1; @@ -178,13 +190,15 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, m_off = c->m_off; assert(c->ip - c->look >= in); + if (lit == 0) ii = c->ip - c->look; + assert(ii + lit == c->ip - c->look); assert(swd->b_char == *(c->ip - c->look)); if ((m_len < M2_MIN_LEN) || - (m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET)) + (m_len < M3_MIN_LEN && m_off > M2_MAX_OFFSET)) { m_len = 0; } @@ -208,12 +222,13 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, /* try a lazy match */ if (m_len > 0 && lazy_match_min_gain >= 0 && c->look > m_len) { - r = find_match(c,swd,1,0); - assert(r == 0); LZO_UNUSED(r); + r = find_match(c, swd, 1, 0); + assert(r == 0); + LZO_UNUSED(r); assert(c->look > 0); if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET && - c->m_off > M2_MAX_OFFSET) + c->m_off > M2_MAX_OFFSET) { lazy_match_min_gain += 1; } @@ -250,8 +265,10 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, ahead = 1; assert(ii + lit + 1 == c->ip - c->look); } + assert(m_len > 0); } + assert(ii + lit + ahead == c->ip - c->look); @@ -259,15 +276,16 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, { /* a literal */ lit++; - r = find_match(c,swd,1,0); - assert(r == 0); LZO_UNUSED(r); + r = find_match(c, swd, 1, 0); + assert(r == 0); + LZO_UNUSED(r); } else { /* 1 - store run */ if (lit > 0) { - op = STORE_RUN(op,ii,lit,out); + op = STORE_RUN(op, ii, lit, out); c->r1_m_len = m_len; c->r1_lit = lit; lit = 0; @@ -276,9 +294,10 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, c->r1_lit = c->r1_m_len = 0; /* 2 - code match */ - op = code_match(c,op,m_len,m_off); - r = find_match(c,swd,m_len,1+ahead); - assert(r == 0); LZO_UNUSED(r); + op = code_match(c, op, m_len, m_off); + r = find_match(c, swd, m_len, 1 + ahead); + assert(r == 0); + LZO_UNUSED(r); } c->codesize = pd(op, out); @@ -287,7 +306,7 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, /* store final run */ if (lit > 0) - op = STORE_RUN(op,ii,lit,out); + op = STORE_RUN(op, ii, lit, out); #if defined(LZO_EOF_CODE) *op++ = M3_MARKER | 1; @@ -305,8 +324,8 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, #if 0 printf("%ld %ld -> %ld: %ld %ld %ld %ld\n", - (long) c->textsize, (long)in_len, (long) c->codesize, - c->r1_r, c->m2_m, c->m3_m, c->lazy); + (long) c->textsize, (long)in_len, (long) c->codesize, + c->r1_r, c->m2_m, c->m3_m, c->lazy); #endif return LZO_E_OK; } @@ -318,11 +337,11 @@ lzo1f_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, ************************************************************************/ LZO_PUBLIC(int) -lzo1f_999_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +lzo1f_999_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { - return lzo1f_999_compress_callback(in,in_len,out,out_len,wrkmem, + return lzo1f_999_compress_callback(in, in_len, out, out_len, wrkmem, (lzo_callback_p) 0, 0); } diff --git a/extern/lzo/src/lzo1f_d.ch b/extern/lzo/src/lzo1f_d.ch index c5093c1..dc7d12a 100644 --- a/extern/lzo/src/lzo1f_d.ch +++ b/extern/lzo/src/lzo1f_d.ch @@ -34,9 +34,9 @@ ************************************************************************/ LZO_PUBLIC(int) -DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +DO_DECOMPRESS(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { lzo_bytep op; const lzo_bytep ip; @@ -58,6 +58,7 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, while (TEST_IP_AND_TEST_OP) { t = *ip++; + if (t > 31) goto match; @@ -65,6 +66,7 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, if (t == 0) { NEED_IP(1); + while (*ip == 0) { t += 255; @@ -72,22 +74,36 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, TEST_IV(t); NEED_IP(1); } + t += 31 + *ip++; } + /* copy literals */ - assert(t > 0); NEED_OP(t); NEED_IP(t+1); + assert(t > 0); + NEED_OP(t); + NEED_IP(t + 1); #if (LZO_OPT_UNALIGNED32) + if (t >= 4) { - do { + do + { UA_COPY4(op, ip); - op += 4; ip += 4; t -= 4; - } while (t >= 4); - if (t > 0) do *op++ = *ip++; while (--t > 0); + op += 4; + ip += 4; + t -= 4; + } + while (t >= 4); + + if (t > 0) do* op++ = *ip++; + + while (--t > 0); } else #endif - do *op++ = *ip++; while (--t > 0); + do* op++ = *ip++; + + while (--t > 0); t = *ip++; @@ -99,27 +115,35 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, m_pos = op - 1 - 0x800; m_pos -= (t >> 2) & 7; m_pos -= *ip++ << 3; - TEST_LB(m_pos); NEED_OP(3); - *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++; + TEST_LB(m_pos); + NEED_OP(3); + *op++ = *m_pos++; + *op++ = *m_pos++; + *op++ = *m_pos++; } else { match: + if (t < M3_MARKER) { m_pos = op - 1; m_pos -= (t >> 2) & 7; m_pos -= *ip++ << 3; t >>= 5; - TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); + TEST_LB(m_pos); + assert(t > 0); + NEED_OP(t + 3 - 1); goto copy_match; } else { t &= 31; + if (t == 0) { NEED_IP(1); + while (*ip == 0) { t += 255; @@ -127,8 +151,10 @@ match: TEST_OV(t); NEED_IP(1); } + t += 31 + *ip++; } + NEED_IP(2); m_pos = op; #if (LZO_OPT_UNALIGNED16) && (LZO_ABI_LITTLE_ENDIAN) @@ -138,38 +164,64 @@ match: m_pos -= *ip++ >> 2; m_pos -= *ip++ << 6; #endif + if (m_pos == op) goto eof_found; } /* copy match */ - TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); + TEST_LB(m_pos); + assert(t > 0); + NEED_OP(t + 3 - 1); #if (LZO_OPT_UNALIGNED32) + if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) { UA_COPY4(op, m_pos); - op += 4; m_pos += 4; t -= 4 - (3 - 1); - do { + op += 4; + m_pos += 4; + t -= 4 - (3 - 1); + + do + { UA_COPY4(op, m_pos); - op += 4; m_pos += 4; t -= 4; - } while (t >= 4); - if (t > 0) do *op++ = *m_pos++; while (--t > 0); + op += 4; + m_pos += 4; + t -= 4; + } + while (t >= 4); + + if (t > 0) do* op++ = *m_pos++; + + while (--t > 0); } else #endif { copy_match: - *op++ = *m_pos++; *op++ = *m_pos++; - do *op++ = *m_pos++; while (--t > 0); + *op++ = *m_pos++; + *op++ = *m_pos++; + + do* op++ = *m_pos++; + + while (--t > 0); } } + t = ip[-2] & 3; + if (t == 0) break; /* copy literals */ - assert(t > 0); NEED_OP(t); NEED_IP(t+1); - do *op++ = *ip++; while (--t > 0); + assert(t > 0); + NEED_OP(t); + NEED_IP(t + 1); + + do* op++ = *ip++; + + while (--t > 0); + t = *ip++; } } @@ -184,7 +236,7 @@ eof_found: assert(t == 1); *out_len = pd(op, out); return (ip == ip_end ? LZO_E_OK : - (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); + (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); #if defined(HAVE_NEED_IP) diff --git a/extern/lzo/src/lzo1f_d2.c b/extern/lzo/src/lzo1f_d2.c index f98f855..1f85621 100644 --- a/extern/lzo/src/lzo1f_d2.c +++ b/extern/lzo/src/lzo1f_d2.c @@ -35,13 +35,13 @@ #if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM) LZO_EXTERN(int) lzo1f_decompress_asm_fast_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_PUBLIC(int) lzo1f_decompress_asm_fast_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem) +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem) { return lzo1f_decompress_safe(src, src_len, dst, dst_len, wrkmem); } diff --git a/extern/lzo/src/lzo1x_9x.c b/extern/lzo/src/lzo1x_9x.c index 4432e48..65ce92e 100644 --- a/extern/lzo/src/lzo1x_9x.c +++ b/extern/lzo/src/lzo1x_9x.c @@ -86,17 +86,17 @@ /* this is a public functions, but there is no prototype in a header file */ LZO_EXTERN(int) -lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len, - lzo_callback_p cb, - int try_lazy_parm, - lzo_uint good_length, - lzo_uint max_lazy, - lzo_uint nice_length, - lzo_uint max_chain, - lzo_uint32_t flags ); +lzo1x_999_compress_internal(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len, + lzo_callback_p cb, + int try_lazy_parm, + lzo_uint good_length, + lzo_uint max_lazy, + lzo_uint nice_length, + lzo_uint max_chain, + lzo_uint32_t flags); /*********************************************************************** @@ -104,7 +104,7 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, ************************************************************************/ static lzo_bytep -code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) +code_match(LZO_COMPRESS_T* c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off) { lzo_uint x_len = m_len; lzo_uint x_off = m_off; @@ -112,38 +112,40 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) c->match_bytes += m_len; #if 0 -/* - static lzo_uint last_m_len = 0, last_m_off = 0; - static lzo_uint prev_m_off[4]; - static unsigned prev_m_off_ptr = 0; - unsigned i; + /* + static lzo_uint last_m_len = 0, last_m_off = 0; + static lzo_uint prev_m_off[4]; + static unsigned prev_m_off_ptr = 0; + unsigned i; - //if (m_len >= 3 && m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) - if (m_len >= 3 && m_len <= M2_MAX_LEN) - { - //if (m_len == last_m_len && m_off == last_m_off) - //printf("last_m_len + last_m_off\n"); - //else - if (m_off == last_m_off) - printf("last_m_off\n"); - else - { - for (i = 0; i < 4; i++) - if (m_off == prev_m_off[i]) - printf("prev_m_off %u: %5ld\n",i,(long)m_off); - } - } - last_m_len = m_len; - last_m_off = prev_m_off[prev_m_off_ptr] = m_off; - prev_m_off_ptr = (prev_m_off_ptr + 1) & 3; -*/ + //if (m_len >= 3 && m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) + if (m_len >= 3 && m_len <= M2_MAX_LEN) + { + //if (m_len == last_m_len && m_off == last_m_off) + //printf("last_m_len + last_m_off\n"); + //else + if (m_off == last_m_off) + printf("last_m_off\n"); + else + { + for (i = 0; i < 4; i++) + if (m_off == prev_m_off[i]) + printf("prev_m_off %u: %5ld\n",i,(long)m_off); + } + } + last_m_len = m_len; + last_m_off = prev_m_off[prev_m_off_ptr] = m_off; + prev_m_off_ptr = (prev_m_off_ptr + 1) & 3; + */ #endif assert(op > c->out); + if (m_len == 2) { assert(m_off <= M1_MAX_OFFSET); - assert(c->r1_lit > 0); assert(c->r1_lit < 4); + assert(c->r1_lit > 0); + assert(c->r1_lit < 4); m_off -= 1; #if defined(LZO1Z) *op++ = LZO_BYTE(M1_MARKER | (m_off >> 6)); @@ -154,6 +156,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) #endif c->m1a_m++; } + #if defined(LZO1Z) else if (m_len <= M2_MAX_LEN && (m_off <= M2_MAX_OFFSET || m_off == c->last_m_off)) #else @@ -172,6 +175,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) *op++ = LZO_BYTE(m_off >> 2); assert(op[-2] >= M2_MARKER); #elif defined(LZO1Z) + if (m_off == c->last_m_off) *op++ = LZO_BYTE(((m_len - 1) << 5) | (0x700 >> 6)); else @@ -180,6 +184,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) *op++ = LZO_BYTE(((m_len - 1) << 5) | (m_off >> 6)); *op++ = LZO_BYTE(m_off << 2); } + #endif c->m2_m++; } @@ -201,20 +206,24 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) { assert(m_len >= 3); m_off -= 1; + if (m_len <= M3_MAX_LEN) *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); else { m_len -= M3_MAX_LEN; *op++ = M3_MARKER | 0; + while (m_len > 255) { m_len -= 255; *op++ = 0; } + assert(m_len > 0); *op++ = LZO_BYTE(m_len); } + #if defined(LZO1Z) *op++ = LZO_BYTE(m_off >> 6); *op++ = LZO_BYTE(m_off << 2); @@ -229,23 +238,28 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) lzo_uint k; assert(m_len >= 3); - assert(m_off > 0x4000); assert(m_off <= 0xbfff); + assert(m_off > 0x4000); + assert(m_off <= 0xbfff); m_off -= 0x4000; k = (m_off & 0x4000) >> 11; + if (m_len <= M4_MAX_LEN) *op++ = LZO_BYTE(M4_MARKER | k | (m_len - 2)); else { m_len -= M4_MAX_LEN; *op++ = LZO_BYTE(M4_MARKER | k | 0); + while (m_len > 255) { m_len -= 255; *op++ = 0; } + assert(m_len > 0); *op++ = LZO_BYTE(m_len); } + #if defined(LZO1Z) *op++ = LZO_BYTE(m_off >> 6); *op++ = LZO_BYTE(m_off << 2); @@ -263,7 +277,7 @@ code_match ( LZO_COMPRESS_T *c, lzo_bytep op, lzo_uint m_len, lzo_uint m_off ) static lzo_bytep -STORE_RUN ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, lzo_uint t ) +STORE_RUN(LZO_COMPRESS_T* c, lzo_bytep op, const lzo_bytep ii, lzo_uint t) { c->lit_bytes += t; @@ -290,29 +304,34 @@ STORE_RUN ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, lzo_uint t ) lzo_uint tt = t - 18; *op++ = 0; + while (tt > 255) { tt -= 255; *op++ = 0; } + assert(tt > 0); *op++ = LZO_BYTE(tt); c->lit3_r++; } - do *op++ = *ii++; while (--t > 0); + + do* op++ = *ii++; + + while (--t > 0); return op; } static lzo_bytep -code_run ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, - lzo_uint lit, lzo_uint m_len ) +code_run(LZO_COMPRESS_T* c, lzo_bytep op, const lzo_bytep ii, + lzo_uint lit, lzo_uint m_len) { if (lit > 0) { assert(m_len >= 2); - op = STORE_RUN(c,op,ii,lit); + op = STORE_RUN(c, op, ii, lit); c->r1_m_len = m_len; c->r1_lit = lit; } @@ -332,42 +351,54 @@ code_run ( LZO_COMPRESS_T *c, lzo_bytep op, const lzo_bytep ii, ************************************************************************/ static lzo_uint -len_of_coded_match ( lzo_uint m_len, lzo_uint m_off, lzo_uint lit ) +len_of_coded_match(lzo_uint m_len, lzo_uint m_off, lzo_uint lit) { lzo_uint n = 4; if (m_len < 2) return 0; + if (m_len == 2) return (m_off <= M1_MAX_OFFSET && lit > 0 && lit < 4) ? 2 : 0; + if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) return 2; + if (m_len == M2_MIN_LEN && m_off <= MX_MAX_OFFSET && lit >= 4) return 2; + if (m_off <= M3_MAX_OFFSET) { if (m_len <= M3_MAX_LEN) return 3; + m_len -= M3_MAX_LEN; + while (m_len > 255) { m_len -= 255; n++; } + return n; } + if (m_off <= M4_MAX_OFFSET) { if (m_len <= M4_MAX_LEN) return 3; + m_len -= M4_MAX_LEN; + while (m_len > 255) { m_len -= 255; n++; } + return n; } + return 0; } @@ -377,12 +408,14 @@ min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2, { lzo_uint lazy_match_min_gain; - assert (ahead >= 1); + assert(ahead >= 1); lazy_match_min_gain = ahead; #if 0 + if (l3) lit2 -= ahead; + #endif if (lit1 <= 3) @@ -391,6 +424,7 @@ min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2, lazy_match_min_gain += (lit2 <= 18) ? 0 : 1; lazy_match_min_gain += (l2 - l1) * 2; + if (l3) lazy_match_min_gain -= (ahead - l3) * 2; @@ -398,9 +432,11 @@ min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2, lazy_match_min_gain = 0; #if 0 + if (l1 == 2) if (lazy_match_min_gain == 0) lazy_match_min_gain = 1; + #endif return lazy_match_min_gain; @@ -413,13 +449,14 @@ min_gain(lzo_uint ahead, lzo_uint lit1, lzo_uint lit2, lzo_uint l1, lzo_uint l2, #if !defined(NDEBUG) static -void assert_match( const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off ) +void assert_match(const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off) { - const LZO_COMPRESS_T *c = swd->c; + const LZO_COMPRESS_T* c = swd->c; lzo_uint d_off; assert(m_len >= 2); - if (m_off <= (lzo_uint) (c->bp - c->in)) + + if (m_off <= (lzo_uint)(c->bp - c->in)) { assert(c->bp - m_off + m_len < c->ip); assert(lzo_memcmp(c->bp, c->bp - m_off, m_len) == 0); @@ -427,8 +464,9 @@ void assert_match( const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off ) else { assert(swd->dict != NULL); - d_off = m_off - (lzo_uint) (c->bp - c->in); + d_off = m_off - (lzo_uint)(c->bp - c->in); assert(d_off <= swd->dict_len); + if (m_len > d_off) { assert(lzo_memcmp(c->bp, swd->dict_end - d_off, d_off) == 0); @@ -449,25 +487,30 @@ void assert_match( const lzo_swd_p swd, lzo_uint m_len, lzo_uint m_off ) #if defined(SWD_BEST_OFF) static void -better_match ( const lzo_swd_p swd, lzo_uint *m_len, lzo_uint *m_off ) +better_match(const lzo_swd_p swd, lzo_uint* m_len, lzo_uint* m_off) { #if defined(LZO1Z) - const LZO_COMPRESS_T *c = swd->c; + const LZO_COMPRESS_T* c = swd->c; #endif if (*m_len <= M2_MIN_LEN) return; + #if defined(LZO1Z) + if (*m_off == c->last_m_off && *m_len <= M2_MAX_LEN) return; + #if 1 + if (*m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && - c->last_m_off && swd->best_off[*m_len-1] == c->last_m_off) + c->last_m_off && swd->best_off[*m_len - 1] == c->last_m_off) { *m_len = *m_len - 1; *m_off = swd->best_off[*m_len]; return; } + #endif #endif @@ -475,38 +518,44 @@ better_match ( const lzo_swd_p swd, lzo_uint *m_len, lzo_uint *m_off ) return; #if 1 + /* M3/M4 -> M2 */ if (*m_off > M2_MAX_OFFSET && - *m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && - swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M2_MAX_OFFSET) + *m_len >= M2_MIN_LEN + 1 && *m_len <= M2_MAX_LEN + 1 && + swd->best_off[*m_len - 1] && swd->best_off[*m_len - 1] <= M2_MAX_OFFSET) { *m_len = *m_len - 1; *m_off = swd->best_off[*m_len]; return; } + #endif #if 1 + /* M4 -> M2 */ if (*m_off > M3_MAX_OFFSET && - *m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 && - swd->best_off[*m_len-2] && swd->best_off[*m_len-2] <= M2_MAX_OFFSET) + *m_len >= M4_MAX_LEN + 1 && *m_len <= M2_MAX_LEN + 2 && + swd->best_off[*m_len - 2] && swd->best_off[*m_len - 2] <= M2_MAX_OFFSET) { *m_len = *m_len - 2; *m_off = swd->best_off[*m_len]; return; } + #endif #if 1 + /* M4 -> M3 */ if (*m_off > M3_MAX_OFFSET && - *m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 && - swd->best_off[*m_len-1] && swd->best_off[*m_len-1] <= M3_MAX_OFFSET) + *m_len >= M4_MAX_LEN + 1 && *m_len <= M3_MAX_LEN + 1 && + swd->best_off[*m_len - 1] && swd->best_off[*m_len - 1] <= M3_MAX_OFFSET) { *m_len = *m_len - 1; *m_off = swd->best_off[*m_len]; } + #endif } @@ -518,24 +567,24 @@ better_match ( const lzo_swd_p swd, lzo_uint *m_len, lzo_uint *m_off ) ************************************************************************/ LZO_PUBLIC(int) -lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len, - lzo_callback_p cb, - int try_lazy_parm, - lzo_uint good_length, - lzo_uint max_lazy, - lzo_uint nice_length, - lzo_uint max_chain, - lzo_uint32_t flags ) +lzo1x_999_compress_internal(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len, + lzo_callback_p cb, + int try_lazy_parm, + lzo_uint good_length, + lzo_uint max_lazy, + lzo_uint nice_length, + lzo_uint max_chain, + lzo_uint32_t flags) { lzo_bytep op; const lzo_bytep ii; lzo_uint lit; lzo_uint m_len, m_off; LZO_COMPRESS_T cc; - LZO_COMPRESS_T * const c = &cc; + LZO_COMPRESS_T* const c = &cc; lzo_swd_p const swd = (lzo_swd_p) wrkmem; lzo_uint try_lazy; int r; @@ -551,20 +600,25 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, # error #endif -/* setup parameter defaults */ + /* setup parameter defaults */ /* number of lazy match tries */ try_lazy = (lzo_uint) try_lazy_parm; + if (try_lazy_parm < 0) try_lazy = 1; + /* reduce lazy match search if we already have a match with this length */ if (good_length == 0) good_length = 32; + /* do not try a lazy match if we already have a match with this length */ if (max_lazy == 0) max_lazy = 32; + /* stop searching for longer matches than this one */ if (nice_length == 0) nice_length = 0; + /* don't search more positions than this */ if (max_chain == 0) max_chain = SWD_MAX_CHAIN; @@ -582,17 +636,22 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, lit = 0; c->r1_lit = c->r1_m_len = 0; - r = init_match(c,swd,dict,dict_len,flags); + r = init_match(c, swd, dict, dict_len, flags); + if (r != 0) return r; + if (max_chain > 0) swd->max_chain = max_chain; + if (nice_length > 0) swd->nice_length = nice_length; - r = find_match(c,swd,0,0); + r = find_match(c, swd, 0, 0); + if (r != 0) return r; + while (c->look > 0) { lzo_uint ahead; @@ -606,21 +665,23 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, assert(c->bp == c->ip - c->look); assert(c->bp >= in); + if (lit == 0) ii = c->bp; + assert(ii + lit == c->bp); assert(swd->b_char == *(c->bp)); - if ( m_len < 2 || - (m_len == 2 && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4)) || + if (m_len < 2 || + (m_len == 2 && (m_off > M1_MAX_OFFSET || lit == 0 || lit >= 4)) || #if 1 - /* Do not accept this match for compressed-data compatibility - * with LZO v1.01 and before - * [ might be a problem for decompress() and optimize() ] - */ - (m_len == 2 && op == out) || + /* Do not accept this match for compressed-data compatibility + * with LZO v1.01 and before + * [ might be a problem for decompress() and optimize() ] + */ + (m_len == 2 && op == out) || #endif - (op == out && lit == 0)) + (op == out && lit == 0)) { /* a literal */ m_len = 0; @@ -634,24 +695,28 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, if (m_len == 0) { - /* a literal */ + /* a literal */ lit++; swd->max_chain = max_chain; - r = find_match(c,swd,1,0); - assert(r == 0); LZO_UNUSED(r); + r = find_match(c, swd, 1, 0); + assert(r == 0); + LZO_UNUSED(r); continue; } - /* a match */ + /* a match */ #if defined(SWD_BEST_OFF) + if (swd->use_best_off) - better_match(swd,&m_len,&m_off); + better_match(swd, &m_len, &m_off); + #endif - assert_match(swd,m_len,m_off); + assert_match(swd, m_len, m_off); /* shall we try a lazy match ? */ ahead = 0; + if (try_lazy == 0 || m_len >= max_lazy) { /* no */ @@ -661,7 +726,7 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, else { /* yes, try a lazy match */ - l1 = len_of_coded_match(m_len,m_off,lit); + l1 = len_of_coded_match(m_len, m_off, lit); assert(l1 > 0); #if 1 max_ahead = LZO_MIN(try_lazy, l1 - 1); @@ -679,63 +744,79 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, swd->max_chain = max_chain >> 2; else swd->max_chain = max_chain; - r = find_match(c,swd,1,0); + + r = find_match(c, swd, 1, 0); ahead++; - assert(r == 0); LZO_UNUSED(r); + assert(r == 0); + LZO_UNUSED(r); assert(c->look > 0); assert(ii + lit + ahead == c->bp); #if defined(LZO1Z) + if (m_off == c->last_m_off && c->m_off != c->last_m_off) if (m_len >= M2_MIN_LEN && m_len <= M2_MAX_LEN) c->m_len = 0; + #endif + if (c->m_len < m_len) continue; + #if 1 + if (c->m_len == m_len && c->m_off >= m_off) continue; + #endif #if defined(SWD_BEST_OFF) + if (swd->use_best_off) - better_match(swd,&c->m_len,&c->m_off); + better_match(swd, &c->m_len, &c->m_off); + #endif - l2 = len_of_coded_match(c->m_len,c->m_off,lit+ahead); + l2 = len_of_coded_match(c->m_len, c->m_off, lit + ahead); + if (l2 == 0) continue; + #if 0 + if (c->m_len == m_len && l2 >= l1) continue; + #endif #if 1 /* compressed-data compatibility [see above] */ - l3 = (op == out) ? 0 : len_of_coded_match(ahead,m_off,lit); + l3 = (op == out) ? 0 : len_of_coded_match(ahead, m_off, lit); #else - l3 = len_of_coded_match(ahead,m_off,lit); + l3 = len_of_coded_match(ahead, m_off, lit); #endif - lazy_match_min_gain = min_gain(ahead,lit,lit+ahead,l1,l2,l3); + lazy_match_min_gain = min_gain(ahead, lit, lit + ahead, l1, l2, l3); + if (c->m_len >= m_len + lazy_match_min_gain) { c->lazy++; - assert_match(swd,c->m_len,c->m_off); + assert_match(swd, c->m_len, c->m_off); if (l3) { /* code previous run */ - op = code_run(c,op,ii,lit,ahead); + op = code_run(c, op, ii, lit, ahead); lit = 0; /* code shortened match */ - op = code_match(c,op,ahead,m_off); + op = code_match(c, op, ahead, m_off); } else { lit += ahead; assert(ii + lit == c->bp); } + goto lazy_match_done; } } @@ -744,22 +825,24 @@ lzo1x_999_compress_internal ( const lzo_bytep in , lzo_uint in_len, assert(ii + lit + ahead == c->bp); /* 1 - code run */ - op = code_run(c,op,ii,lit,m_len); + op = code_run(c, op, ii, lit, m_len); lit = 0; /* 2 - code match */ - op = code_match(c,op,m_len,m_off); + op = code_match(c, op, m_len, m_off); swd->max_chain = max_chain; - r = find_match(c,swd,m_len,1+ahead); - assert(r == 0); LZO_UNUSED(r); + r = find_match(c, swd, m_len, 1 + ahead); + assert(r == 0); + LZO_UNUSED(r); -lazy_match_done: ; +lazy_match_done: + ; } /* store final run */ if (lit > 0) - op = STORE_RUN(c,op,ii,lit); + op = STORE_RUN(c, op, ii, lit); #if defined(LZO_EOF_CODE) *op++ = M4_MARKER | 1; @@ -777,9 +860,9 @@ lazy_match_done: ; #if 0 printf("%ld %ld -> %ld %ld: %ld %ld %ld %ld %ld %ld: %ld %ld %ld %ld\n", - (long) c->textsize, (long) in_len, (long) c->codesize, - c->match_bytes, c->m1a_m, c->m1b_m, c->m2_m, c->m3_m, c->m4_m, - c->lit_bytes, c->lit1_r, c->lit2_r, c->lit3_r, c->lazy); + (long) c->textsize, (long) in_len, (long) c->codesize, + c->match_bytes, c->m1a_m, c->m1b_m, c->m2_m, c->m3_m, c->m4_m, + c->lit_bytes, c->lit1_r, c->lit2_r, c->lit3_r, c->lazy); #endif assert(c->lit_bytes + c->match_bytes == in_len); @@ -792,12 +875,12 @@ lazy_match_done: ; ************************************************************************/ LZO_PUBLIC(int) -lzo1x_999_compress_level ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len, - lzo_callback_p cb, - int compression_level ) +lzo1x_999_compress_level(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len, + lzo_callback_p cb, + int compression_level) { static const struct { @@ -807,7 +890,8 @@ lzo1x_999_compress_level ( const lzo_bytep in , lzo_uint in_len, lzo_uint nice_length; lzo_uint max_chain; lzo_uint32_t flags; - } c[9] = { + } c[9] = + { /* faster compression */ { 0, 0, 0, 8, 4, 0 }, { 0, 0, 0, 16, 8, 0 }, @@ -845,19 +929,19 @@ lzo1x_999_compress_level ( const lzo_bytep in , lzo_uint in_len, ************************************************************************/ LZO_PUBLIC(int) -lzo1x_999_compress_dict ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - const lzo_bytep dict, lzo_uint dict_len ) +lzo1x_999_compress_dict(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + const lzo_bytep dict, lzo_uint dict_len) { return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem, dict, dict_len, 0, 8); } LZO_PUBLIC(int) -lzo1x_999_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +lzo1x_999_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { return lzo1x_999_compress_level(in, in_len, out, out_len, wrkmem, NULL, 0, (lzo_callback_p) 0, 8); diff --git a/extern/lzo/src/lzo1x_c.ch b/extern/lzo/src/lzo1x_c.ch index 562e0b1..8abee03 100644 --- a/extern/lzo/src/lzo1x_c.ch +++ b/extern/lzo/src/lzo1x_c.ch @@ -28,7 +28,7 @@ #if 1 && defined(DO_COMPRESS) && !defined(do_compress) - /* choose a unique name to better help PGO optimizations */ +/* choose a unique name to better help PGO optimizations */ # define do_compress LZO_PP_ECONCAT2(DO_COMPRESS,_core) #endif @@ -38,9 +38,9 @@ ************************************************************************/ static __lzo_noinline lzo_uint -do_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_uint ti, lzo_voidp wrkmem) +do_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_uint ti, lzo_voidp wrkmem) { const lzo_bytep ip; lzo_bytep op; @@ -54,6 +54,7 @@ do_compress ( const lzo_bytep in , lzo_uint in_len, ii = ip; ip += ti < 4 ? 4 - ti : 0; + for (;;) { const lzo_bytep m_pos; @@ -62,26 +63,36 @@ do_compress ( const lzo_bytep in , lzo_uint in_len, lzo_uint m_len; lzo_uint dindex; next: + if __lzo_unlikely(ip >= ip_end) break; - DINDEX1(dindex,ip); - GINDEX(m_pos,m_off,dict,dindex,in); - if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) + + DINDEX1(dindex, ip); + GINDEX(m_pos, m_off, dict, dindex, in); + + if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M4_MAX_OFFSET)) goto literal; + #if 1 + if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) goto try_match; - DINDEX2(dindex,ip); + + DINDEX2(dindex, ip); #endif - GINDEX(m_pos,m_off,dict,dindex,in); - if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET)) + GINDEX(m_pos, m_off, dict, dindex, in); + + if (LZO_CHECK_MPOS_NON_DET(m_pos, m_off, in, ip, M4_MAX_OFFSET)) goto literal; + if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3]) goto try_match; + goto literal; try_match: #if (LZO_OPT_UNALIGNED32) + if (UA_GET_NE32(m_pos) != UA_GET_NE32(ip)) #else if (m_pos[0] != ip[0] || m_pos[1] != ip[1] || m_pos[2] != ip[2] || m_pos[3] != ip[3]) @@ -89,187 +100,264 @@ try_match: { /* a literal */ literal: - UPDATE_I(dict,0,dindex,ip,in); + UPDATE_I(dict, 0, dindex, ip, in); ip += 1 + ((ip - ii) >> 5); continue; } -/*match:*/ - UPDATE_I(dict,0,dindex,ip,in); + + /*match:*/ + UPDATE_I(dict, 0, dindex, ip, in); #else lzo_uint m_off; lzo_uint m_len; { - lzo_uint32_t dv; - lzo_uint dindex; + lzo_uint32_t dv; + lzo_uint dindex; literal: - ip += 1 + ((ip - ii) >> 5); + ip += 1 + ((ip - ii) >> 5); next: - if __lzo_unlikely(ip >= ip_end) - break; - dv = UA_GET_LE32(ip); - dindex = DINDEX(dv,ip); - GINDEX(m_off,m_pos,in+dict,dindex,in); - UPDATE_I(dict,0,dindex,ip,in); - if __lzo_unlikely(dv != UA_GET_LE32(m_pos)) - goto literal; + + if __lzo_unlikely(ip >= ip_end) + break; + + dv = UA_GET_LE32(ip); + dindex = DINDEX(dv, ip); + GINDEX(m_off, m_pos, in + dict, dindex, in); + UPDATE_I(dict, 0, dindex, ip, in); + + if __lzo_unlikely(dv != UA_GET_LE32(m_pos)) + goto literal; } #endif - /* a match */ + /* a match */ - ii -= ti; ti = 0; + ii -= ti; + ti = 0; { - lzo_uint t = pd(ip,ii); - if (t != 0) - { - if (t <= 3) + lzo_uint t = pd(ip, ii); + + if (t != 0) { - op[-2] = LZO_BYTE(op[-2] | t); + if (t <= 3) + { + op[-2] = LZO_BYTE(op[-2] | t); #if (LZO_OPT_UNALIGNED32) - UA_COPY4(op, ii); - op += t; + UA_COPY4(op, ii); + op += t; #else - { do *op++ = *ii++; while (--t > 0); } + { do* op++ = *ii++; while (--t > 0); } #endif - } + } + #if (LZO_OPT_UNALIGNED32) || (LZO_OPT_UNALIGNED64) - else if (t <= 16) - { - *op++ = LZO_BYTE(t - 3); - UA_COPY8(op, ii); - UA_COPY8(op+8, ii+8); - op += t; - } -#endif - else - { - if (t <= 18) + else if (t <= 16) + { *op++ = LZO_BYTE(t - 3); + UA_COPY8(op, ii); + UA_COPY8(op + 8, ii + 8); + op += t; + } + +#endif else { - lzo_uint tt = t - 18; - *op++ = 0; - while __lzo_unlikely(tt > 255) + if (t <= 18) + *op++ = LZO_BYTE(t - 3); + else { - tt -= 255; - UA_SET1(op, 0); - op++; + lzo_uint tt = t - 18; + *op++ = 0; + + while __lzo_unlikely(tt > 255) + { + tt -= 255; + UA_SET1(op, 0); + op++; + } + + assert(tt > 0); + *op++ = LZO_BYTE(tt); } - assert(tt > 0); - *op++ = LZO_BYTE(tt); - } + #if (LZO_OPT_UNALIGNED32) || (LZO_OPT_UNALIGNED64) - do { - UA_COPY8(op, ii); - UA_COPY8(op+8, ii+8); - op += 16; ii += 16; t -= 16; - } while (t >= 16); if (t > 0) + + do + { + UA_COPY8(op, ii); + UA_COPY8(op + 8, ii + 8); + op += 16; + ii += 16; + t -= 16; + } + while (t >= 16); + + if (t > 0) #endif - { do *op++ = *ii++; while (--t > 0); } + { do* op++ = *ii++; while (--t > 0); } + } } } - } m_len = 4; { #if (LZO_OPT_UNALIGNED64) - lzo_uint64_t v; - v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len); - if __lzo_unlikely(v == 0) { - do { - m_len += 8; - v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len); - if __lzo_unlikely(ip + m_len >= ip_end) - goto m_len_done; - } while (v == 0); - } + lzo_uint64_t v; + v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len); + + if __lzo_unlikely(v == 0) + { + do + { + m_len += 8; + v = UA_GET_NE64(ip + m_len) ^ UA_GET_NE64(m_pos + m_len); + + if __lzo_unlikely(ip + m_len >= ip_end) + goto m_len_done; + } + while (v == 0); + } + #if (LZO_ABI_BIG_ENDIAN) && defined(lzo_bitops_ctlz64) - m_len += lzo_bitops_ctlz64(v) / CHAR_BIT; + m_len += lzo_bitops_ctlz64(v) / CHAR_BIT; #elif (LZO_ABI_BIG_ENDIAN) - if ((v >> (64 - CHAR_BIT)) == 0) do { - v <<= CHAR_BIT; - m_len += 1; - } while ((v >> (64 - CHAR_BIT)) == 0); + + if ((v >> (64 - CHAR_BIT)) == 0) do + { + v <<= CHAR_BIT; + m_len += 1; + } + while ((v >> (64 - CHAR_BIT)) == 0); + #elif (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_cttz64) - m_len += lzo_bitops_cttz64(v) / CHAR_BIT; + m_len += lzo_bitops_cttz64(v) / CHAR_BIT; #elif (LZO_ABI_LITTLE_ENDIAN) - if ((v & UCHAR_MAX) == 0) do { - v >>= CHAR_BIT; - m_len += 1; - } while ((v & UCHAR_MAX) == 0); + + if ((v & UCHAR_MAX) == 0) do + { + v >>= CHAR_BIT; + m_len += 1; + } + while ((v & UCHAR_MAX) == 0); + #else - if (ip[m_len] == m_pos[m_len]) do { - m_len += 1; - } while (ip[m_len] == m_pos[m_len]); + + if (ip[m_len] == m_pos[m_len]) do + { + m_len += 1; + } + while (ip[m_len] == m_pos[m_len]); + #endif #elif (LZO_OPT_UNALIGNED32) - lzo_uint32_t v; - v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len); - if __lzo_unlikely(v == 0) { - do { - m_len += 4; - v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len); - if (v != 0) - break; - m_len += 4; - v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len); - if __lzo_unlikely(ip + m_len >= ip_end) - goto m_len_done; - } while (v == 0); - } + lzo_uint32_t v; + v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len); + + if __lzo_unlikely(v == 0) + { + do + { + m_len += 4; + v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len); + + if (v != 0) + break; + + m_len += 4; + v = UA_GET_NE32(ip + m_len) ^ UA_GET_NE32(m_pos + m_len); + + if __lzo_unlikely(ip + m_len >= ip_end) + goto m_len_done; + } + while (v == 0); + } + #if (LZO_ABI_BIG_ENDIAN) && defined(lzo_bitops_ctlz32) - m_len += lzo_bitops_ctlz32(v) / CHAR_BIT; + m_len += lzo_bitops_ctlz32(v) / CHAR_BIT; #elif (LZO_ABI_BIG_ENDIAN) - if ((v >> (32 - CHAR_BIT)) == 0) do { - v <<= CHAR_BIT; - m_len += 1; - } while ((v >> (32 - CHAR_BIT)) == 0); + + if ((v >> (32 - CHAR_BIT)) == 0) do + { + v <<= CHAR_BIT; + m_len += 1; + } + while ((v >> (32 - CHAR_BIT)) == 0); + #elif (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_cttz32) - m_len += lzo_bitops_cttz32(v) / CHAR_BIT; + m_len += lzo_bitops_cttz32(v) / CHAR_BIT; #elif (LZO_ABI_LITTLE_ENDIAN) - if ((v & UCHAR_MAX) == 0) do { - v >>= CHAR_BIT; - m_len += 1; - } while ((v & UCHAR_MAX) == 0); + + if ((v & UCHAR_MAX) == 0) do + { + v >>= CHAR_BIT; + m_len += 1; + } + while ((v & UCHAR_MAX) == 0); + #else - if (ip[m_len] == m_pos[m_len]) do { - m_len += 1; - } while (ip[m_len] == m_pos[m_len]); + + if (ip[m_len] == m_pos[m_len]) do + { + m_len += 1; + } + while (ip[m_len] == m_pos[m_len]); + #endif #else - if __lzo_unlikely(ip[m_len] == m_pos[m_len]) { - do { - m_len += 1; - if (ip[m_len] != m_pos[m_len]) - break; - m_len += 1; - if (ip[m_len] != m_pos[m_len]) - break; - m_len += 1; - if (ip[m_len] != m_pos[m_len]) - break; - m_len += 1; - if (ip[m_len] != m_pos[m_len]) - break; - m_len += 1; - if (ip[m_len] != m_pos[m_len]) - break; - m_len += 1; - if (ip[m_len] != m_pos[m_len]) - break; - m_len += 1; - if (ip[m_len] != m_pos[m_len]) - break; - m_len += 1; - if __lzo_unlikely(ip + m_len >= ip_end) - goto m_len_done; - } while (ip[m_len] == m_pos[m_len]); - } + + if __lzo_unlikely(ip[m_len] == m_pos[m_len]) + { + do + { + m_len += 1; + + if (ip[m_len] != m_pos[m_len]) + break; + + m_len += 1; + + if (ip[m_len] != m_pos[m_len]) + break; + + m_len += 1; + + if (ip[m_len] != m_pos[m_len]) + break; + + m_len += 1; + + if (ip[m_len] != m_pos[m_len]) + break; + + m_len += 1; + + if (ip[m_len] != m_pos[m_len]) + break; + + m_len += 1; + + if (ip[m_len] != m_pos[m_len]) + break; + + m_len += 1; + + if (ip[m_len] != m_pos[m_len]) + break; + + m_len += 1; + + if __lzo_unlikely(ip + m_len >= ip_end) + goto m_len_done; + } + while (ip[m_len] == m_pos[m_len]); + } + #endif } m_len_done: - m_off = pd(ip,m_pos); + m_off = pd(ip, m_pos); ip += m_len; ii = ip; + if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET) { m_off -= 1; @@ -284,48 +372,57 @@ m_len_done: else if (m_off <= M3_MAX_OFFSET) { m_off -= 1; + if (m_len <= M3_MAX_LEN) *op++ = LZO_BYTE(M3_MARKER | (m_len - 2)); else { m_len -= M3_MAX_LEN; *op++ = M3_MARKER | 0; + while __lzo_unlikely(m_len > 255) { m_len -= 255; UA_SET1(op, 0); op++; } + *op++ = LZO_BYTE(m_len); } + *op++ = LZO_BYTE(m_off << 2); *op++ = LZO_BYTE(m_off >> 6); } else { m_off -= 0x4000; + if (m_len <= M4_MAX_LEN) *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8) | (m_len - 2)); else { m_len -= M4_MAX_LEN; *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8)); + while __lzo_unlikely(m_len > 255) { m_len -= 255; UA_SET1(op, 0); op++; } + *op++ = LZO_BYTE(m_len); } + *op++ = LZO_BYTE(m_off << 2); *op++ = LZO_BYTE(m_off >> 6); } + goto next; } *out_len = pd(op, out); - return pd(in_end,ii-ti); + return pd(in_end, ii - ti); } @@ -334,9 +431,9 @@ m_len_done: ************************************************************************/ LZO_PUBLIC(int) -DO_COMPRESS ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +DO_COMPRESS(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { const lzo_bytep ip = in; lzo_bytep op = out; @@ -351,16 +448,19 @@ DO_COMPRESS ( const lzo_bytep in , lzo_uint in_len, ll = LZO_MIN(ll, 49152); #endif ll_end = (lzo_uintptr_t)ip + ll; + if ((ll_end + ((t + ll) >> 5)) <= ll_end || (const lzo_bytep)(ll_end + ((t + ll) >> 5)) <= ip + ll) break; + #if (LZO_DETERMINISTIC) lzo_memset(wrkmem, 0, ((lzo_uint)1 << D_BITS) * sizeof(lzo_dict_t)); #endif - t = do_compress(ip,ll,op,out_len,t,wrkmem); + t = do_compress(ip, ll, op, out_len, t, wrkmem); ip += ll; op += *out_len; l -= ll; } + t += l; if (t > 0) @@ -378,15 +478,18 @@ DO_COMPRESS ( const lzo_bytep in , lzo_uint in_len, lzo_uint tt = t - 18; *op++ = 0; + while (tt > 255) { tt -= 255; UA_SET1(op, 0); op++; } + assert(tt > 0); *op++ = LZO_BYTE(tt); } + UA_COPYN(op, ii, t); op += t; } diff --git a/extern/lzo/src/lzo1x_d.ch b/extern/lzo/src/lzo1x_d.ch index 5107f5f..6a418e5 100644 --- a/extern/lzo/src/lzo1x_d.ch +++ b/extern/lzo/src/lzo1x_d.ch @@ -35,9 +35,9 @@ #if defined(DO_DECOMPRESS) LZO_PUBLIC(int) -DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +DO_DECOMPRESS(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) #endif { lzo_bytep op; @@ -61,6 +61,7 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, LZO_UNUSED(wrkmem); #if defined(COPY_DICT) + if (dict) { if (dict_len > M4_MAX_OFFSET) @@ -68,6 +69,7 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, dict += dict_len - M4_MAX_OFFSET; dict_len = M4_MAX_OFFSET; } + dict_end = dict + dict_len; } else @@ -75,6 +77,7 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, dict_len = 0; dict_end = NULL; } + #endif /* COPY_DICT */ *out_len = 0; @@ -83,13 +86,22 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, ip = in; NEED_IP(1); + if (*ip > 17) { t = *ip++ - 17; + if (t < 4) goto match_next; - assert(t > 0); NEED_OP(t); NEED_IP(t+3); - do *op++ = *ip++; while (--t > 0); + + assert(t > 0); + NEED_OP(t); + NEED_IP(t + 3); + + do* op++ = *ip++; + + while (--t > 0); + goto first_literal_run; } @@ -97,8 +109,10 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, { NEED_IP(3); t = *ip++; + if (t >= 16) goto match; + /* a literal run */ if (t == 0) { @@ -109,47 +123,74 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, TEST_IV(t); NEED_IP(1); } + t += 15 + *ip++; } + /* copy literals */ - assert(t > 0); NEED_OP(t+3); NEED_IP(t+6); + assert(t > 0); + NEED_OP(t + 3); + NEED_IP(t + 6); #if (LZO_OPT_UNALIGNED64) && (LZO_OPT_UNALIGNED32) t += 3; + if (t >= 8) do - { - UA_COPY8(op,ip); - op += 8; ip += 8; t -= 8; - } while (t >= 8); + { + UA_COPY8(op, ip); + op += 8; + ip += 8; + t -= 8; + } + while (t >= 8); + if (t >= 4) { - UA_COPY4(op,ip); - op += 4; ip += 4; t -= 4; + UA_COPY4(op, ip); + op += 4; + ip += 4; + t -= 4; } + if (t > 0) { *op++ = *ip++; + if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } } + #elif (LZO_OPT_UNALIGNED32) || (LZO_ALIGNED_OK_4) #if !(LZO_OPT_UNALIGNED32) - if (PTR_ALIGNED2_4(op,ip)) + + if (PTR_ALIGNED2_4(op, ip)) { #endif - UA_COPY4(op,ip); - op += 4; ip += 4; - if (--t > 0) - { - if (t >= 4) + UA_COPY4(op, ip); + op += 4; + ip += 4; + + if (--t > 0) { - do { - UA_COPY4(op,ip); - op += 4; ip += 4; t -= 4; - } while (t >= 4); - if (t > 0) do *op++ = *ip++; while (--t > 0); + if (t >= 4) + { + do + { + UA_COPY4(op, ip); + op += 4; + ip += 4; + t -= 4; + } + while (t >= 4); + + if (t > 0) do* op++ = *ip++; + + while (--t > 0); + } + else + do* op++ = *ip++; + + while (--t > 0); } - else - do *op++ = *ip++; while (--t > 0); - } + #if !(LZO_OPT_UNALIGNED32) } else @@ -157,9 +198,15 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, #endif #if !(LZO_OPT_UNALIGNED32) { - *op++ = *ip++; *op++ = *ip++; *op++ = *ip++; - do *op++ = *ip++; while (--t > 0); + *op++ = *ip++; + *op++ = *ip++; + *op++ = *ip++; + + do* op++ = *ip++; + + while (--t > 0); } + #endif @@ -167,8 +214,10 @@ first_literal_run: t = *ip++; + if (t >= 16) goto match; + #if defined(COPY_DICT) #if defined(LZO1Z) m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); @@ -177,7 +226,8 @@ first_literal_run: m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2); #endif NEED_OP(3); - t = 3; COPY_DICT(t,m_off) + t = 3; + COPY_DICT(t, m_off) #else /* !COPY_DICT */ #if defined(LZO1Z) t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2); @@ -188,15 +238,20 @@ first_literal_run: m_pos -= t >> 2; m_pos -= *ip++ << 2; #endif - TEST_LB(m_pos); NEED_OP(3); - *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos; + TEST_LB(m_pos); + NEED_OP(3); + *op++ = *m_pos++; + *op++ = *m_pos++; + *op++ = *m_pos; #endif /* COPY_DICT */ goto match_done; /* handle matches */ - for (;;) { + for (;;) + { match: + if (t >= 64) /* a M2 match */ { #if defined(COPY_DICT) @@ -208,6 +263,7 @@ match: t = (t >> 4) - 3; #elif defined(LZO1Z) m_off = t & 0x1f; + if (m_off >= 0x1c) m_off = last_m_off; else @@ -215,6 +271,7 @@ match: m_off = 1 + (m_off << 6) + (*ip++ >> 2); last_m_off = m_off; } + t = (t >> 5) - 1; #endif #else /* !COPY_DICT */ @@ -232,6 +289,7 @@ match: { lzo_uint off = t & 0x1f; m_pos = op; + if (off >= 0x1c) { assert(last_m_off > 0); @@ -246,13 +304,16 @@ match: } t = (t >> 5) - 1; #endif - TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); + TEST_LB(m_pos); + assert(t > 0); + NEED_OP(t + 3 - 1); goto copy_match; #endif /* COPY_DICT */ } else if (t >= 32) /* a M3 match */ { t &= 31; + if (t == 0) { while (*ip == 0) @@ -262,9 +323,11 @@ match: TEST_OV(t); NEED_IP(1); } + t += 31 + *ip++; NEED_IP(2); } + #if defined(COPY_DICT) #if defined(LZO1Z) m_off = 1 + (ip[0] << 6) + (ip[1] >> 2); @@ -298,6 +361,7 @@ match: m_pos -= (t & 8) << 11; #endif /* COPY_DICT */ t &= 7; + if (t == 0) { while (*ip == 0) @@ -307,9 +371,11 @@ match: TEST_OV(t); NEED_IP(1); } + t += 7 + *ip++; NEED_IP(2); } + #if defined(COPY_DICT) #if defined(LZO1Z) m_off += (ip[0] << 6) + (ip[1] >> 2); @@ -317,8 +383,10 @@ match: m_off += (ip[0] >> 2) + (ip[1] << 6); #endif ip += 2; + if (m_off == 0) goto eof_found; + m_off += 0x4000; #if defined(LZO1Z) last_m_off = m_off; @@ -332,8 +400,10 @@ match: m_pos -= (ip[0] >> 2) + (ip[1] << 6); #endif ip += 2; + if (m_pos == op) goto eof_found; + m_pos -= 0x4000; #if defined(LZO1Z) last_m_off = pd((const lzo_bytep)op, m_pos); @@ -350,7 +420,8 @@ match: m_off = 1 + (t >> 2) + (*ip++ << 2); #endif NEED_OP(2); - t = 2; COPY_DICT(t,m_off) + t = 2; + COPY_DICT(t, m_off) #else /* !COPY_DICT */ #if defined(LZO1Z) t = 1 + (t << 6) + (*ip++ >> 2); @@ -361,8 +432,10 @@ match: m_pos -= t >> 2; m_pos -= *ip++ << 2; #endif - TEST_LB(m_pos); NEED_OP(2); - *op++ = *m_pos++; *op++ = *m_pos; + TEST_LB(m_pos); + NEED_OP(2); + *op++ = *m_pos++; + *op++ = *m_pos; #endif /* COPY_DICT */ goto match_done; } @@ -370,56 +443,84 @@ match: /* copy match */ #if defined(COPY_DICT) - NEED_OP(t+3-1); - t += 3-1; COPY_DICT(t,m_off) + NEED_OP(t + 3 - 1); + t += 3 - 1; + COPY_DICT(t, m_off) #else /* !COPY_DICT */ - TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1); + TEST_LB(m_pos); + assert(t > 0); + NEED_OP(t + 3 - 1); #if (LZO_OPT_UNALIGNED64) && (LZO_OPT_UNALIGNED32) + if (op - m_pos >= 8) { t += (3 - 1); + if (t >= 8) do - { - UA_COPY8(op,m_pos); - op += 8; m_pos += 8; t -= 8; - } while (t >= 8); + { + UA_COPY8(op, m_pos); + op += 8; + m_pos += 8; + t -= 8; + } + while (t >= 8); + if (t >= 4) { - UA_COPY4(op,m_pos); - op += 4; m_pos += 4; t -= 4; + UA_COPY4(op, m_pos); + op += 4; + m_pos += 4; + t -= 4; } + if (t > 0) { *op++ = m_pos[0]; + if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } } } } else #elif (LZO_OPT_UNALIGNED32) || (LZO_ALIGNED_OK_4) #if !(LZO_OPT_UNALIGNED32) - if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos)) + if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op, m_pos)) { assert((op - m_pos) >= 4); /* both pointers are aligned */ #else + if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4) { #endif - UA_COPY4(op,m_pos); - op += 4; m_pos += 4; t -= 4 - (3 - 1); - do { - UA_COPY4(op,m_pos); - op += 4; m_pos += 4; t -= 4; - } while (t >= 4); - if (t > 0) do *op++ = *m_pos++; while (--t > 0); + UA_COPY4(op, m_pos); + op += 4; + m_pos += 4; + t -= 4 - (3 - 1); + + do + { + UA_COPY4(op, m_pos); + op += 4; + m_pos += 4; + t -= 4; + } + while (t >= 4); + + if (t > 0) do* op++ = *m_pos++; + + while (--t > 0); } else #endif { copy_match: - *op++ = *m_pos++; *op++ = *m_pos++; - do *op++ = *m_pos++; while (--t > 0); + *op++ = *m_pos++; + *op++ = *m_pos++; + + do* op++ = *m_pos++; + + while (--t > 0); } #endif /* COPY_DICT */ @@ -430,17 +531,27 @@ match_done: #else t = ip[-2] & 3; #endif + if (t == 0) break; /* copy literals */ match_next: - assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+3); + assert(t > 0); + assert(t < 4); + NEED_OP(t); + NEED_IP(t + 3); #if 0 - do *op++ = *ip++; while (--t > 0); + + do* op++ = *ip++; + + while (--t > 0); + #else *op++ = *ip++; + if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } } + #endif t = *ip++; } @@ -449,7 +560,7 @@ match_next: eof_found: *out_len = pd(op, out); return (ip == ip_end ? LZO_E_OK : - (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); + (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); #if defined(HAVE_NEED_IP) diff --git a/extern/lzo/src/lzo1x_d2.c b/extern/lzo/src/lzo1x_d2.c index abe9463..1013b80 100644 --- a/extern/lzo/src/lzo1x_d2.c +++ b/extern/lzo/src/lzo1x_d2.c @@ -35,24 +35,24 @@ #if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM) LZO_EXTERN(int) lzo1x_decompress_asm_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_PUBLIC(int) lzo1x_decompress_asm_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem) +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem) { return lzo1x_decompress_safe(src, src_len, dst, dst_len, wrkmem); } LZO_EXTERN(int) lzo1x_decompress_asm_fast_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_PUBLIC(int) lzo1x_decompress_asm_fast_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem) +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem) { return lzo1x_decompress_safe(src, src_len, dst, dst_len, wrkmem); } diff --git a/extern/lzo/src/lzo1x_d3.c b/extern/lzo/src/lzo1x_d3.c index 8bde36f..1275053 100644 --- a/extern/lzo/src/lzo1x_d3.c +++ b/extern/lzo/src/lzo1x_d3.c @@ -81,10 +81,10 @@ LZO_PUBLIC(int) -lzo1x_decompress_dict_safe ( const lzo_bytep in, lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem /* NOT USED */, - const lzo_bytep dict, lzo_uint dict_len) +lzo1x_decompress_dict_safe(const lzo_bytep in, lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem /* NOT USED */, + const lzo_bytep dict, lzo_uint dict_len) #include "lzo1x_d.ch" diff --git a/extern/lzo/src/lzo1x_oo.ch b/extern/lzo/src/lzo1x_oo.ch index 82871bb..70bd553 100644 --- a/extern/lzo/src/lzo1x_oo.ch +++ b/extern/lzo/src/lzo1x_oo.ch @@ -41,6 +41,7 @@ static void copy2(lzo_bytep ip, const lzo_bytep m_pos, lzo_uint off) { assert(off > 0); ip[0] = m_pos[0]; + if (off == 1) ip[1] = m_pos[0]; else @@ -52,6 +53,7 @@ static void copy3(lzo_bytep ip, const lzo_bytep m_pos, lzo_uint off) { assert(off > 0); ip[0] = m_pos[0]; + if (off == 1) { ip[2] = ip[1] = m_pos[0]; @@ -74,9 +76,9 @@ static void copy3(lzo_bytep ip, const lzo_bytep m_pos, lzo_uint off) ************************************************************************/ LZO_PUBLIC(int) -DO_OPTIMIZE ( lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +DO_OPTIMIZE(lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { lzo_bytep op; lzo_bytep ip; @@ -98,41 +100,57 @@ DO_OPTIMIZE ( lzo_bytep in , lzo_uint in_len, ip = in; assert(in_len >= 3); + if (*ip > 17) { t = *ip++ - 17; + if (t < 4) goto match_next; + goto first_literal_run; } + assert(*ip < 16 || (*ip == 17 && in_len == 3)); while (TEST_IP_AND_TEST_OP) { t = *ip++; + if (t >= 16) goto match; + /* a literal run */ litp = ip - 1; + if (t == 0) { t = 15; + while (*ip == 0) t += 255, ip++; + t += *ip++; } + lit = t + 3; /* copy literals */ copy_literal_run: - *op++ = *ip++; *op++ = *ip++; *op++ = *ip++; + *op++ = *ip++; + *op++ = *ip++; + *op++ = *ip++; first_literal_run: - do *op++ = *ip++; while (--t > 0); + + do* op++ = *ip++; + + while (--t > 0); t = *ip++; if (t >= 16) goto match; + #if defined(LZO1X) m_pos = op - 1 - 0x800; #elif defined(LZO1Y) @@ -140,13 +158,16 @@ first_literal_run: #endif m_pos -= t >> 2; m_pos -= *ip++ << 2; - *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++; + *op++ = *m_pos++; + *op++ = *m_pos++; + *op++ = *m_pos++; lit = 0; goto match_done; /* handle matches */ - do { + do + { if (t < 16) /* a M1 match */ { m_pos = op - 1; @@ -161,6 +182,7 @@ first_literal_run: assert(litp == ip - 2 - lit - 2); assert((lzo_uint)(*litp & 3) == lit); nl = ip[-2] & 3; + /* test if a match follows */ if (nl == 0 && lit == 1 && ip[0] >= 16) { @@ -169,7 +191,7 @@ first_literal_run: lit += 2; *litp = LZO_BYTE((*litp & ~3) | lit); /* copy over the 2 literals that replace the match */ - copy2(ip-2,m_pos,pd(op,m_pos)); + copy2(ip - 2, m_pos, pd(op, m_pos)); o_m1_a++; } /* test if a literal run follows */ @@ -180,25 +202,32 @@ first_literal_run: /* remove short run */ *litp &= ~3; /* copy over the 2 literals that replace the match */ - copy2(ip-3+1,m_pos,pd(op,m_pos)); + copy2(ip - 3 + 1, m_pos, pd(op, m_pos)); /* move literals 1 byte ahead */ litp += 2; + if (lit > 0) - lzo_memmove(litp+1,litp,lit); + lzo_memmove(litp + 1, litp, lit); + /* insert new length of long literal run */ - lit += 2 + t + 3; assert(lit <= 18); + lit += 2 + t + 3; + assert(lit <= 18); *litp = LZO_BYTE(lit - 3); o_m1_b++; - *op++ = *m_pos++; *op++ = *m_pos++; + *op++ = *m_pos++; + *op++ = *m_pos++; goto copy_literal_run; } + copy_m1: - *op++ = *m_pos++; *op++ = *m_pos++; + *op++ = *m_pos++; + *op++ = *m_pos++; } else { match: + if (t >= 64) /* a M2 match */ { m_pos = op - 1; @@ -211,23 +240,28 @@ match: m_pos -= *ip++ << 2; t = (t >> 4) - 3; #endif + if (litp == NULL) goto copy_m; nl = ip[-2] & 3; + /* test if in beetween two long literal runs */ if (t == 1 && lit > 3 && nl == 0 && - ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16)) + ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16)) { assert(*litp == lit - 3); t = *ip++; /* copy over the 3 literals that replace the match */ - copy3(ip-1-2,m_pos,pd(op,m_pos)); + copy3(ip - 1 - 2, m_pos, pd(op, m_pos)); /* set new length of previous literal run */ - lit += 3 + t + 3; assert(lit <= 18); + lit += 3 + t + 3; + assert(lit <= 18); *litp = LZO_BYTE(lit - 3); o_m2++; - *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++; + *op++ = *m_pos++; + *op++ = *m_pos++; + *op++ = *m_pos++; goto copy_literal_run; } } @@ -236,13 +270,17 @@ match: if (t >= 32) /* a M3 match */ { t &= 31; + if (t == 0) { t = 31; + while (*ip == 0) t += 255, ip++; + t += *ip++; } + m_pos = op - 1; m_pos -= *ip++ >> 2; m_pos -= *ip++ << 6; @@ -252,23 +290,31 @@ match: m_pos = op; m_pos -= (t & 8) << 11; t &= 7; + if (t == 0) { t = 7; + while (*ip == 0) t += 255, ip++; + t += *ip++; } + m_pos -= *ip++ >> 2; m_pos -= *ip++ << 6; + if (m_pos == op) goto eof_found; + m_pos -= 0x4000; } + if (litp == NULL) goto copy_m; nl = ip[-2] & 3; + /* test if in beetween two matches */ if (t == 1 && lit == 0 && nl == 0 && ip[0] >= 16) { @@ -279,7 +325,7 @@ match: lit += 3; *litp = LZO_BYTE((*litp & ~3) | lit); /* copy over the 3 literals that replace the match */ - copy3(ip-3,m_pos,pd(op,m_pos)); + copy3(ip - 3, m_pos, pd(op, m_pos)); o_m3_a++; } /* test if a literal run follows */ @@ -292,26 +338,37 @@ match: /* remove short run */ *litp &= ~3; /* copy over the 3 literals that replace the match */ - copy3(ip-4+1,m_pos,pd(op,m_pos)); + copy3(ip - 4 + 1, m_pos, pd(op, m_pos)); /* move literals 1 byte ahead */ litp += 2; + if (lit > 0) - lzo_memmove(litp+1,litp,lit); + lzo_memmove(litp + 1, litp, lit); + /* insert new length of long literal run */ - lit += 3 + t + 3; assert(lit <= 18); + lit += 3 + t + 3; + assert(lit <= 18); *litp = LZO_BYTE(lit - 3); o_m3_b++; - *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos++; + *op++ = *m_pos++; + *op++ = *m_pos++; + *op++ = *m_pos++; goto copy_literal_run; } } + copy_m: - *op++ = *m_pos++; *op++ = *m_pos++; - do *op++ = *m_pos++; while (--t > 0); + *op++ = *m_pos++; + *op++ = *m_pos++; + + do* op++ = *m_pos++; + + while (--t > 0); } match_done: + if (next_lit == NO_LIT) { t = ip[-2] & 3; @@ -320,15 +377,23 @@ match_done: } else t = next_lit; + assert(t <= 3); next_lit = NO_LIT; + if (t == 0) break; + /* copy literals */ match_next: - do *op++ = *ip++; while (--t > 0); + + do* op++ = *ip++; + + while (--t > 0); + t = *ip++; - } while (TEST_IP_AND_TEST_OP); + } + while (TEST_IP_AND_TEST_OP); } /* no EOF code was found */ @@ -341,11 +406,14 @@ eof_found: printf("optimize: %5lu %5lu %5lu %5lu %5lu\n", o_m1_a, o_m1_b, o_m2, o_m3_a, o_m3_b); #endif - LZO_UNUSED(o_m1_a); LZO_UNUSED(o_m1_b); LZO_UNUSED(o_m2); - LZO_UNUSED(o_m3_a); LZO_UNUSED(o_m3_b); + LZO_UNUSED(o_m1_a); + LZO_UNUSED(o_m1_b); + LZO_UNUSED(o_m2); + LZO_UNUSED(o_m3_a); + LZO_UNUSED(o_m3_b); *out_len = pd(op, out); return (ip == ip_end ? LZO_E_OK : - (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); + (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); } diff --git a/extern/lzo/src/lzo1y_d2.c b/extern/lzo/src/lzo1y_d2.c index 2f14724..fd0d644 100644 --- a/extern/lzo/src/lzo1y_d2.c +++ b/extern/lzo/src/lzo1y_d2.c @@ -35,24 +35,24 @@ #if defined(LZO_ARCH_I386) && defined(LZO_USE_ASM) LZO_EXTERN(int) lzo1y_decompress_asm_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_PUBLIC(int) lzo1y_decompress_asm_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem) +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem) { return lzo1y_decompress_safe(src, src_len, dst, dst_len, wrkmem); } LZO_EXTERN(int) lzo1y_decompress_asm_fast_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem); +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem); LZO_PUBLIC(int) lzo1y_decompress_asm_fast_safe - (const lzo_bytep src, lzo_uint src_len, - lzo_bytep dst, lzo_uintp dst_len, - lzo_voidp wrkmem) +(const lzo_bytep src, lzo_uint src_len, + lzo_bytep dst, lzo_uintp dst_len, + lzo_voidp wrkmem) { return lzo1y_decompress_safe(src, src_len, dst, dst_len, wrkmem); } diff --git a/extern/lzo/src/lzo2a_9x.c b/extern/lzo/src/lzo2a_9x.c index 0e14916..46d9399 100644 --- a/extern/lzo/src/lzo2a_9x.c +++ b/extern/lzo/src/lzo2a_9x.c @@ -46,7 +46,7 @@ #if (LZO_CC_BORLANDC && LZO_MM_FLAT) # if ((__BORLANDC__) >= 0x0450 && (__BORLANDC__) < 0x0460) - /* avoid internal compiler error */ +/* avoid internal compiler error */ # pragma option -Od # endif #endif @@ -72,24 +72,24 @@ ************************************************************************/ LZO_EXTERN(int) -lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_callback_p cb, - lzo_uint max_chain ); +lzo2a_999_compress_callback(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_callback_p cb, + lzo_uint max_chain); LZO_PUBLIC(int) -lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem, - lzo_callback_p cb, - lzo_uint max_chain ) +lzo2a_999_compress_callback(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem, + lzo_callback_p cb, + lzo_uint max_chain) { lzo_bytep op; lzo_bytep bitp = 0; lzo_uint m_len, m_off; LZO_COMPRESS_T cc; - LZO_COMPRESS_T * const c = &cc; + LZO_COMPRESS_T* const c = &cc; lzo_swd_p const swd = (lzo_swd_p) wrkmem; int r; @@ -107,15 +107,19 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, op = out; - r = init_match(c,swd,NULL,0,0); + r = init_match(c, swd, NULL, 0, 0); + if (r != 0) return r; + if (max_chain > 0) swd->max_chain = max_chain; - r = find_match(c,swd,0,0); + r = find_match(c, swd, 0, 0); + if (r != 0) return r; + while (c->look > 0) { lzo_uint lazy_match_min_gain = 0; @@ -129,6 +133,7 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, m_off = c->m_off; #if (SWD_N >= 8192) + if (m_off >= 8192) { if (m_len < M3_MIN_LEN) @@ -138,25 +143,25 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, } else #endif - if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256) - { - lazy_match_min_gain = 2; + if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256) + { + lazy_match_min_gain = 2; #if (SWD_N >= 8192) - extra1 = 3; + extra1 = 3; #endif - extra2 = 2; - } - else if (m_len >= 10) - lazy_match_min_gain = 1; - else if (m_len >= 3) - { - lazy_match_min_gain = 1; + extra2 = 2; + } + else if (m_len >= 10) + lazy_match_min_gain = 1; + else if (m_len >= 3) + { + lazy_match_min_gain = 1; #if (SWD_N >= 8192) - extra1 = 1; + extra1 = 1; #endif - } - else - m_len = 0; + } + else + m_len = 0; /* try a lazy match */ @@ -164,25 +169,28 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, { unsigned char lit = LZO_BYTE(swd->b_char); - r = find_match(c,swd,1,0); - assert(r == 0); LZO_UNUSED(r); + r = find_match(c, swd, 1, 0); + assert(r == 0); + LZO_UNUSED(r); assert(c->look > 0); #if (SWD_N >= 8192) + if (m_off < 8192 && c->m_off >= 8192) lazy_match_min_gain += extra1; else #endif - if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256) - { - if (!(c->m_len >= M1_MIN_LEN && - c->m_len <= M1_MAX_LEN && c->m_off <= 256)) - lazy_match_min_gain += extra2; - } + if (m_len >= M1_MIN_LEN && m_len <= M1_MAX_LEN && m_off <= 256) + { + if (!(c->m_len >= M1_MIN_LEN && + c->m_len <= M1_MAX_LEN && c->m_off <= 256)) + lazy_match_min_gain += extra2; + } + if (c->m_len >= M1_MIN_LEN && - c->m_len <= M1_MAX_LEN && c->m_off <= 256) + c->m_len <= M1_MAX_LEN && c->m_off <= 256) { - lazy_match_min_gain -= 1; + lazy_match_min_gain -= 1; } if ((lzo_int) lazy_match_min_gain < 1) @@ -206,6 +214,7 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, } else ahead = 1; + assert(m_len > 0); } @@ -216,8 +225,9 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, putbit(0); putbyte(swd->b_char); c->lit_bytes++; - r = find_match(c,swd,1,0); - assert(r == 0); LZO_UNUSED(r); + r = find_match(c, swd, 1, 0); + assert(r == 0); + LZO_UNUSED(r); } else { @@ -230,10 +240,11 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, { putbit(1); putbit(0); - putbits(2,m_len - M1_MIN_LEN); + putbits(2, m_len - M1_MIN_LEN); putbyte(m_off - 1); c->m1++; } + #if (SWD_N >= 8192) else if (m_off >= 8192) { @@ -245,14 +256,17 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, putbyte(m_off >> 5); putbit(1); len -= M3_MIN_LEN - 1; + while (len > 255) { len -= 255; putbyte(0); } + putbyte(len); c->m4++; } + #endif else { @@ -260,6 +274,7 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, putbit(1); putbit(1); + if (m_len <= 9) { putbyte(((m_len - 2) << 5) | (m_off & 31)); @@ -275,17 +290,21 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, putbit(0); #endif len -= 10 - 1; + while (len > 255) { len -= 255; putbyte(0); } + putbyte(len); c->m3++; } } - r = find_match(c,swd,m_len,1+ahead); - assert(r == 0); LZO_UNUSED(r); + + r = find_match(c, swd, m_len, 1 + ahead); + assert(r == 0); + LZO_UNUSED(r); } c->codesize = pd(op, out); @@ -301,6 +320,7 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, /* flush remaining bits */ assert(k < CHAR_BIT); + if (k > 0) { assert(b == MASKBITS(k)); @@ -321,8 +341,8 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, #if 0 printf("%ld -> %ld: %ld %ld %ld %ld %ld %ld\n", - (long) c->textsize, (long) c->codesize, - c->lit_bytes, c->m1, c->m2, c->m3, c->m4, c->lazy); + (long) c->textsize, (long) c->codesize, + c->lit_bytes, c->m1, c->m2, c->m3, c->m4, c->lazy); #endif return LZO_E_OK; } @@ -334,11 +354,11 @@ lzo2a_999_compress_callback ( const lzo_bytep in , lzo_uint in_len, ************************************************************************/ LZO_PUBLIC(int) -lzo2a_999_compress ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +lzo2a_999_compress(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { - return lzo2a_999_compress_callback(in,in_len,out,out_len,wrkmem, + return lzo2a_999_compress_callback(in, in_len, out, out_len, wrkmem, (lzo_callback_p) 0, 0); } diff --git a/extern/lzo/src/lzo2a_d.ch b/extern/lzo/src/lzo2a_d.ch index dcd2b54..93498ea 100644 --- a/extern/lzo/src/lzo2a_d.ch +++ b/extern/lzo/src/lzo2a_d.ch @@ -37,9 +37,9 @@ #define _NEXTBYTE (*ip++) LZO_PUBLIC(int) -DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, - lzo_bytep out, lzo_uintp out_len, - lzo_voidp wrkmem ) +DO_DECOMPRESS(const lzo_bytep in , lzo_uint in_len, + lzo_bytep out, lzo_uintp out_len, + lzo_voidp wrkmem) { lzo_bytep op; const lzo_bytep ip; @@ -62,17 +62,21 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, while (TEST_IP_AND_TEST_OP) { NEEDBITS(1); + if (MASKBITS(1) == 0) { DUMPBITS(1); /* a literal */ - NEED_IP(1); NEED_OP(1); + NEED_IP(1); + NEED_OP(1); *op++ = *ip++; continue; } + DUMPBITS(1); NEEDBITS(1); + if (MASKBITS(1) == 0) { DUMPBITS(1); @@ -80,26 +84,31 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, NEEDBITS(2); t = M1_MIN_LEN + (lzo_uint) MASKBITS(2); DUMPBITS(2); - NEED_IP(1); NEED_OP(t); + NEED_IP(1); + NEED_OP(t); m_pos = op - 1 - *ip++; - assert(m_pos >= out); assert(m_pos < op); + assert(m_pos >= out); + assert(m_pos < op); TEST_LB(m_pos); - MEMCPY_DS(op,m_pos,t); + MEMCPY_DS(op, m_pos, t); continue; } + DUMPBITS(1); NEED_IP(2); t = *ip++; m_pos = op; - m_pos -= (t & 31) | (((lzo_uint) *ip++) << 5); + m_pos -= (t & 31) | (((lzo_uint) * ip++) << 5); t >>= 5; + if (t == 0) { #if (SWD_N >= 8192) NEEDBITS(1); t = MASKBITS(1); DUMPBITS(1); + if (t == 0) t = 10 - 1; else @@ -108,10 +117,12 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, m_pos -= 8192; /* t << 13 */ t = M3_MIN_LEN - 1; } + #else t = 10 - 1; #endif NEED_IP(1); + while (*ip == 0) { t += 255; @@ -119,20 +130,25 @@ DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len, TEST_OV(t); NEED_IP(1); } + t += *ip++; } else { #if defined(LZO_EOF_CODE) + if (m_pos == op) goto eof_found; + #endif t += 2; } - assert(m_pos >= out); assert(m_pos < op); + + assert(m_pos >= out); + assert(m_pos < op); TEST_LB(m_pos); NEED_OP(t); - MEMCPY_DS(op,m_pos,t); + MEMCPY_DS(op, m_pos, t); } @@ -148,7 +164,7 @@ eof_found: #endif *out_len = pd(op, out); return (ip == ip_end ? LZO_E_OK : - (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); + (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN)); #if defined(HAVE_NEED_IP) diff --git a/extern/lzo/src/lzo_conf.h b/extern/lzo/src/lzo_conf.h index 0690181..c1f1186 100644 --- a/extern/lzo/src/lzo_conf.h +++ b/extern/lzo/src/lzo_conf.h @@ -47,7 +47,7 @@ # error "include this file first" #endif #if defined(LZO_CFG_BUILD_DLL) && (LZO_CFG_BUILD_DLL+0) && !defined(__LZO_EXPORT1) && !defined(__LZO_EXPORT2) && 0 - /* idea: we could auto-define __LZO_EXPORT1 for DLL exports */ +/* idea: we could auto-define __LZO_EXPORT1 for DLL exports */ #ifndef __LZODEFS_H_INCLUDED #if defined(LZO_HAVE_CONFIG_H) # include @@ -56,8 +56,8 @@ #include #include #endif - /* #define __LZO_EXPORT1 __attribute__((__visibility__("default"))) */ - /* #define __LZO_EXPORT1 __declspec(dllexport) */ +/* #define __LZO_EXPORT1 __attribute__((__visibility__("default"))) */ +/* #define __LZO_EXPORT1 __declspec(dllexport) */ #endif #include #if defined(LZO_CFG_EXTRA_CONFIG_HEADER2) @@ -75,24 +75,24 @@ ************************************************************************/ #if (LZO_CC_MSC && (_MSC_VER >= 1000 && _MSC_VER < 1100)) - /* disable bogus "unreachable code" warnings */ +/* disable bogus "unreachable code" warnings */ # pragma warning(disable: 4702) #endif #if (LZO_CC_MSC && (_MSC_VER >= 1000)) # pragma warning(disable: 4127 4701) - /* disable warnings about inlining */ +/* disable warnings about inlining */ # pragma warning(disable: 4514 4710 4711) #endif #if (LZO_CC_MSC && (_MSC_VER >= 1300)) - /* disable '-Wall' warnings in system header files */ +/* disable '-Wall' warnings in system header files */ # pragma warning(disable: 4820) #endif #if (LZO_CC_MSC && (_MSC_VER >= 1800)) - /* disable '-Wall' warnings in system header files */ +/* disable '-Wall' warnings in system header files */ # pragma warning(disable: 4746) #endif #if (LZO_CC_INTELC && (__INTEL_COMPILER >= 900)) - /* disable pedantic warnings in system header files */ +/* disable pedantic warnings in system header files */ # pragma warning(disable: 1684) #endif @@ -277,8 +277,8 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint64_t) == 8) #if !defined(DMUL) #if 0 - /* 32*32 multiplies may be faster than 64*64 on some 64-bit machines, - * but then we need extra casts from unsigned<->size_t */ +/* 32*32 multiplies may be faster than 64*64 on some 64-bit machines, + * but then we need extra casts from unsigned<->size_t */ # define DMUL(a,b) ((lzo_xint) ((lzo_uint32_t)(a) * (lzo_uint32_t)(b))) #else # define DMUL(a,b) ((lzo_xint) ((a) * (b))) diff --git a/extern/lzo/src/lzo_crc.c b/extern/lzo/src/lzo_crc.c index b35ec23..70a5d98 100644 --- a/extern/lzo/src/lzo_crc.c +++ b/extern/lzo/src/lzo_crc.c @@ -35,59 +35,60 @@ // see http://www.zlib.org/ ************************************************************************/ -static const lzo_uint32_t lzo_crc32_table[256] = { - 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, - 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, - 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, - 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, - 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, - 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, - 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, - 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, - 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, - 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, - 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, - 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, - 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, - 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, - 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, - 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, - 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, - 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, - 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, - 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, - 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, - 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, - 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, - 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, - 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, - 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, - 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, - 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, - 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, - 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, - 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, - 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, - 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, - 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, - 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, - 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, - 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, - 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, - 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, - 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, - 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, - 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, - 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, - 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, - 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, - 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, - 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, - 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, - 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, - 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, - 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, - 0x2d02ef8dL +static const lzo_uint32_t lzo_crc32_table[256] = +{ + 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, + 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, + 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, + 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, + 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, + 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, + 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, + 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, + 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, + 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, + 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, + 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, + 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, + 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, + 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, + 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, + 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, + 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, + 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, + 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, + 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, + 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, + 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, + 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, + 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, + 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, + 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, + 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, + 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, + 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, + 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, + 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, + 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, + 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, + 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, + 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, + 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, + 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, + 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, + 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, + 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, + 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, + 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, + 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, + 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, + 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, + 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, + 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, + 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, + 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, + 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, + 0x2d02ef8dL }; @@ -119,25 +120,29 @@ lzo_crc32(lzo_uint32_t c, const lzo_bytep buf, lzo_uint len) #if 1 # define table lzo_crc32_table #else - const lzo_uint32_t * table = lzo_crc32_table; + const lzo_uint32_t* table = lzo_crc32_table; #endif if (buf == NULL) return 0; crc = (c & LZO_UINT32_C(0xffffffff)) ^ LZO_UINT32_C(0xffffffff); + if (len >= 16) do - { - LZO_DO16(buf,0); - buf += 16; - len -= 16; - } while (len >= 16); + { + LZO_DO16(buf, 0); + buf += 16; + len -= 16; + } + while (len >= 16); + if (len != 0) do - { - LZO_DO1(buf,0); - buf += 1; - len -= 1; - } while (len > 0); + { + LZO_DO1(buf, 0); + buf += 1; + len -= 1; + } + while (len > 0); return crc ^ LZO_UINT32_C(0xffffffff); #undef table diff --git a/extern/lzo/src/lzo_dict.h b/extern/lzo/src/lzo_dict.h index 68ec43f..b9a9d40 100644 --- a/extern/lzo/src/lzo_dict.h +++ b/extern/lzo/src/lzo_dict.h @@ -152,11 +152,11 @@ extern "C" { #if (LZO_HASH == LZO_HASH_GZIP) - /* hash function like in gzip/zlib (deflate) */ +/* hash function like in gzip/zlib (deflate) */ # define _DINDEX(dv,p) (_DV_A((p),DL_SHIFT)) #elif (LZO_HASH == LZO_HASH_GZIP_INCREMENTAL) - /* incremental hash like in gzip/zlib (deflate) */ +/* incremental hash like in gzip/zlib (deflate) */ # define __LZO_HASH_INCREMENTAL 1 # define DVAL_FIRST(dv,p) dv = _DV_A((p),DL_SHIFT) # define DVAL_NEXT(dv,p) dv = (((dv) << DL_SHIFT) ^ p[2]) @@ -164,7 +164,7 @@ extern "C" { # define DVAL_LOOKAHEAD DL_MIN_LEN #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_A) - /* incremental LZO hash version A */ +/* incremental LZO hash version A */ # define __LZO_HASH_INCREMENTAL 1 # define DVAL_FIRST(dv,p) dv = _DV_A((p),5) # define DVAL_NEXT(dv,p) \ @@ -173,7 +173,7 @@ extern "C" { # define DVAL_LOOKAHEAD DL_MIN_LEN #elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_B) - /* incremental LZO hash version B */ +/* incremental LZO hash version B */ # define __LZO_HASH_INCREMENTAL 1 # define DVAL_FIRST(dv,p) dv = _DV_B((p),5) # define DVAL_NEXT(dv,p) \ @@ -215,8 +215,8 @@ static void DVAL_ASSERT(lzo_xint dv, const lzo_bytep p) { lzo_xint df; - DVAL_FIRST(df,(p)); - assert(DINDEX(dv,p) == DINDEX(df,p)); + DVAL_FIRST(df, (p)); + assert(DINDEX(dv, p) == DINDEX(df, p)); } #else # define DVAL_ASSERT(dv,p) ((void) 0) diff --git a/extern/lzo/src/lzo_dll.ch b/extern/lzo/src/lzo_dll.ch index 6fda0bc..ef755e2 100644 --- a/extern/lzo/src/lzo_dll.ch +++ b/extern/lzo/src/lzo_dll.ch @@ -34,13 +34,16 @@ /* don't pull in - we don't need it */ #if 0 -BOOL FAR PASCAL LibMain ( HANDLE hInstance, WORD wDataSegment, - WORD wHeapSize, LPSTR lpszCmdLine ) +BOOL FAR PASCAL LibMain(HANDLE hInstance, WORD wDataSegment, + WORD wHeapSize, LPSTR lpszCmdLine) #else -int __far __pascal LibMain ( int a, short b, short c, long d ) +int __far __pascal LibMain(int a, short b, short c, long d) #endif { - LZO_UNUSED(a); LZO_UNUSED(b); LZO_UNUSED(c); LZO_UNUSED(d); + LZO_UNUSED(a); + LZO_UNUSED(b); + LZO_UNUSED(c); + LZO_UNUSED(d); return 1; } diff --git a/extern/lzo/src/lzo_func.h b/extern/lzo/src/lzo_func.h index 3c204da..b21007e 100644 --- a/extern/lzo/src/lzo_func.h +++ b/extern/lzo/src/lzo_func.h @@ -64,21 +64,28 @@ __lzo_static_forceinline unsigned lzo_bitops_ctlz32_func(lzo_uint32_t v) { #if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) - unsigned long r; (void) _BitScanReverse(&r, v); return (unsigned) r ^ 31; + unsigned long r; + (void) _BitScanReverse(&r, v); + return (unsigned) r ^ 31; #define lzo_bitops_ctlz32(v) lzo_bitops_ctlz32_func(v) #elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) lzo_uint32_t r; - __asm__("bsr %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC); + __asm__("bsr %1,%0" : "=r"(r) : "rm"(v) __LZO_ASM_CLOBBER_LIST_CC); return (unsigned) r ^ 31; #define lzo_bitops_ctlz32(v) lzo_bitops_ctlz32_func(v) #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_INT == 4) - unsigned r; r = (unsigned) __builtin_clz(v); return r; + unsigned r; + r = (unsigned) __builtin_clz(v); + return r; #define lzo_bitops_ctlz32(v) ((unsigned) __builtin_clz(v)) #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG == 8) && (LZO_WORDSIZE >= 8) - unsigned r; r = (unsigned) __builtin_clzl(v); return r ^ 32; + unsigned r; + r = (unsigned) __builtin_clzl(v); + return r ^ 32; #define lzo_bitops_ctlz32(v) (((unsigned) __builtin_clzl(v)) ^ 32) #else - LZO_UNUSED(v); return 0; + LZO_UNUSED(v); + return 0; #endif } @@ -86,21 +93,28 @@ __lzo_static_forceinline unsigned lzo_bitops_ctlz32_func(lzo_uint32_t v) __lzo_static_forceinline unsigned lzo_bitops_ctlz64_func(lzo_uint64_t v) { #if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64) - unsigned long r; (void) _BitScanReverse64(&r, v); return (unsigned) r ^ 63; + unsigned long r; + (void) _BitScanReverse64(&r, v); + return (unsigned) r ^ 63; #define lzo_bitops_ctlz64(v) lzo_bitops_ctlz64_func(v) #elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64) && (LZO_ASM_SYNTAX_GNUC) lzo_uint64_t r; - __asm__("bsr %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC); + __asm__("bsr %1,%0" : "=r"(r) : "rm"(v) __LZO_ASM_CLOBBER_LIST_CC); return (unsigned) r ^ 63; #define lzo_bitops_ctlz64(v) lzo_bitops_ctlz64_func(v) #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG == 8) && (LZO_WORDSIZE >= 8) - unsigned r; r = (unsigned) __builtin_clzl(v); return r; + unsigned r; + r = (unsigned) __builtin_clzl(v); + return r; #define lzo_bitops_ctlz64(v) ((unsigned) __builtin_clzl(v)) #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG_LONG == 8) && (LZO_WORDSIZE >= 8) - unsigned r; r = (unsigned) __builtin_clzll(v); return r; + unsigned r; + r = (unsigned) __builtin_clzll(v); + return r; #define lzo_bitops_ctlz64(v) ((unsigned) __builtin_clzll(v)) #else - LZO_UNUSED(v); return 0; + LZO_UNUSED(v); + return 0; #endif } #endif @@ -108,18 +122,23 @@ __lzo_static_forceinline unsigned lzo_bitops_ctlz64_func(lzo_uint64_t v) __lzo_static_forceinline unsigned lzo_bitops_cttz32_func(lzo_uint32_t v) { #if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) - unsigned long r; (void) _BitScanForward(&r, v); return (unsigned) r; + unsigned long r; + (void) _BitScanForward(&r, v); + return (unsigned) r; #define lzo_bitops_cttz32(v) lzo_bitops_cttz32_func(v) #elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) lzo_uint32_t r; - __asm__("bsf %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC); + __asm__("bsf %1,%0" : "=r"(r) : "rm"(v) __LZO_ASM_CLOBBER_LIST_CC); return (unsigned) r; #define lzo_bitops_cttz32(v) lzo_bitops_cttz32_func(v) #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_INT >= 4) - unsigned r; r = (unsigned) __builtin_ctz(v); return r; + unsigned r; + r = (unsigned) __builtin_ctz(v); + return r; #define lzo_bitops_cttz32(v) ((unsigned) __builtin_ctz(v)) #else - LZO_UNUSED(v); return 0; + LZO_UNUSED(v); + return 0; #endif } @@ -127,21 +146,28 @@ __lzo_static_forceinline unsigned lzo_bitops_cttz32_func(lzo_uint32_t v) __lzo_static_forceinline unsigned lzo_bitops_cttz64_func(lzo_uint64_t v) { #if (LZO_BITOPS_USE_MSC_BITSCAN) && (LZO_ARCH_AMD64) - unsigned long r; (void) _BitScanForward64(&r, v); return (unsigned) r; + unsigned long r; + (void) _BitScanForward64(&r, v); + return (unsigned) r; #define lzo_bitops_cttz64(v) lzo_bitops_cttz64_func(v) #elif (LZO_BITOPS_USE_ASM_BITSCAN) && (LZO_ARCH_AMD64) && (LZO_ASM_SYNTAX_GNUC) lzo_uint64_t r; - __asm__("bsf %1,%0" : "=r" (r) : "rm" (v) __LZO_ASM_CLOBBER_LIST_CC); + __asm__("bsf %1,%0" : "=r"(r) : "rm"(v) __LZO_ASM_CLOBBER_LIST_CC); return (unsigned) r; #define lzo_bitops_cttz64(v) lzo_bitops_cttz64_func(v) #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG >= 8) && (LZO_WORDSIZE >= 8) - unsigned r; r = (unsigned) __builtin_ctzl(v); return r; + unsigned r; + r = (unsigned) __builtin_ctzl(v); + return r; #define lzo_bitops_cttz64(v) ((unsigned) __builtin_ctzl(v)) #elif (LZO_BITOPS_USE_GNUC_BITSCAN) && (LZO_SIZEOF_LONG_LONG >= 8) && (LZO_WORDSIZE >= 8) - unsigned r; r = (unsigned) __builtin_ctzll(v); return r; + unsigned r; + r = (unsigned) __builtin_ctzll(v); + return r; #define lzo_bitops_cttz64(v) ((unsigned) __builtin_ctzll(v)) #else - LZO_UNUSED(v); return 0; + LZO_UNUSED(v); + return 0; #endif } #endif @@ -179,7 +205,7 @@ lzo_unused_funcs_impl(void, lzo_bitops_unused_funcs)(void) typedef lzo_uint16_t __lzo_may_alias lzo_memops_TU2; #define lzo_memops_TU2p volatile lzo_memops_TU2 * #elif defined(__lzo_byte_struct) -__lzo_byte_struct(lzo_memops_TU2_struct,2) +__lzo_byte_struct(lzo_memops_TU2_struct, 2) typedef struct lzo_memops_TU2_struct lzo_memops_TU2; #else struct lzo_memops_TU2_struct { unsigned char a[2]; } __lzo_may_alias; @@ -194,7 +220,7 @@ typedef struct lzo_memops_TU2_struct lzo_memops_TU2; typedef lzo_uint32_t __lzo_may_alias lzo_memops_TU4; #define lzo_memops_TU4p volatile lzo_memops_TU4 __LZO_MMODEL * #elif defined(__lzo_byte_struct) -__lzo_byte_struct(lzo_memops_TU4_struct,4) +__lzo_byte_struct(lzo_memops_TU4_struct, 4) typedef struct lzo_memops_TU4_struct lzo_memops_TU4; #else struct lzo_memops_TU4_struct { unsigned char a[4]; } __lzo_may_alias; @@ -209,7 +235,7 @@ typedef struct lzo_memops_TU4_struct lzo_memops_TU4; typedef lzo_uint64_t __lzo_may_alias lzo_memops_TU8; #define lzo_memops_TU8p volatile lzo_memops_TU8 __LZO_MMODEL * #elif defined(__lzo_byte_struct) -__lzo_byte_struct(lzo_memops_TU8_struct,8) +__lzo_byte_struct(lzo_memops_TU8_struct, 8) typedef struct lzo_memops_TU8_struct lzo_memops_TU8; #else struct lzo_memops_TU8_struct { unsigned char a[8]; } __lzo_may_alias; @@ -276,10 +302,10 @@ typedef struct lzo_memops_TU8_struct lzo_memops_TU8; d__8[0] = s__8[0]; d__8[1] = s__8[1]; d__8[2] = s__8[2]; d__8[3] = s__8[3]; \ d__8[4] = s__8[4]; d__8[5] = s__8[5]; d__8[6] = s__8[6]; d__8[7] = s__8[7]; \ LZO_BLOCK_END -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU1p)0)==1) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU1p)0) == 1) #define LZO_MEMOPS_COPY1(dd,ss) LZO_MEMOPS_MOVE1(dd,ss) #if (LZO_OPT_UNALIGNED16) -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0)==2) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0) == 2) #define LZO_MEMOPS_COPY2(dd,ss) \ * (lzo_memops_TU2p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss) #elif defined(lzo_memops_tcheck__) @@ -291,7 +317,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0)==2) #define LZO_MEMOPS_COPY2(dd,ss) LZO_MEMOPS_MOVE2(dd,ss) #endif #if (LZO_OPT_UNALIGNED32) -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0)==4) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0) == 4) #define LZO_MEMOPS_COPY4(dd,ss) \ * (lzo_memops_TU4p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss) #elif defined(lzo_memops_tcheck__) @@ -307,7 +333,7 @@ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0)==4) LZO_BLOCK_BEGIN LZO_MEMOPS_COPY4(dd,ss); LZO_MEMOPS_COPY4((lzo_memops_TU1p)(lzo_memops_TU0p)(dd)+4,(const lzo_memops_TU1p)(const lzo_memops_TU0p)(ss)+4); LZO_BLOCK_END #else #if (LZO_OPT_UNALIGNED64) -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU8p)0)==8) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU8p)0) == 8) #define LZO_MEMOPS_COPY8(dd,ss) \ * (lzo_memops_TU8p) (lzo_memops_TU0p) (dd) = * (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss) #elif (LZO_OPT_UNALIGNED32) @@ -340,11 +366,11 @@ __lzo_static_forceinline lzo_uint16_t lzo_memops_get_le16(const lzo_voidp ss) #elif (LZO_OPT_UNALIGNED16 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC) const lzo_memops_TU2p s = (const lzo_memops_TU2p) ss; unsigned long vv; - __asm__("lhbrx %0,0,%1" : "=r" (vv) : "r" (s), "m" (*s)); + __asm__("lhbrx %0,0,%1" : "=r"(vv) : "r"(s), "m"(*s)); v = (lzo_uint16_t) vv; #else const lzo_memops_TU1p s = (const lzo_memops_TU1p) ss; - v = (lzo_uint16_t) (((lzo_uint16_t)s[0]) | ((lzo_uint16_t)s[1] << 8)); + v = (lzo_uint16_t)(((lzo_uint16_t)s[0]) | ((lzo_uint16_t)s[1] << 8)); #endif return v; } @@ -362,11 +388,11 @@ __lzo_static_forceinline lzo_uint32_t lzo_memops_get_le32(const lzo_voidp ss) #elif (LZO_OPT_UNALIGNED32 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC) const lzo_memops_TU4p s = (const lzo_memops_TU4p) ss; unsigned long vv; - __asm__("lwbrx %0,0,%1" : "=r" (vv) : "r" (s), "m" (*s)); + __asm__("lwbrx %0,0,%1" : "=r"(vv) : "r"(s), "m"(*s)); v = (lzo_uint32_t) vv; #else const lzo_memops_TU1p s = (const lzo_memops_TU1p) ss; - v = (lzo_uint32_t) (((lzo_uint32_t)s[0]) | ((lzo_uint32_t)s[1] << 8) | ((lzo_uint32_t)s[2] << 16) | ((lzo_uint32_t)s[3] << 24)); + v = (lzo_uint32_t)(((lzo_uint32_t)s[0]) | ((lzo_uint32_t)s[1] << 8) | ((lzo_uint32_t)s[2] << 16) | ((lzo_uint32_t)s[3] << 24)); #endif return v; } @@ -387,7 +413,7 @@ __lzo_static_forceinline lzo_uint16_t lzo_memops_get_ne16(const lzo_voidp ss) return v; } #if (LZO_OPT_UNALIGNED16) -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0)==2) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU2p)0) == 2) #define LZO_MEMOPS_GET_NE16(ss) (* (const lzo_memops_TU2p) (const lzo_memops_TU0p) (ss)) #else #define LZO_MEMOPS_GET_NE16(ss) lzo_memops_get_ne16(ss) @@ -400,14 +426,14 @@ __lzo_static_forceinline lzo_uint32_t lzo_memops_get_ne32(const lzo_voidp ss) return v; } #if (LZO_OPT_UNALIGNED32) -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0)==4) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU4p)0) == 4) #define LZO_MEMOPS_GET_NE32(ss) (* (const lzo_memops_TU4p) (const lzo_memops_TU0p) (ss)) #else #define LZO_MEMOPS_GET_NE32(ss) lzo_memops_get_ne32(ss) #endif #if (LZO_OPT_UNALIGNED64) -LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU8p)0)==8) +LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(*(lzo_memops_TU8p)0) == 8) #define LZO_MEMOPS_GET_NE64(ss) (* (const lzo_memops_TU8p) (const lzo_memops_TU0p) (ss)) #endif @@ -418,10 +444,10 @@ __lzo_static_forceinline void lzo_memops_put_le16(lzo_voidp dd, lzo_uint16_t vv) #elif (LZO_OPT_UNALIGNED16 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC) lzo_memops_TU2p d = (lzo_memops_TU2p) dd; unsigned long v = vv; - __asm__("sthbrx %2,0,%1" : "=m" (*d) : "r" (d), "r" (v)); + __asm__("sthbrx %2,0,%1" : "=m"(*d) : "r"(d), "r"(v)); #else lzo_memops_TU1p d = (lzo_memops_TU1p) dd; - d[0] = LZO_BYTE((vv ) & 0xff); + d[0] = LZO_BYTE((vv) & 0xff); d[1] = LZO_BYTE((vv >> 8) & 0xff); #endif } @@ -438,10 +464,10 @@ __lzo_static_forceinline void lzo_memops_put_le32(lzo_voidp dd, lzo_uint32_t vv) #elif (LZO_OPT_UNALIGNED32 && LZO_ARCH_POWERPC && LZO_ABI_BIG_ENDIAN) && (LZO_ASM_SYNTAX_GNUC) lzo_memops_TU4p d = (lzo_memops_TU4p) dd; unsigned long v = vv; - __asm__("stwbrx %2,0,%1" : "=m" (*d) : "r" (d), "r" (v)); + __asm__("stwbrx %2,0,%1" : "=m"(*d) : "r"(d), "r"(v)); #else lzo_memops_TU1p d = (lzo_memops_TU1p) dd; - d[0] = LZO_BYTE((vv ) & 0xff); + d[0] = LZO_BYTE((vv) & 0xff); d[1] = LZO_BYTE((vv >> 8) & 0xff); d[2] = LZO_BYTE((vv >> 16) & 0xff); d[3] = LZO_BYTE((vv >> 24) & 0xff); diff --git a/extern/lzo/src/lzo_init.c b/extern/lzo/src/lzo_init.c index 142e95c..98b3849 100644 --- a/extern/lzo/src/lzo_init.c +++ b/extern/lzo/src/lzo_init.c @@ -48,14 +48,14 @@ #undef LZOCHK_ASSERT #include "lzo_supp.h" - LZOCHK_ASSERT((LZO_UINT32_C(1) << (int)(8*sizeof(LZO_UINT32_C(1))-1)) > 0) - LZOCHK_ASSERT_IS_SIGNED_T(lzo_int) - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint) +LZOCHK_ASSERT((LZO_UINT32_C(1) << (int)(8 * sizeof(LZO_UINT32_C(1)) - 1)) > 0) +LZOCHK_ASSERT_IS_SIGNED_T(lzo_int) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint) #if !(__LZO_UINTPTR_T_IS_POINTER) - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t) #endif - LZOCHK_ASSERT(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp)) - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_xint) +LZOCHK_ASSERT(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp)) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_xint) #endif #undef LZOCHK_ASSERT @@ -65,9 +65,10 @@ // ************************************************************************/ -union lzo_config_check_union { +union lzo_config_check_union +{ lzo_uint a[2]; - unsigned char b[2*LZO_MAX(8,sizeof(lzo_uint))]; + unsigned char b[2 * LZO_MAX(8, sizeof(lzo_uint))]; #if defined(lzo_uint64_t) lzo_uint64_t c[2]; #endif @@ -79,7 +80,7 @@ union lzo_config_check_union { #else static __lzo_noinline lzo_voidp u2p(lzo_voidp ptr, lzo_uint off) { - return (lzo_voidp) ((lzo_bytep) ptr + off); + return (lzo_voidp)((lzo_bytep) ptr + off); } #endif @@ -102,17 +103,20 @@ _lzo_config_check(void) r &= ((* (lzo_bytep) p) == 0); #if !(LZO_CFG_NO_CONFIG_CHECK) #if (LZO_ABI_BIG_ENDIAN) - u.a[0] = u.a[1] = 0; u.b[sizeof(lzo_uint) - 1] = 128; + u.a[0] = u.a[1] = 0; + u.b[sizeof(lzo_uint) - 1] = 128; p = u2p(&u, 0); r &= ((* (lzo_uintp) p) == 128); #endif #if (LZO_ABI_LITTLE_ENDIAN) - u.a[0] = u.a[1] = 0; u.b[0] = 128; + u.a[0] = u.a[1] = 0; + u.b[0] = 128; p = u2p(&u, 0); r &= ((* (lzo_uintp) p) == 128); #endif u.a[0] = u.a[1] = 0; - u.b[0] = 1; u.b[3] = 2; + u.b[0] = 1; + u.b[3] = 2; p = u2p(&u, 1); r &= UA_GET_NE16(p) == 0; r &= UA_GET_LE16(p) == 0; @@ -127,13 +131,16 @@ _lzo_config_check(void) r &= UA_GET_NE16(p) == LZO_UINT16_C(0x8180); #endif u.a[0] = u.a[1] = 0; - u.b[0] = 3; u.b[5] = 4; + u.b[0] = 3; + u.b[5] = 4; p = u2p(&u, 1); r &= UA_GET_NE32(p) == 0; r &= UA_GET_LE32(p) == 0; u.b[1] = 128; r &= UA_GET_LE32(p) == 128; - u.b[2] = 129; u.b[3] = 130; u.b[4] = 131; + u.b[2] = 129; + u.b[3] = 130; + u.b[4] = 131; r &= UA_GET_LE32(p) == LZO_UINT32_C(0x83828180); #if (LZO_ABI_BIG_ENDIAN) r &= UA_GET_NE32(p) == LZO_UINT32_C(0x80818283); @@ -143,7 +150,8 @@ _lzo_config_check(void) #endif #if defined(UA_GET_NE64) u.c[0] = u.c[1] = 0; - u.b[0] = 5; u.b[9] = 6; + u.b[0] = 5; + u.b[9] = 6; p = u2p(&u, 1); u.c[0] = u.c[1] = 0; r &= UA_GET_NE64(p) == 0; @@ -154,32 +162,52 @@ _lzo_config_check(void) #endif #endif #if defined(lzo_bitops_ctlz32) - { unsigned i = 0; lzo_uint32_t v; - for (v = 1; v != 0 && r == 1; v <<= 1, i++) { - r &= lzo_bitops_ctlz32(v) == 31 - i; - r &= lzo_bitops_ctlz32_func(v) == 31 - i; - }} + { + unsigned i = 0; + lzo_uint32_t v; + + for (v = 1; v != 0 && r == 1; v <<= 1, i++) + { + r &= lzo_bitops_ctlz32(v) == 31 - i; + r &= lzo_bitops_ctlz32_func(v) == 31 - i; + } + } #endif #if defined(lzo_bitops_ctlz64) - { unsigned i = 0; lzo_uint64_t v; - for (v = 1; v != 0 && r == 1; v <<= 1, i++) { - r &= lzo_bitops_ctlz64(v) == 63 - i; - r &= lzo_bitops_ctlz64_func(v) == 63 - i; - }} + { + unsigned i = 0; + lzo_uint64_t v; + + for (v = 1; v != 0 && r == 1; v <<= 1, i++) + { + r &= lzo_bitops_ctlz64(v) == 63 - i; + r &= lzo_bitops_ctlz64_func(v) == 63 - i; + } + } #endif #if defined(lzo_bitops_cttz32) - { unsigned i = 0; lzo_uint32_t v; - for (v = 1; v != 0 && r == 1; v <<= 1, i++) { - r &= lzo_bitops_cttz32(v) == i; - r &= lzo_bitops_cttz32_func(v) == i; - }} + { + unsigned i = 0; + lzo_uint32_t v; + + for (v = 1; v != 0 && r == 1; v <<= 1, i++) + { + r &= lzo_bitops_cttz32(v) == i; + r &= lzo_bitops_cttz32_func(v) == i; + } + } #endif #if defined(lzo_bitops_cttz64) - { unsigned i = 0; lzo_uint64_t v; - for (v = 1; v != 0 && r == 1; v <<= 1, i++) { - r &= lzo_bitops_cttz64(v) == i; - r &= lzo_bitops_cttz64_func(v) == i; - }} + { + unsigned i = 0; + lzo_uint64_t v; + + for (v = 1; v != 0 && r == 1; v <<= 1, i++) + { + r &= lzo_bitops_cttz64(v) == i; + r &= lzo_bitops_cttz64_func(v) == i; + } + } #endif #endif LZO_UNUSED_FUNC(lzo_bitops_unused_funcs); @@ -194,7 +222,7 @@ _lzo_config_check(void) LZO_PUBLIC(int) __lzo_init_v2(unsigned v, int s1, int s2, int s3, int s4, int s5, - int s6, int s7, int s8, int s9) + int s6, int s7, int s8, int s9) { int r; @@ -217,13 +245,15 @@ __lzo_init_v2(unsigned v, int s1, int s2, int s3, int s4, int s5, (s4 == -1 || s4 == (int) sizeof(lzo_uint32_t)) && (s5 == -1 || s5 == (int) sizeof(lzo_uint)) && (s6 == -1 || s6 == (int) lzo_sizeof_dict_t) && - (s7 == -1 || s7 == (int) sizeof(char *)) && + (s7 == -1 || s7 == (int) sizeof(char*)) && (s8 == -1 || s8 == (int) sizeof(lzo_voidp)) && (s9 == -1 || s9 == (int) sizeof(lzo_callback_t)); + if (!r) return LZO_E_ERROR; r = _lzo_config_check(); + if (r != LZO_E_OK) return r; diff --git a/extern/lzo/src/lzo_mchw.ch b/extern/lzo/src/lzo_mchw.ch index bcfec46..6e63eae 100644 --- a/extern/lzo/src/lzo_mchw.ch +++ b/extern/lzo/src/lzo_mchw.ch @@ -110,9 +110,9 @@ LZO_COMPRESS_T; ************************************************************************/ static int -init_match ( LZO_COMPRESS_T *c, lzo_swd_p s, - const lzo_bytep dict, lzo_uint dict_len, - lzo_uint32_t flags ) +init_match(LZO_COMPRESS_T* c, lzo_swd_p s, + const lzo_bytep dict, lzo_uint dict_len, + lzo_uint32_t flags) { int r; @@ -127,7 +127,8 @@ init_match ( LZO_COMPRESS_T *c, lzo_swd_p s, c->lit_bytes = c->match_bytes = c->rep_bytes = 0; c->lazy = 0; - r = swd_init(s,dict,dict_len); + r = swd_init(s, dict, dict_len); + if (r != LZO_E_OK) { swd_exit(s); @@ -144,8 +145,8 @@ init_match ( LZO_COMPRESS_T *c, lzo_swd_p s, ************************************************************************/ static int -find_match ( LZO_COMPRESS_T *c, lzo_swd_p s, - lzo_uint this_len, lzo_uint skip ) +find_match(LZO_COMPRESS_T* c, lzo_swd_p s, + lzo_uint this_len, lzo_uint skip) { assert(c->init); @@ -164,8 +165,10 @@ find_match ( LZO_COMPRESS_T *c, lzo_swd_p s, s->m_len = SWD_THRESHOLD; s->m_off = 0; #ifdef SWD_BEST_OFF + if (s->use_best_off) - lzo_memset(s->best_pos,0,sizeof(s->best_pos)); + lzo_memset(s->best_pos, 0, sizeof(s->best_pos)); + #endif swd_findbest(s); c->m_len = s->m_len; @@ -183,9 +186,11 @@ find_match ( LZO_COMPRESS_T *c, lzo_swd_p s, { c->look = s->look + 1; } + c->bp = c->ip - c->look; #if 0 + /* brute force match search */ if (c->m_len > SWD_THRESHOLD && c->m_len + 1 <= c->look) { @@ -195,18 +200,23 @@ find_match ( LZO_COMPRESS_T *c, lzo_swd_p s, if (ip - in > s->swd_n) in = ip - s->swd_n; + for (;;) { while (*in != *ip) in++; + if (in == ip) break; + if (in != m) - if (lzo_memcmp(in,ip,c->m_len+1) == 0) - printf("%p %p %p %5d\n",in,ip,m,c->m_len); + if (lzo_memcmp(in, ip, c->m_len + 1) == 0) + printf("%p %p %p %5d\n", in, ip, m, c->m_len); + in++; } } + #endif if (c->cb && c->cb->nprogress && c->textsize > c->printcount) diff --git a/extern/lzo/src/lzo_ptr.c b/extern/lzo/src/lzo_ptr.c index 38359ff..42155a3 100644 --- a/extern/lzo/src/lzo_ptr.c +++ b/extern/lzo/src/lzo_ptr.c @@ -61,14 +61,19 @@ __lzo_align_gap(const lzo_voidp ptr, lzo_uint size) #error "__LZO_UINTPTR_T_IS_POINTER is unsupported" #else lzo_uintptr_t p, n; + if (size < 2) return 0; + p = __lzo_ptr_linear(ptr); #if 0 n = (((p + size - 1) / size) * size) - p; #else + if ((size & (size - 1)) != 0) return 0; - n = size; n = ((p + n - 1) & ~(n - 1)) - p; + + n = size; + n = ((p + n - 1) & ~(n - 1)) - p; #endif #endif assert((long)n >= 0); diff --git a/extern/lzo/src/lzo_ptr.h b/extern/lzo/src/lzo_ptr.h index 736c7c5..f023b07 100644 --- a/extern/lzo/src/lzo_ptr.h +++ b/extern/lzo/src/lzo_ptr.h @@ -98,12 +98,12 @@ typedef union size_t a_size_t; ptrdiff_t a_ptrdiff_t; lzo_uintptr_t a_lzo_uintptr_t; - void * a_void_p; - char * a_char_p; - unsigned char * a_uchar_p; - const void * a_c_void_p; - const char * a_c_char_p; - const unsigned char * a_c_uchar_p; + void* a_void_p; + char* a_char_p; + unsigned char* a_uchar_p; + const void* a_c_void_p; + const char* a_c_char_p; + const unsigned char* a_c_uchar_p; lzo_voidp a_lzo_voidp; lzo_bytep a_lzo_bytep; const lzo_voidp a_c_lzo_voidp; diff --git a/extern/lzo/src/lzo_supp.h b/extern/lzo/src/lzo_supp.h index 87307f9..2c7256d 100644 --- a/extern/lzo/src/lzo_supp.h +++ b/extern/lzo/src/lzo_supp.h @@ -655,11 +655,11 @@ extern "C" { #endif #if (LZO_BROKEN_CDECL_ALT_SYNTAX) -typedef void __lzo_cdecl_sighandler (*lzo_sighandler_t)(lzo_signo_t); +typedef void __lzo_cdecl_sighandler(*lzo_sighandler_t)(lzo_signo_t); #elif defined(RETSIGTYPE) -typedef RETSIGTYPE (__lzo_cdecl_sighandler *lzo_sighandler_t)(lzo_signo_t); +typedef RETSIGTYPE(__lzo_cdecl_sighandler* lzo_sighandler_t)(lzo_signo_t); #else -typedef void (__lzo_cdecl_sighandler *lzo_sighandler_t)(lzo_signo_t); +typedef void (__lzo_cdecl_sighandler* lzo_sighandler_t)(lzo_signo_t); #endif #if defined(__cplusplus) } @@ -949,13 +949,13 @@ typedef unsigned short wchar_t; # define lzolib_handle_t lzo_intptr_t #endif #if 0 -LZOLIB_EXTERN(int, lzo_ascii_digit) (int); -LZOLIB_EXTERN(int, lzo_ascii_islower) (int); -LZOLIB_EXTERN(int, lzo_ascii_isupper) (int); -LZOLIB_EXTERN(int, lzo_ascii_tolower) (int); -LZOLIB_EXTERN(int, lzo_ascii_toupper) (int); -LZOLIB_EXTERN(int, lzo_ascii_utolower) (int); -LZOLIB_EXTERN(int, lzo_ascii_utoupper) (int); +LZOLIB_EXTERN(int, lzo_ascii_digit)(int); +LZOLIB_EXTERN(int, lzo_ascii_islower)(int); +LZOLIB_EXTERN(int, lzo_ascii_isupper)(int); +LZOLIB_EXTERN(int, lzo_ascii_tolower)(int); +LZOLIB_EXTERN(int, lzo_ascii_toupper)(int); +LZOLIB_EXTERN(int, lzo_ascii_utolower)(int); +LZOLIB_EXTERN(int, lzo_ascii_utoupper)(int); #endif #define lzo_ascii_isdigit(c) ((LZO_ICAST(unsigned, c) - 48) < 10) #define lzo_ascii_islower(c) ((LZO_ICAST(unsigned, c) - 97) < 26) @@ -979,95 +979,95 @@ LZOLIB_EXTERN(int, lzo_ascii_utoupper) (int); # define lzo_hbyte_p unsigned char * #endif #endif -LZOLIB_EXTERN(lzo_hvoid_p, lzo_halloc) (lzo_hsize_t); -LZOLIB_EXTERN(void, lzo_hfree) (lzo_hvoid_p); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_halloc)(lzo_hsize_t); +LZOLIB_EXTERN(void, lzo_hfree)(lzo_hvoid_p); #if (LZO_OS_DOS16 || LZO_OS_OS216) -LZOLIB_EXTERN(void __far*, lzo_dos_alloc) (unsigned long); -LZOLIB_EXTERN(int, lzo_dos_free) (void __far*); +LZOLIB_EXTERN(void __far*, lzo_dos_alloc)(unsigned long); +LZOLIB_EXTERN(int, lzo_dos_free)(void __far*); #endif -LZOLIB_EXTERN(int, lzo_hmemcmp) (const lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemcpy) (lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemmove) (lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemset) (lzo_hvoid_p, int, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrlen) (const lzo_hchar_p); -LZOLIB_EXTERN(int, lzo_hstrcmp) (const lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(int, lzo_hmemcmp)(const lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemcpy)(lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemmove)(lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemset)(lzo_hvoid_p, int, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrlen)(const lzo_hchar_p); +LZOLIB_EXTERN(int, lzo_hstrcmp)(const lzo_hchar_p, const lzo_hchar_p); LZOLIB_EXTERN(int, lzo_hstrncmp)(const lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); -LZOLIB_EXTERN(int, lzo_ascii_hstricmp) (const lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(int, lzo_ascii_hstricmp)(const lzo_hchar_p, const lzo_hchar_p); LZOLIB_EXTERN(int, lzo_ascii_hstrnicmp)(const lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); -LZOLIB_EXTERN(int, lzo_ascii_hmemicmp) (const lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrstr) (const lzo_hchar_p, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstristr) (const lzo_hchar_p, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemmem) (const lzo_hvoid_p, lzo_hsize_t, const lzo_hvoid_p, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemimem) (const lzo_hvoid_p, lzo_hsize_t, const lzo_hvoid_p, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrcpy) (lzo_hchar_p, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrcat) (lzo_hchar_p, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrlcpy) (lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrlcat) (lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); -LZOLIB_EXTERN(int, lzo_hstrscpy) (lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); -LZOLIB_EXTERN(int, lzo_hstrscat) (lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrccpy) (lzo_hchar_p, const lzo_hchar_p, int); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemccpy) (lzo_hvoid_p, const lzo_hvoid_p, int, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrchr) (const lzo_hchar_p, int); -LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrrchr) (const lzo_hchar_p, int); -LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrichr) (const lzo_hchar_p, int); -LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrrichr) (const lzo_hchar_p, int); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemchr) (const lzo_hvoid_p, int, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemrchr) (const lzo_hvoid_p, int, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemichr) (const lzo_hvoid_p, int, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemrichr) (const lzo_hvoid_p, int, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrspn) (const lzo_hchar_p, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrrspn) (const lzo_hchar_p, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrcspn) (const lzo_hchar_p, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrrcspn) (const lzo_hchar_p, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrpbrk) (const lzo_hchar_p, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrrpbrk) (const lzo_hchar_p, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrsep) (lzo_hchar_pp, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrrsep) (lzo_hchar_pp, const lzo_hchar_p); -LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrlwr) (lzo_hchar_p); -LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrupr) (lzo_hchar_p); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemlwr) (lzo_hvoid_p, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemupr) (lzo_hvoid_p, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hsize_t, lzo_hfread) (void *, lzo_hvoid_p, lzo_hsize_t); -LZOLIB_EXTERN(lzo_hsize_t, lzo_hfwrite) (void *, const lzo_hvoid_p, lzo_hsize_t); +LZOLIB_EXTERN(int, lzo_ascii_hmemicmp)(const lzo_hvoid_p, const lzo_hvoid_p, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrstr)(const lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstristr)(const lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemmem)(const lzo_hvoid_p, lzo_hsize_t, const lzo_hvoid_p, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemimem)(const lzo_hvoid_p, lzo_hsize_t, const lzo_hvoid_p, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrcpy)(lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrcat)(lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrlcpy)(lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrlcat)(lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); +LZOLIB_EXTERN(int, lzo_hstrscpy)(lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); +LZOLIB_EXTERN(int, lzo_hstrscat)(lzo_hchar_p, const lzo_hchar_p, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrccpy)(lzo_hchar_p, const lzo_hchar_p, int); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemccpy)(lzo_hvoid_p, const lzo_hvoid_p, int, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrchr)(const lzo_hchar_p, int); +LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrrchr)(const lzo_hchar_p, int); +LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrichr)(const lzo_hchar_p, int); +LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrrichr)(const lzo_hchar_p, int); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemchr)(const lzo_hvoid_p, int, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_hmemrchr)(const lzo_hvoid_p, int, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemichr)(const lzo_hvoid_p, int, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemrichr)(const lzo_hvoid_p, int, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrspn)(const lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrrspn)(const lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrcspn)(const lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hsize_t, lzo_hstrrcspn)(const lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrpbrk)(const lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrrpbrk)(const lzo_hchar_p, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrsep)(lzo_hchar_pp, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hchar_p, lzo_hstrrsep)(lzo_hchar_pp, const lzo_hchar_p); +LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrlwr)(lzo_hchar_p); +LZOLIB_EXTERN(lzo_hchar_p, lzo_ascii_hstrupr)(lzo_hchar_p); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemlwr)(lzo_hvoid_p, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hvoid_p, lzo_ascii_hmemupr)(lzo_hvoid_p, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hsize_t, lzo_hfread)(void*, lzo_hvoid_p, lzo_hsize_t); +LZOLIB_EXTERN(lzo_hsize_t, lzo_hfwrite)(void*, const lzo_hvoid_p, lzo_hsize_t); #if (LZO_HAVE_MM_HUGE_PTR) -LZOLIB_EXTERN(long, lzo_hread) (int, lzo_hvoid_p, long); -LZOLIB_EXTERN(long, lzo_hwrite) (int, const lzo_hvoid_p, long); +LZOLIB_EXTERN(long, lzo_hread)(int, lzo_hvoid_p, long); +LZOLIB_EXTERN(long, lzo_hwrite)(int, const lzo_hvoid_p, long); #endif -LZOLIB_EXTERN(long, lzo_safe_hread) (int, lzo_hvoid_p, long); -LZOLIB_EXTERN(long, lzo_safe_hwrite) (int, const lzo_hvoid_p, long); -LZOLIB_EXTERN(unsigned, lzo_ua_get_be16) (const lzo_hvoid_p); -LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_be24) (const lzo_hvoid_p); -LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_be32) (const lzo_hvoid_p); -LZOLIB_EXTERN(void, lzo_ua_set_be16) (lzo_hvoid_p, unsigned); -LZOLIB_EXTERN(void, lzo_ua_set_be24) (lzo_hvoid_p, lzo_uint32l_t); -LZOLIB_EXTERN(void, lzo_ua_set_be32) (lzo_hvoid_p, lzo_uint32l_t); -LZOLIB_EXTERN(unsigned, lzo_ua_get_le16) (const lzo_hvoid_p); -LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_le24) (const lzo_hvoid_p); -LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_le32) (const lzo_hvoid_p); -LZOLIB_EXTERN(void, lzo_ua_set_le16) (lzo_hvoid_p, unsigned); -LZOLIB_EXTERN(void, lzo_ua_set_le24) (lzo_hvoid_p, lzo_uint32l_t); -LZOLIB_EXTERN(void, lzo_ua_set_le32) (lzo_hvoid_p, lzo_uint32l_t); +LZOLIB_EXTERN(long, lzo_safe_hread)(int, lzo_hvoid_p, long); +LZOLIB_EXTERN(long, lzo_safe_hwrite)(int, const lzo_hvoid_p, long); +LZOLIB_EXTERN(unsigned, lzo_ua_get_be16)(const lzo_hvoid_p); +LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_be24)(const lzo_hvoid_p); +LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_be32)(const lzo_hvoid_p); +LZOLIB_EXTERN(void, lzo_ua_set_be16)(lzo_hvoid_p, unsigned); +LZOLIB_EXTERN(void, lzo_ua_set_be24)(lzo_hvoid_p, lzo_uint32l_t); +LZOLIB_EXTERN(void, lzo_ua_set_be32)(lzo_hvoid_p, lzo_uint32l_t); +LZOLIB_EXTERN(unsigned, lzo_ua_get_le16)(const lzo_hvoid_p); +LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_le24)(const lzo_hvoid_p); +LZOLIB_EXTERN(lzo_uint32l_t, lzo_ua_get_le32)(const lzo_hvoid_p); +LZOLIB_EXTERN(void, lzo_ua_set_le16)(lzo_hvoid_p, unsigned); +LZOLIB_EXTERN(void, lzo_ua_set_le24)(lzo_hvoid_p, lzo_uint32l_t); +LZOLIB_EXTERN(void, lzo_ua_set_le32)(lzo_hvoid_p, lzo_uint32l_t); #if defined(lzo_int64l_t) -LZOLIB_EXTERN(lzo_uint64l_t, lzo_ua_get_be64) (const lzo_hvoid_p); -LZOLIB_EXTERN(void, lzo_ua_set_be64) (lzo_hvoid_p, lzo_uint64l_t); -LZOLIB_EXTERN(lzo_uint64l_t, lzo_ua_get_le64) (const lzo_hvoid_p); -LZOLIB_EXTERN(void, lzo_ua_set_le64) (lzo_hvoid_p, lzo_uint64l_t); +LZOLIB_EXTERN(lzo_uint64l_t, lzo_ua_get_be64)(const lzo_hvoid_p); +LZOLIB_EXTERN(void, lzo_ua_set_be64)(lzo_hvoid_p, lzo_uint64l_t); +LZOLIB_EXTERN(lzo_uint64l_t, lzo_ua_get_le64)(const lzo_hvoid_p); +LZOLIB_EXTERN(void, lzo_ua_set_le64)(lzo_hvoid_p, lzo_uint64l_t); #endif -LZOLIB_EXTERN_NOINLINE(short, lzo_vget_short) (short, int); -LZOLIB_EXTERN_NOINLINE(int, lzo_vget_int) (int, int); -LZOLIB_EXTERN_NOINLINE(long, lzo_vget_long) (long, int); +LZOLIB_EXTERN_NOINLINE(short, lzo_vget_short)(short, int); +LZOLIB_EXTERN_NOINLINE(int, lzo_vget_int)(int, int); +LZOLIB_EXTERN_NOINLINE(long, lzo_vget_long)(long, int); #if defined(lzo_int64l_t) -LZOLIB_EXTERN_NOINLINE(lzo_int64l_t, lzo_vget_lzo_int64l_t) (lzo_int64l_t, int); +LZOLIB_EXTERN_NOINLINE(lzo_int64l_t, lzo_vget_lzo_int64l_t)(lzo_int64l_t, int); #endif -LZOLIB_EXTERN_NOINLINE(lzo_hsize_t, lzo_vget_lzo_hsize_t) (lzo_hsize_t, int); +LZOLIB_EXTERN_NOINLINE(lzo_hsize_t, lzo_vget_lzo_hsize_t)(lzo_hsize_t, int); #if !(LZO_CFG_NO_FLOAT) -LZOLIB_EXTERN_NOINLINE(float, lzo_vget_float) (float, int); +LZOLIB_EXTERN_NOINLINE(float, lzo_vget_float)(float, int); #endif #if !(LZO_CFG_NO_DOUBLE) -LZOLIB_EXTERN_NOINLINE(double, lzo_vget_double) (double, int); +LZOLIB_EXTERN_NOINLINE(double, lzo_vget_double)(double, int); #endif -LZOLIB_EXTERN_NOINLINE(lzo_hvoid_p, lzo_vget_lzo_hvoid_p) (lzo_hvoid_p, int); -LZOLIB_EXTERN_NOINLINE(const lzo_hvoid_p, lzo_vget_lzo_hvoid_cp) (const lzo_hvoid_p, int); +LZOLIB_EXTERN_NOINLINE(lzo_hvoid_p, lzo_vget_lzo_hvoid_p)(lzo_hvoid_p, int); +LZOLIB_EXTERN_NOINLINE(const lzo_hvoid_p, lzo_vget_lzo_hvoid_cp)(const lzo_hvoid_p, int); #if !defined(LZO_FN_PATH_MAX) #if (LZO_OS_DOS16 || LZO_OS_WIN16) # define LZO_FN_PATH_MAX 143 @@ -1098,7 +1098,7 @@ LZOLIB_EXTERN_NOINLINE(const lzo_hvoid_p, lzo_vget_lzo_hvoid_cp) (const lzo_hvoi #define LZO_FNMATCH_PATHSTAR 4 #define LZO_FNMATCH_PERIOD 8 #define LZO_FNMATCH_ASCII_CASEFOLD 16 -LZOLIB_EXTERN(int, lzo_fnmatch) (const lzo_hchar_p, const lzo_hchar_p, int); +LZOLIB_EXTERN(int, lzo_fnmatch)(const lzo_hchar_p, const lzo_hchar_p, int); #undef __LZOLIB_USE_OPENDIR #if (HAVE_DIRENT_H || LZO_CC_WATCOMC) # define __LZOLIB_USE_OPENDIR 1 @@ -1120,13 +1120,13 @@ typedef struct unsigned short f_date; unsigned long f_size; # endif - char f_name[LZO_FN_NAME_MAX+1]; + char f_name[LZO_FN_NAME_MAX + 1]; #elif (LZO_OS_WIN32 || LZO_OS_WIN64) lzolib_handle_t u_handle; unsigned f_attr; unsigned f_size_low; unsigned f_size_high; - char f_name[LZO_FN_NAME_MAX+1]; + char f_name[LZO_FN_NAME_MAX + 1]; #elif (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_TOS || LZO_OS_WIN16) char u_dta[21]; unsigned char f_attr; @@ -1134,19 +1134,19 @@ typedef struct unsigned short f_date; unsigned short f_size_low; unsigned short f_size_high; - char f_name[LZO_FN_NAME_MAX+1]; + char f_name[LZO_FN_NAME_MAX + 1]; char u_dirp; #else void* u_dirp; - char f_name[LZO_FN_NAME_MAX+1]; + char f_name[LZO_FN_NAME_MAX + 1]; #endif } lzo_dir_t; #ifndef lzo_dir_p #define lzo_dir_p lzo_dir_t * #endif -LZOLIB_EXTERN(int, lzo_opendir) (lzo_dir_p, const char*); -LZOLIB_EXTERN(int, lzo_readdir) (lzo_dir_p); -LZOLIB_EXTERN(int, lzo_closedir) (lzo_dir_p); +LZOLIB_EXTERN(int, lzo_opendir)(lzo_dir_p, const char*); +LZOLIB_EXTERN(int, lzo_readdir)(lzo_dir_p); +LZOLIB_EXTERN(int, lzo_closedir)(lzo_dir_p); #if (LZO_CC_GNUC) && (defined(__CYGWIN__) || defined(__MINGW32__)) # define lzo_alloca(x) __builtin_alloca((x)) #elif (LZO_CC_GNUC) && (LZO_OS_CONSOLE_PS2) @@ -1173,33 +1173,33 @@ LZOLIB_EXTERN(int, lzo_closedir) (lzo_dir_p); #elif ((LZO_ARCH_I086 || LZO_ARCH_I386) && LZO_CC_TURBOC && (__TURBOC__ >= 0x0450)) # define lzo_stackavail() stackavail() #elif (LZO_ARCH_I086 && LZO_CC_TURBOC && (__TURBOC__ >= 0x0400)) - LZO_EXTERN_C size_t __cdecl stackavail(void); +LZO_EXTERN_C size_t __cdecl stackavail(void); # define lzo_stackavail() stackavail() #elif ((LZO_ARCH_I086 || LZO_ARCH_I386) && (LZO_CC_WATCOMC)) # define lzo_stackavail() stackavail() #elif (LZO_ARCH_I086 && LZO_CC_ZORTECHC) # define lzo_stackavail() _chkstack() #endif -LZOLIB_EXTERN(lzo_intptr_t, lzo_get_osfhandle) (int); -LZOLIB_EXTERN(const char *, lzo_getenv) (const char *); -LZOLIB_EXTERN(int, lzo_isatty) (int); -LZOLIB_EXTERN(int, lzo_mkdir) (const char*, unsigned); -LZOLIB_EXTERN(int, lzo_rmdir) (const char*); -LZOLIB_EXTERN(int, lzo_response) (int*, char***); -LZOLIB_EXTERN(int, lzo_set_binmode) (int, int); +LZOLIB_EXTERN(lzo_intptr_t, lzo_get_osfhandle)(int); +LZOLIB_EXTERN(const char*, lzo_getenv)(const char*); +LZOLIB_EXTERN(int, lzo_isatty)(int); +LZOLIB_EXTERN(int, lzo_mkdir)(const char*, unsigned); +LZOLIB_EXTERN(int, lzo_rmdir)(const char*); +LZOLIB_EXTERN(int, lzo_response)(int*, char***); +LZOLIB_EXTERN(int, lzo_set_binmode)(int, int); #if defined(lzo_int32e_t) -LZOLIB_EXTERN(lzo_int32e_t, lzo_muldiv32s) (lzo_int32e_t, lzo_int32e_t, lzo_int32e_t); -LZOLIB_EXTERN(lzo_uint32e_t, lzo_muldiv32u) (lzo_uint32e_t, lzo_uint32e_t, lzo_uint32e_t); +LZOLIB_EXTERN(lzo_int32e_t, lzo_muldiv32s)(lzo_int32e_t, lzo_int32e_t, lzo_int32e_t); +LZOLIB_EXTERN(lzo_uint32e_t, lzo_muldiv32u)(lzo_uint32e_t, lzo_uint32e_t, lzo_uint32e_t); #endif -LZOLIB_EXTERN(void, lzo_wildargv) (int*, char***); -LZOLIB_EXTERN_NOINLINE(void, lzo_debug_break) (void); -LZOLIB_EXTERN_NOINLINE(void, lzo_debug_nop) (void); -LZOLIB_EXTERN_NOINLINE(int, lzo_debug_align_check_query) (void); -LZOLIB_EXTERN_NOINLINE(int, lzo_debug_align_check_enable) (int); -LZOLIB_EXTERN_NOINLINE(unsigned, lzo_debug_running_on_qemu) (void); -LZOLIB_EXTERN_NOINLINE(unsigned, lzo_debug_running_on_valgrind) (void); +LZOLIB_EXTERN(void, lzo_wildargv)(int*, char***); +LZOLIB_EXTERN_NOINLINE(void, lzo_debug_break)(void); +LZOLIB_EXTERN_NOINLINE(void, lzo_debug_nop)(void); +LZOLIB_EXTERN_NOINLINE(int, lzo_debug_align_check_query)(void); +LZOLIB_EXTERN_NOINLINE(int, lzo_debug_align_check_enable)(int); +LZOLIB_EXTERN_NOINLINE(unsigned, lzo_debug_running_on_qemu)(void); +LZOLIB_EXTERN_NOINLINE(unsigned, lzo_debug_running_on_valgrind)(void); #if defined(lzo_int32e_t) -LZOLIB_EXTERN(int, lzo_tsc_read) (lzo_uint32e_t*); +LZOLIB_EXTERN(int, lzo_tsc_read)(lzo_uint32e_t*); #endif struct lzo_pclock_handle_t; struct lzo_pclock_t; @@ -1215,8 +1215,9 @@ typedef struct lzo_pclock_t lzo_pclock_t; #define LZO_PCLOCK_MONOTONIC 1 #define LZO_PCLOCK_PROCESS_CPUTIME_ID 2 #define LZO_PCLOCK_THREAD_CPUTIME_ID 3 -typedef int (*lzo_pclock_gettime_t) (lzo_pclock_handle_p, lzo_pclock_p); -struct lzo_pclock_handle_t { +typedef int (*lzo_pclock_gettime_t)(lzo_pclock_handle_p, lzo_pclock_p); +struct lzo_pclock_handle_t +{ lzolib_handle_t h; int mode; int read_error; @@ -1226,7 +1227,8 @@ struct lzo_pclock_handle_t { lzo_uint64l_t ticks_base; #endif }; -struct lzo_pclock_t { +struct lzo_pclock_t +{ #if defined(lzo_int64l_t) lzo_int64l_t tv_sec; #else @@ -1235,14 +1237,14 @@ struct lzo_pclock_t { #endif lzo_uint32l_t tv_nsec; }; -LZOLIB_EXTERN(int, lzo_pclock_open) (lzo_pclock_handle_p, int); -LZOLIB_EXTERN(int, lzo_pclock_open_default) (lzo_pclock_handle_p); -LZOLIB_EXTERN(int, lzo_pclock_close) (lzo_pclock_handle_p); -LZOLIB_EXTERN(void, lzo_pclock_read) (lzo_pclock_handle_p, lzo_pclock_p); +LZOLIB_EXTERN(int, lzo_pclock_open)(lzo_pclock_handle_p, int); +LZOLIB_EXTERN(int, lzo_pclock_open_default)(lzo_pclock_handle_p); +LZOLIB_EXTERN(int, lzo_pclock_close)(lzo_pclock_handle_p); +LZOLIB_EXTERN(void, lzo_pclock_read)(lzo_pclock_handle_p, lzo_pclock_p); #if !(LZO_CFG_NO_DOUBLE) -LZOLIB_EXTERN(double, lzo_pclock_get_elapsed) (lzo_pclock_handle_p, const lzo_pclock_p, const lzo_pclock_p); +LZOLIB_EXTERN(double, lzo_pclock_get_elapsed)(lzo_pclock_handle_p, const lzo_pclock_p, const lzo_pclock_p); #endif -LZOLIB_EXTERN(int, lzo_pclock_flush_cpu_cache) (lzo_pclock_handle_p, unsigned); +LZOLIB_EXTERN(int, lzo_pclock_flush_cpu_cache)(lzo_pclock_handle_p, unsigned); struct lzo_getopt_t; typedef struct lzo_getopt_t lzo_getopt_t; #ifndef lzo_getopt_p @@ -1253,90 +1255,99 @@ typedef struct lzo_getopt_longopt_t lzo_getopt_longopt_t; #ifndef lzo_getopt_longopt_p #define lzo_getopt_longopt_p lzo_getopt_longopt_t * #endif -struct lzo_getopt_longopt_t { +struct lzo_getopt_longopt_t +{ const char* name; int has_arg; int* flag; int val; }; -typedef void (*lzo_getopt_opterr_t)(lzo_getopt_p, const char*, void *); -struct lzo_getopt_t { - void *user; - const char *progname; +typedef void (*lzo_getopt_opterr_t)(lzo_getopt_p, const char*, void*); +struct lzo_getopt_t +{ + void* user; + const char* progname; int bad_option; - char *optarg; + char* optarg; lzo_getopt_opterr_t opterr; int optind; int optopt; int errcount; - int argc; char** argv; - int eof; int shortpos; + int argc; + char** argv; + int eof; + int shortpos; int pending_rotate_first, pending_rotate_middle; }; enum { LZO_GETOPT_NO_ARG, LZO_GETOPT_REQUIRED_ARG, LZO_GETOPT_OPTIONAL_ARG, LZO_GETOPT_EXACT_ARG = 0x10 }; enum { LZO_GETOPT_PERMUTE, LZO_GETOPT_RETURN_IN_ORDER, LZO_GETOPT_REQUIRE_ORDER }; -LZOLIB_EXTERN(void, lzo_getopt_init) (lzo_getopt_p g, - int start_argc, int argc, char** argv); -LZOLIB_EXTERN(int, lzo_getopt) (lzo_getopt_p g, - const char* shortopts, - const lzo_getopt_longopt_p longopts, - int* longind); -typedef struct { +LZOLIB_EXTERN(void, lzo_getopt_init)(lzo_getopt_p g, + int start_argc, int argc, char** argv); +LZOLIB_EXTERN(int, lzo_getopt)(lzo_getopt_p g, + const char* shortopts, + const lzo_getopt_longopt_p longopts, + int* longind); +typedef struct +{ lzo_uint32l_t seed; } lzo_rand31_t; #ifndef lzo_rand31_p #define lzo_rand31_p lzo_rand31_t * #endif -LZOLIB_EXTERN(void, lzo_srand31) (lzo_rand31_p, lzo_uint32l_t); -LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand31) (lzo_rand31_p); +LZOLIB_EXTERN(void, lzo_srand31)(lzo_rand31_p, lzo_uint32l_t); +LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand31)(lzo_rand31_p); #if defined(lzo_int64l_t) -typedef struct { +typedef struct +{ lzo_uint64l_t seed; } lzo_rand48_t; #ifndef lzo_rand48_p #define lzo_rand48_p lzo_rand48_t * #endif -LZOLIB_EXTERN(void, lzo_srand48) (lzo_rand48_p, lzo_uint32l_t); -LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand48) (lzo_rand48_p); -LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand48_r32) (lzo_rand48_p); +LZOLIB_EXTERN(void, lzo_srand48)(lzo_rand48_p, lzo_uint32l_t); +LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand48)(lzo_rand48_p); +LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand48_r32)(lzo_rand48_p); #endif #if defined(lzo_int64l_t) -typedef struct { +typedef struct +{ lzo_uint64l_t seed; } lzo_rand64_t; #ifndef lzo_rand64_p #define lzo_rand64_p lzo_rand64_t * #endif -LZOLIB_EXTERN(void, lzo_srand64) (lzo_rand64_p, lzo_uint64l_t); -LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand64) (lzo_rand64_p); -LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand64_r32) (lzo_rand64_p); +LZOLIB_EXTERN(void, lzo_srand64)(lzo_rand64_p, lzo_uint64l_t); +LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand64)(lzo_rand64_p); +LZOLIB_EXTERN(lzo_uint32l_t, lzo_rand64_r32)(lzo_rand64_p); #endif -typedef struct { +typedef struct +{ unsigned n; lzo_uint32l_t s[624]; } lzo_randmt_t; #ifndef lzo_randmt_p #define lzo_randmt_p lzo_randmt_t * #endif -LZOLIB_EXTERN(void, lzo_srandmt) (lzo_randmt_p, lzo_uint32l_t); -LZOLIB_EXTERN(lzo_uint32l_t, lzo_randmt) (lzo_randmt_p); -LZOLIB_EXTERN(lzo_uint32l_t, lzo_randmt_r32) (lzo_randmt_p); +LZOLIB_EXTERN(void, lzo_srandmt)(lzo_randmt_p, lzo_uint32l_t); +LZOLIB_EXTERN(lzo_uint32l_t, lzo_randmt)(lzo_randmt_p); +LZOLIB_EXTERN(lzo_uint32l_t, lzo_randmt_r32)(lzo_randmt_p); #if defined(lzo_int64l_t) -typedef struct { +typedef struct +{ unsigned n; lzo_uint64l_t s[312]; } lzo_randmt64_t; #ifndef lzo_randmt64_p #define lzo_randmt64_p lzo_randmt64_t * #endif -LZOLIB_EXTERN(void, lzo_srandmt64) (lzo_randmt64_p, lzo_uint64l_t); -LZOLIB_EXTERN(lzo_uint64l_t, lzo_randmt64_r64) (lzo_randmt64_p); +LZOLIB_EXTERN(void, lzo_srandmt64)(lzo_randmt64_p, lzo_uint64l_t); +LZOLIB_EXTERN(lzo_uint64l_t, lzo_randmt64_r64)(lzo_randmt64_p); #endif #define LZO_SPAWN_P_WAIT 0 #define LZO_SPAWN_P_NOWAIT 1 -LZOLIB_EXTERN(int, lzo_spawnv) (int mode, const char* fn, const char* const * argv); -LZOLIB_EXTERN(int, lzo_spawnvp) (int mode, const char* fn, const char* const * argv); -LZOLIB_EXTERN(int, lzo_spawnve) (int mode, const char* fn, const char* const * argv, const char * const envp); +LZOLIB_EXTERN(int, lzo_spawnv)(int mode, const char* fn, const char* const* argv); +LZOLIB_EXTERN(int, lzo_spawnvp)(int mode, const char* fn, const char* const* argv); +LZOLIB_EXTERN(int, lzo_spawnve)(int mode, const char* fn, const char* const* argv, const char* const envp); #endif #endif #if defined(LZO_WANT_ACC_CXX_H) @@ -1503,451 +1514,451 @@ LZOLIB_EXTERN(int, lzo_spawnve) (int mode, const char* fn, const char* const * a #undef LZOCHK_TMP2 #if 0 || defined(LZOCHK_CFG_PEDANTIC) # if (LZO_ARCH_MIPS) && defined(_MIPS_SZINT) - LZOCHK_ASSERT((_MIPS_SZINT) == 8 * sizeof(int)) +LZOCHK_ASSERT((_MIPS_SZINT) == 8 * sizeof(int)) # endif # if (LZO_ARCH_MIPS) && defined(_MIPS_SZLONG) - LZOCHK_ASSERT((_MIPS_SZLONG) == 8 * sizeof(long)) +LZOCHK_ASSERT((_MIPS_SZLONG) == 8 * sizeof(long)) # endif # if (LZO_ARCH_MIPS) && defined(_MIPS_SZPTR) - LZOCHK_ASSERT((_MIPS_SZPTR) == 8 * sizeof(void *)) +LZOCHK_ASSERT((_MIPS_SZPTR) == 8 * sizeof(void*)) # endif #endif - LZOCHK_ASSERT(1 == 1) - LZOCHK_ASSERT(__LZO_MASK_GEN(1u,1) == 1) - LZOCHK_ASSERT(__LZO_MASK_GEN(1u,2) == 3) - LZOCHK_ASSERT(__LZO_MASK_GEN(1u,3) == 7) - LZOCHK_ASSERT(__LZO_MASK_GEN(1u,8) == 255) +LZOCHK_ASSERT(1 == 1) +LZOCHK_ASSERT(__LZO_MASK_GEN(1u, 1) == 1) +LZOCHK_ASSERT(__LZO_MASK_GEN(1u, 2) == 3) +LZOCHK_ASSERT(__LZO_MASK_GEN(1u, 3) == 7) +LZOCHK_ASSERT(__LZO_MASK_GEN(1u, 8) == 255) #if (LZO_SIZEOF_INT >= 2) - LZOCHK_ASSERT(__LZO_MASK_GEN(1,15) == 32767) - LZOCHK_ASSERT(__LZO_MASK_GEN(1u,16) == 0xffffU) - LZOCHK_ASSERT(__LZO_MASK_GEN(0u,16) == 0u) +LZOCHK_ASSERT(__LZO_MASK_GEN(1, 15) == 32767) +LZOCHK_ASSERT(__LZO_MASK_GEN(1u, 16) == 0xffffU) +LZOCHK_ASSERT(__LZO_MASK_GEN(0u, 16) == 0u) #else - LZOCHK_ASSERT(__LZO_MASK_GEN(1ul,16) == 0xffffUL) - LZOCHK_ASSERT(__LZO_MASK_GEN(0ul,16) == 0ul) +LZOCHK_ASSERT(__LZO_MASK_GEN(1ul, 16) == 0xffffUL) +LZOCHK_ASSERT(__LZO_MASK_GEN(0ul, 16) == 0ul) #endif #if (LZO_SIZEOF_INT >= 4) - LZOCHK_ASSERT(__LZO_MASK_GEN(1,31) == 2147483647) - LZOCHK_ASSERT(__LZO_MASK_GEN(1u,32) == 0xffffffffU) - LZOCHK_ASSERT(__LZO_MASK_GEN(0u,32) == 0u) +LZOCHK_ASSERT(__LZO_MASK_GEN(1, 31) == 2147483647) +LZOCHK_ASSERT(__LZO_MASK_GEN(1u, 32) == 0xffffffffU) +LZOCHK_ASSERT(__LZO_MASK_GEN(0u, 32) == 0u) #endif #if (LZO_SIZEOF_LONG >= 4) - LZOCHK_ASSERT(__LZO_MASK_GEN(1ul,32) == 0xffffffffUL) - LZOCHK_ASSERT(__LZO_MASK_GEN(0ul,32) == 0ul) +LZOCHK_ASSERT(__LZO_MASK_GEN(1ul, 32) == 0xffffffffUL) +LZOCHK_ASSERT(__LZO_MASK_GEN(0ul, 32) == 0ul) #endif #if (LZO_SIZEOF_LONG >= 8) - LZOCHK_ASSERT(__LZO_MASK_GEN(1ul,64) == 0xffffffffffffffffUL) - LZOCHK_ASSERT(__LZO_MASK_GEN(0ul,64) == 0ul) +LZOCHK_ASSERT(__LZO_MASK_GEN(1ul, 64) == 0xffffffffffffffffUL) +LZOCHK_ASSERT(__LZO_MASK_GEN(0ul, 64) == 0ul) #endif #if !(LZO_BROKEN_INTEGRAL_PROMOTION) - LZOCHK_ASSERT(__LZO_MASK_GEN(1u,LZO_SIZEOF_INT*8) == ~0u) - LZOCHK_ASSERT(__LZO_MASK_GEN(1ul,LZO_SIZEOF_LONG*8) == ~0ul) +LZOCHK_ASSERT(__LZO_MASK_GEN(1u, LZO_SIZEOF_INT * 8) == ~0u) +LZOCHK_ASSERT(__LZO_MASK_GEN(1ul, LZO_SIZEOF_LONG * 8) == ~0ul) #endif #if 1 - LZOCHK_ASSERT(__LZO_MASK_GEN(0,0) == 0) - LZOCHK_ASSERT(__LZO_MASK_GEN(1,0) == 0) - LZOCHK_ASSERT(__LZO_MASK_GEN(2,0) == 0) - LZOCHK_ASSERT(__LZO_MASK_GEN(4,0) == 0) +LZOCHK_ASSERT(__LZO_MASK_GEN(0, 0) == 0) +LZOCHK_ASSERT(__LZO_MASK_GEN(1, 0) == 0) +LZOCHK_ASSERT(__LZO_MASK_GEN(2, 0) == 0) +LZOCHK_ASSERT(__LZO_MASK_GEN(4, 0) == 0) #endif #if 1 - LZOCHK_ASSERT(__LZO_MASK_GEN(2,1) == 2) - LZOCHK_ASSERT(__LZO_MASK_GEN(4,1) == 4) - LZOCHK_ASSERT(__LZO_MASK_GEN(8,1) == 8) - LZOCHK_ASSERT(__LZO_MASK_GEN(2,2) == 2+4) - LZOCHK_ASSERT(__LZO_MASK_GEN(4,2) == 4+8) - LZOCHK_ASSERT(__LZO_MASK_GEN(8,2) == 8+16) - LZOCHK_ASSERT(__LZO_MASK_GEN(2,3) == 2+4+8) - LZOCHK_ASSERT(__LZO_MASK_GEN(4,3) == 4+8+16) - LZOCHK_ASSERT(__LZO_MASK_GEN(8,3) == 8+16+32) - LZOCHK_ASSERT(__LZO_MASK_GEN(7,1) == 7) - LZOCHK_ASSERT(__LZO_MASK_GEN(7,2) == 7+14) - LZOCHK_ASSERT(__LZO_MASK_GEN(7,3) == 7+14+28) +LZOCHK_ASSERT(__LZO_MASK_GEN(2, 1) == 2) +LZOCHK_ASSERT(__LZO_MASK_GEN(4, 1) == 4) +LZOCHK_ASSERT(__LZO_MASK_GEN(8, 1) == 8) +LZOCHK_ASSERT(__LZO_MASK_GEN(2, 2) == 2 + 4) +LZOCHK_ASSERT(__LZO_MASK_GEN(4, 2) == 4 + 8) +LZOCHK_ASSERT(__LZO_MASK_GEN(8, 2) == 8 + 16) +LZOCHK_ASSERT(__LZO_MASK_GEN(2, 3) == 2 + 4 + 8) +LZOCHK_ASSERT(__LZO_MASK_GEN(4, 3) == 4 + 8 + 16) +LZOCHK_ASSERT(__LZO_MASK_GEN(8, 3) == 8 + 16 + 32) +LZOCHK_ASSERT(__LZO_MASK_GEN(7, 1) == 7) +LZOCHK_ASSERT(__LZO_MASK_GEN(7, 2) == 7 + 14) +LZOCHK_ASSERT(__LZO_MASK_GEN(7, 3) == 7 + 14 + 28) #endif #if !(LZO_BROKEN_SIGNED_RIGHT_SHIFT) - LZOCHK_ASSERT(((-1) >> 7) == -1) +LZOCHK_ASSERT(((-1) >> 7) == -1) #endif - LZOCHK_ASSERT(((1) >> 7) == 0) +LZOCHK_ASSERT(((1) >> 7) == 0) #if (LZO_CC_INTELC && (__INTEL_COMPILER >= 900)) # pragma warning(push) # pragma warning(disable: 1025) #endif - LZOCHK_ASSERT((~0l & ~0) == ~0l) - LZOCHK_ASSERT((~0l & ~0u) == ~0u) - LZOCHK_ASSERT((~0ul & ~0) == ~0ul) - LZOCHK_ASSERT((~0ul & ~0u) == ~0u) +LZOCHK_ASSERT((~0l & ~0) == ~0l) +LZOCHK_ASSERT((~0l & ~0u) == ~0u) +LZOCHK_ASSERT((~0ul & ~0) == ~0ul) +LZOCHK_ASSERT((~0ul & ~0u) == ~0u) #if defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0150) #elif (LZO_SIZEOF_INT == 2) - LZOCHK_ASSERT((~0l & ~0u) == 0xffffU) - LZOCHK_ASSERT((~0ul & ~0u) == 0xffffU) +LZOCHK_ASSERT((~0l & ~0u) == 0xffffU) +LZOCHK_ASSERT((~0ul & ~0u) == 0xffffU) #elif (LZO_SIZEOF_INT == 4) - LZOCHK_ASSERT((~0l & ~0u) == 0xffffffffU) - LZOCHK_ASSERT((~0ul & ~0u) == 0xffffffffU) +LZOCHK_ASSERT((~0l & ~0u) == 0xffffffffU) +LZOCHK_ASSERT((~0ul & ~0u) == 0xffffffffU) #endif #if (LZO_CC_INTELC && (__INTEL_COMPILER >= 900)) # pragma warning(pop) #endif - LZOCHK_ASSERT_IS_SIGNED_T(signed char) - LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned char) - LZOCHK_ASSERT(sizeof(signed char) == sizeof(char)) - LZOCHK_ASSERT(sizeof(unsigned char) == sizeof(char)) - LZOCHK_ASSERT(sizeof(char) == 1) +LZOCHK_ASSERT_IS_SIGNED_T(signed char) +LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned char) +LZOCHK_ASSERT(sizeof(signed char) == sizeof(char)) +LZOCHK_ASSERT(sizeof(unsigned char) == sizeof(char)) +LZOCHK_ASSERT(sizeof(char) == 1) #if (LZO_CC_CILLY) && (!defined(__CILLY__) || (__CILLY__ < 0x010302L)) #else - LZOCHK_ASSERT(sizeof(char) == sizeof(LZO_STATIC_CAST(char, 0))) +LZOCHK_ASSERT(sizeof(char) == sizeof(LZO_STATIC_CAST(char, 0))) #endif #if defined(__cplusplus) - LZOCHK_ASSERT(sizeof('\0') == sizeof(char)) +LZOCHK_ASSERT(sizeof('\0') == sizeof(char)) #else # if (LZO_CC_DMC) # else - LZOCHK_ASSERT(sizeof('\0') == sizeof(int)) +LZOCHK_ASSERT(sizeof('\0') == sizeof(int)) # endif #endif #if defined(__lzo_alignof) - LZOCHK_ASSERT(__lzo_alignof(char) == 1) - LZOCHK_ASSERT(__lzo_alignof(signed char) == 1) - LZOCHK_ASSERT(__lzo_alignof(unsigned char) == 1) +LZOCHK_ASSERT(__lzo_alignof(char) == 1) +LZOCHK_ASSERT(__lzo_alignof(signed char) == 1) +LZOCHK_ASSERT(__lzo_alignof(unsigned char) == 1) #if defined(lzo_int16e_t) - LZOCHK_ASSERT(__lzo_alignof(lzo_int16e_t) >= 1) - LZOCHK_ASSERT(__lzo_alignof(lzo_int16e_t) <= 2) +LZOCHK_ASSERT(__lzo_alignof(lzo_int16e_t) >= 1) +LZOCHK_ASSERT(__lzo_alignof(lzo_int16e_t) <= 2) #endif #if defined(lzo_int32e_t) - LZOCHK_ASSERT(__lzo_alignof(lzo_int32e_t) >= 1) - LZOCHK_ASSERT(__lzo_alignof(lzo_int32e_t) <= 4) +LZOCHK_ASSERT(__lzo_alignof(lzo_int32e_t) >= 1) +LZOCHK_ASSERT(__lzo_alignof(lzo_int32e_t) <= 4) #endif #endif - LZOCHK_ASSERT_IS_SIGNED_T(short) - LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned short) - LZOCHK_ASSERT(sizeof(short) == sizeof(unsigned short)) +LZOCHK_ASSERT_IS_SIGNED_T(short) +LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned short) +LZOCHK_ASSERT(sizeof(short) == sizeof(unsigned short)) #if !(LZO_ABI_I8LP16) - LZOCHK_ASSERT(sizeof(short) >= 2) +LZOCHK_ASSERT(sizeof(short) >= 2) #endif - LZOCHK_ASSERT(sizeof(short) >= sizeof(char)) +LZOCHK_ASSERT(sizeof(short) >= sizeof(char)) #if (LZO_CC_CILLY) && (!defined(__CILLY__) || (__CILLY__ < 0x010302L)) #else - LZOCHK_ASSERT(sizeof(short) == sizeof(LZO_STATIC_CAST(short, 0))) +LZOCHK_ASSERT(sizeof(short) == sizeof(LZO_STATIC_CAST(short, 0))) #endif #if (LZO_SIZEOF_SHORT > 0) - LZOCHK_ASSERT(sizeof(short) == LZO_SIZEOF_SHORT) +LZOCHK_ASSERT(sizeof(short) == LZO_SIZEOF_SHORT) #endif - LZOCHK_ASSERT_IS_SIGNED_T(int) - LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned int) - LZOCHK_ASSERT(sizeof(int) == sizeof(unsigned int)) +LZOCHK_ASSERT_IS_SIGNED_T(int) +LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned int) +LZOCHK_ASSERT(sizeof(int) == sizeof(unsigned int)) #if !(LZO_ABI_I8LP16) - LZOCHK_ASSERT(sizeof(int) >= 2) +LZOCHK_ASSERT(sizeof(int) >= 2) #endif - LZOCHK_ASSERT(sizeof(int) >= sizeof(short)) - LZOCHK_ASSERT(sizeof(int) == sizeof(0)) - LZOCHK_ASSERT(sizeof(int) == sizeof(LZO_STATIC_CAST(int, 0))) +LZOCHK_ASSERT(sizeof(int) >= sizeof(short)) +LZOCHK_ASSERT(sizeof(int) == sizeof(0)) +LZOCHK_ASSERT(sizeof(int) == sizeof(LZO_STATIC_CAST(int, 0))) #if (LZO_SIZEOF_INT > 0) - LZOCHK_ASSERT(sizeof(int) == LZO_SIZEOF_INT) +LZOCHK_ASSERT(sizeof(int) == LZO_SIZEOF_INT) #endif - LZOCHK_ASSERT(sizeof(0) == sizeof(int)) - LZOCHK_ASSERT_IS_SIGNED_T(long) - LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned long) - LZOCHK_ASSERT(sizeof(long) == sizeof(unsigned long)) +LZOCHK_ASSERT(sizeof(0) == sizeof(int)) +LZOCHK_ASSERT_IS_SIGNED_T(long) +LZOCHK_ASSERT_IS_UNSIGNED_T(unsigned long) +LZOCHK_ASSERT(sizeof(long) == sizeof(unsigned long)) #if !(LZO_ABI_I8LP16) - LZOCHK_ASSERT(sizeof(long) >= 4) +LZOCHK_ASSERT(sizeof(long) >= 4) #endif - LZOCHK_ASSERT(sizeof(long) >= sizeof(int)) - LZOCHK_ASSERT(sizeof(long) == sizeof(0L)) - LZOCHK_ASSERT(sizeof(long) == sizeof(LZO_STATIC_CAST(long, 0))) +LZOCHK_ASSERT(sizeof(long) >= sizeof(int)) +LZOCHK_ASSERT(sizeof(long) == sizeof(0L)) +LZOCHK_ASSERT(sizeof(long) == sizeof(LZO_STATIC_CAST(long, 0))) #if (LZO_SIZEOF_LONG > 0) - LZOCHK_ASSERT(sizeof(long) == LZO_SIZEOF_LONG) +LZOCHK_ASSERT(sizeof(long) == LZO_SIZEOF_LONG) #endif - LZOCHK_ASSERT(sizeof(0L) == sizeof(long)) - LZOCHK_ASSERT_IS_UNSIGNED_T(size_t) - LZOCHK_ASSERT(sizeof(size_t) >= sizeof(int)) - LZOCHK_ASSERT(sizeof(size_t) == sizeof(sizeof(0))) +LZOCHK_ASSERT(sizeof(0L) == sizeof(long)) +LZOCHK_ASSERT_IS_UNSIGNED_T(size_t) +LZOCHK_ASSERT(sizeof(size_t) >= sizeof(int)) +LZOCHK_ASSERT(sizeof(size_t) == sizeof(sizeof(0))) #if (LZO_SIZEOF_SIZE_T > 0) - LZOCHK_ASSERT(sizeof(size_t) == LZO_SIZEOF_SIZE_T) +LZOCHK_ASSERT(sizeof(size_t) == LZO_SIZEOF_SIZE_T) #endif - LZOCHK_ASSERT_IS_SIGNED_T(ptrdiff_t) - LZOCHK_ASSERT(sizeof(ptrdiff_t) >= sizeof(int)) - LZOCHK_ASSERT(sizeof(ptrdiff_t) >= sizeof(size_t)) +LZOCHK_ASSERT_IS_SIGNED_T(ptrdiff_t) +LZOCHK_ASSERT(sizeof(ptrdiff_t) >= sizeof(int)) +LZOCHK_ASSERT(sizeof(ptrdiff_t) >= sizeof(size_t)) #if !(LZO_BROKEN_SIZEOF) - LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(LZO_STATIC_CAST(char*, 0) - LZO_STATIC_CAST(char*, 0))) +LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(LZO_STATIC_CAST(char*, 0) - LZO_STATIC_CAST(char*, 0))) # if (LZO_HAVE_MM_HUGE_PTR) - LZOCHK_ASSERT(4 == sizeof(LZO_STATIC_CAST(char __huge*, 0) - LZO_STATIC_CAST(char __huge*, 0))) +LZOCHK_ASSERT(4 == sizeof(LZO_STATIC_CAST(char __huge*, 0) - LZO_STATIC_CAST(char __huge*, 0))) # endif #endif #if (LZO_SIZEOF_PTRDIFF_T > 0) - LZOCHK_ASSERT(sizeof(ptrdiff_t) == LZO_SIZEOF_PTRDIFF_T) +LZOCHK_ASSERT(sizeof(ptrdiff_t) == LZO_SIZEOF_PTRDIFF_T) #endif - LZOCHK_ASSERT(sizeof(void*) >= sizeof(char*)) +LZOCHK_ASSERT(sizeof(void*) >= sizeof(char*)) #if (LZO_SIZEOF_VOID_P > 0) - LZOCHK_ASSERT(sizeof(void*) == LZO_SIZEOF_VOID_P) - LZOCHK_ASSERT(sizeof(char*) == LZO_SIZEOF_VOID_P) +LZOCHK_ASSERT(sizeof(void*) == LZO_SIZEOF_VOID_P) +LZOCHK_ASSERT(sizeof(char*) == LZO_SIZEOF_VOID_P) #endif #if (LZO_HAVE_MM_HUGE_PTR) - LZOCHK_ASSERT(4 == sizeof(void __huge*)) - LZOCHK_ASSERT(4 == sizeof(char __huge*)) +LZOCHK_ASSERT(4 == sizeof(void __huge*)) +LZOCHK_ASSERT(4 == sizeof(char __huge*)) #endif #if (LZO_ABI_I8LP16) - LZOCHK_ASSERT((((1u << 7) + 1) >> 7) == 1) - LZOCHK_ASSERT((((1ul << 15) + 1) >> 15) == 1) +LZOCHK_ASSERT((((1u << 7) + 1) >> 7) == 1) +LZOCHK_ASSERT((((1ul << 15) + 1) >> 15) == 1) #else - LZOCHK_ASSERT((((1u << 15) + 1) >> 15) == 1) - LZOCHK_ASSERT((((1ul << 31) + 1) >> 31) == 1) +LZOCHK_ASSERT((((1u << 15) + 1) >> 15) == 1) +LZOCHK_ASSERT((((1ul << 31) + 1) >> 31) == 1) #endif #if defined(LZOCHK_CFG_PEDANTIC) #if defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0150) #else - LZOCHK_ASSERT((1 << (8*LZO_SIZEOF_INT-1)) < 0) +LZOCHK_ASSERT((1 << (8 * LZO_SIZEOF_INT - 1)) < 0) #endif #endif - LZOCHK_ASSERT((1u << (8*LZO_SIZEOF_INT-1)) > 0) +LZOCHK_ASSERT((1u << (8 * LZO_SIZEOF_INT - 1)) > 0) #if defined(LZOCHK_CFG_PEDANTIC) - LZOCHK_ASSERT((1l << (8*LZO_SIZEOF_LONG-1)) < 0) +LZOCHK_ASSERT((1l << (8 * LZO_SIZEOF_LONG - 1)) < 0) #endif - LZOCHK_ASSERT((1ul << (8*LZO_SIZEOF_LONG-1)) > 0) +LZOCHK_ASSERT((1ul << (8 * LZO_SIZEOF_LONG - 1)) > 0) #if defined(lzo_int16e_t) - LZOCHK_ASSERT(sizeof(lzo_int16e_t) == 2) - LZOCHK_ASSERT(sizeof(lzo_int16e_t) == LZO_SIZEOF_LZO_INT16E_T) - LZOCHK_ASSERT(sizeof(lzo_uint16e_t) == 2) - LZOCHK_ASSERT(sizeof(lzo_int16e_t) == sizeof(lzo_uint16e_t)) - LZOCHK_ASSERT_IS_SIGNED_T(lzo_int16e_t) - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint16e_t) +LZOCHK_ASSERT(sizeof(lzo_int16e_t) == 2) +LZOCHK_ASSERT(sizeof(lzo_int16e_t) == LZO_SIZEOF_LZO_INT16E_T) +LZOCHK_ASSERT(sizeof(lzo_uint16e_t) == 2) +LZOCHK_ASSERT(sizeof(lzo_int16e_t) == sizeof(lzo_uint16e_t)) +LZOCHK_ASSERT_IS_SIGNED_T(lzo_int16e_t) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint16e_t) #if defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0150) #else - LZOCHK_ASSERT((LZO_STATIC_CAST(lzo_uint16e_t, (~LZO_STATIC_CAST(lzo_uint16e_t,0ul))) >> 15) == 1) +LZOCHK_ASSERT((LZO_STATIC_CAST(lzo_uint16e_t, (~LZO_STATIC_CAST(lzo_uint16e_t, 0ul))) >> 15) == 1) #endif - LZOCHK_ASSERT( LZO_STATIC_CAST(lzo_int16e_t, (1 + ~LZO_STATIC_CAST(lzo_int16e_t, 0))) == 0) +LZOCHK_ASSERT(LZO_STATIC_CAST(lzo_int16e_t, (1 + ~LZO_STATIC_CAST(lzo_int16e_t, 0))) == 0) #if defined(LZOCHK_CFG_PEDANTIC) - LZOCHK_ASSERT( LZO_STATIC_CAST(lzo_uint16e_t, (1 + ~LZO_STATIC_CAST(lzo_uint16e_t, 0))) == 0) +LZOCHK_ASSERT(LZO_STATIC_CAST(lzo_uint16e_t, (1 + ~LZO_STATIC_CAST(lzo_uint16e_t, 0))) == 0) #endif #endif #if defined(lzo_int32e_t) - LZOCHK_ASSERT(sizeof(lzo_int32e_t) == 4) - LZOCHK_ASSERT(sizeof(lzo_int32e_t) == LZO_SIZEOF_LZO_INT32E_T) - LZOCHK_ASSERT(sizeof(lzo_uint32e_t) == 4) - LZOCHK_ASSERT(sizeof(lzo_int32e_t) == sizeof(lzo_uint32e_t)) - LZOCHK_ASSERT_IS_SIGNED_T(lzo_int32e_t) - LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_int32e_t, 1) << 30) + 1) >> 30) == 1) - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32e_t) - LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_uint32e_t, 1) << 31) + 1) >> 31) == 1) - LZOCHK_ASSERT((LZO_STATIC_CAST(lzo_uint32e_t, (~LZO_STATIC_CAST(lzo_uint32e_t, 0ul))) >> 31) == 1) - LZOCHK_ASSERT( LZO_STATIC_CAST(lzo_int32e_t, (1 + ~LZO_STATIC_CAST(lzo_int32e_t, 0))) == 0) +LZOCHK_ASSERT(sizeof(lzo_int32e_t) == 4) +LZOCHK_ASSERT(sizeof(lzo_int32e_t) == LZO_SIZEOF_LZO_INT32E_T) +LZOCHK_ASSERT(sizeof(lzo_uint32e_t) == 4) +LZOCHK_ASSERT(sizeof(lzo_int32e_t) == sizeof(lzo_uint32e_t)) +LZOCHK_ASSERT_IS_SIGNED_T(lzo_int32e_t) +LZOCHK_ASSERT((((LZO_STATIC_CAST(lzo_int32e_t, 1) << 30) + 1) >> 30) == 1) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32e_t) +LZOCHK_ASSERT((((LZO_STATIC_CAST(lzo_uint32e_t, 1) << 31) + 1) >> 31) == 1) +LZOCHK_ASSERT((LZO_STATIC_CAST(lzo_uint32e_t, (~LZO_STATIC_CAST(lzo_uint32e_t, 0ul))) >> 31) == 1) +LZOCHK_ASSERT(LZO_STATIC_CAST(lzo_int32e_t, (1 + ~LZO_STATIC_CAST(lzo_int32e_t, 0))) == 0) #if defined(LZOCHK_CFG_PEDANTIC) - LZOCHK_ASSERT( LZO_STATIC_CAST(lzo_uint32e_t, (1 + ~LZO_STATIC_CAST(lzo_uint32e_t, 0))) == 0) +LZOCHK_ASSERT(LZO_STATIC_CAST(lzo_uint32e_t, (1 + ~LZO_STATIC_CAST(lzo_uint32e_t, 0))) == 0) #endif #endif #if defined(lzo_int32e_t) - LZOCHK_ASSERT(sizeof(lzo_int32l_t) >= sizeof(lzo_int32e_t)) +LZOCHK_ASSERT(sizeof(lzo_int32l_t) >= sizeof(lzo_int32e_t)) #endif - LZOCHK_ASSERT(sizeof(lzo_int32l_t) >= 4) - LZOCHK_ASSERT(sizeof(lzo_int32l_t) == LZO_SIZEOF_LZO_INT32L_T) - LZOCHK_ASSERT(sizeof(lzo_uint32l_t) >= 4) - LZOCHK_ASSERT(sizeof(lzo_int32l_t) == sizeof(lzo_uint32l_t)) - LZOCHK_ASSERT_IS_SIGNED_T(lzo_int32l_t) - LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_int32l_t, 1) << 30) + 1) >> 30) == 1) - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32l_t) - LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_uint32l_t, 1) << 31) + 1) >> 31) == 1) - LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(int)) +LZOCHK_ASSERT(sizeof(lzo_int32l_t) >= 4) +LZOCHK_ASSERT(sizeof(lzo_int32l_t) == LZO_SIZEOF_LZO_INT32L_T) +LZOCHK_ASSERT(sizeof(lzo_uint32l_t) >= 4) +LZOCHK_ASSERT(sizeof(lzo_int32l_t) == sizeof(lzo_uint32l_t)) +LZOCHK_ASSERT_IS_SIGNED_T(lzo_int32l_t) +LZOCHK_ASSERT((((LZO_STATIC_CAST(lzo_int32l_t, 1) << 30) + 1) >> 30) == 1) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32l_t) +LZOCHK_ASSERT((((LZO_STATIC_CAST(lzo_uint32l_t, 1) << 31) + 1) >> 31) == 1) +LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(int)) #if defined(lzo_int32e_t) - LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(lzo_int32e_t)) +LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(lzo_int32e_t)) #endif - LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(lzo_int32l_t)) - LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= 4) - LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(lzo_int32l_t)) - LZOCHK_ASSERT(sizeof(lzo_int32f_t) == LZO_SIZEOF_LZO_INT32F_T) - LZOCHK_ASSERT(sizeof(lzo_uint32f_t) >= 4) - LZOCHK_ASSERT(sizeof(lzo_uint32f_t) >= sizeof(lzo_uint32l_t)) - LZOCHK_ASSERT(sizeof(lzo_int32f_t) == sizeof(lzo_uint32f_t)) - LZOCHK_ASSERT_IS_SIGNED_T(lzo_int32f_t) - LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_int32f_t, 1) << 30) + 1) >> 30) == 1) - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32f_t) - LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_uint32f_t, 1) << 31) + 1) >> 31) == 1) +LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(lzo_int32l_t)) +LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= 4) +LZOCHK_ASSERT(sizeof(lzo_int32f_t) >= sizeof(lzo_int32l_t)) +LZOCHK_ASSERT(sizeof(lzo_int32f_t) == LZO_SIZEOF_LZO_INT32F_T) +LZOCHK_ASSERT(sizeof(lzo_uint32f_t) >= 4) +LZOCHK_ASSERT(sizeof(lzo_uint32f_t) >= sizeof(lzo_uint32l_t)) +LZOCHK_ASSERT(sizeof(lzo_int32f_t) == sizeof(lzo_uint32f_t)) +LZOCHK_ASSERT_IS_SIGNED_T(lzo_int32f_t) +LZOCHK_ASSERT((((LZO_STATIC_CAST(lzo_int32f_t, 1) << 30) + 1) >> 30) == 1) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32f_t) +LZOCHK_ASSERT((((LZO_STATIC_CAST(lzo_uint32f_t, 1) << 31) + 1) >> 31) == 1) #if defined(lzo_int64e_t) - LZOCHK_ASSERT(sizeof(lzo_int64e_t) == 8) - LZOCHK_ASSERT(sizeof(lzo_int64e_t) == LZO_SIZEOF_LZO_INT64E_T) - LZOCHK_ASSERT(sizeof(lzo_uint64e_t) == 8) - LZOCHK_ASSERT(sizeof(lzo_int64e_t) == sizeof(lzo_uint64e_t)) - LZOCHK_ASSERT_IS_SIGNED_T(lzo_int64e_t) +LZOCHK_ASSERT(sizeof(lzo_int64e_t) == 8) +LZOCHK_ASSERT(sizeof(lzo_int64e_t) == LZO_SIZEOF_LZO_INT64E_T) +LZOCHK_ASSERT(sizeof(lzo_uint64e_t) == 8) +LZOCHK_ASSERT(sizeof(lzo_int64e_t) == sizeof(lzo_uint64e_t)) +LZOCHK_ASSERT_IS_SIGNED_T(lzo_int64e_t) #if (LZO_CC_BORLANDC && (__BORLANDC__ < 0x0530)) #else - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64e_t) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64e_t) #endif #endif #if defined(lzo_int64l_t) #if defined(lzo_int64e_t) - LZOCHK_ASSERT(sizeof(lzo_int64l_t) >= sizeof(lzo_int64e_t)) +LZOCHK_ASSERT(sizeof(lzo_int64l_t) >= sizeof(lzo_int64e_t)) #endif - LZOCHK_ASSERT(sizeof(lzo_int64l_t) >= 8) - LZOCHK_ASSERT(sizeof(lzo_int64l_t) == LZO_SIZEOF_LZO_INT64L_T) - LZOCHK_ASSERT(sizeof(lzo_uint64l_t) >= 8) - LZOCHK_ASSERT(sizeof(lzo_int64l_t) == sizeof(lzo_uint64l_t)) - LZOCHK_ASSERT_IS_SIGNED_T(lzo_int64l_t) - LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_int64l_t, 1) << 62) + 1) >> 62) == 1) - LZOCHK_ASSERT(((( LZO_INT64_C(1) << 62) + 1) >> 62) == 1) +LZOCHK_ASSERT(sizeof(lzo_int64l_t) >= 8) +LZOCHK_ASSERT(sizeof(lzo_int64l_t) == LZO_SIZEOF_LZO_INT64L_T) +LZOCHK_ASSERT(sizeof(lzo_uint64l_t) >= 8) +LZOCHK_ASSERT(sizeof(lzo_int64l_t) == sizeof(lzo_uint64l_t)) +LZOCHK_ASSERT_IS_SIGNED_T(lzo_int64l_t) +LZOCHK_ASSERT((((LZO_STATIC_CAST(lzo_int64l_t, 1) << 62) + 1) >> 62) == 1) +LZOCHK_ASSERT((((LZO_INT64_C(1) << 62) + 1) >> 62) == 1) #if (LZO_CC_BORLANDC && (__BORLANDC__ < 0x0530)) #else - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64l_t) - LZOCHK_ASSERT(LZO_UINT64_C(18446744073709551615) > 0) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64l_t) +LZOCHK_ASSERT(LZO_UINT64_C(18446744073709551615) > 0) #endif - LZOCHK_ASSERT(((( LZO_STATIC_CAST(lzo_uint64l_t, 1) << 63) + 1) >> 63) == 1) - LZOCHK_ASSERT(((( LZO_UINT64_C(1) << 63) + 1) >> 63) == 1) +LZOCHK_ASSERT((((LZO_STATIC_CAST(lzo_uint64l_t, 1) << 63) + 1) >> 63) == 1) +LZOCHK_ASSERT((((LZO_UINT64_C(1) << 63) + 1) >> 63) == 1) #if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x020600ul)) - LZOCHK_ASSERT(LZO_INT64_C(9223372036854775807) > LZO_INT64_C(0)) +LZOCHK_ASSERT(LZO_INT64_C(9223372036854775807) > LZO_INT64_C(0)) #else - LZOCHK_ASSERT(LZO_INT64_C(9223372036854775807) > 0) +LZOCHK_ASSERT(LZO_INT64_C(9223372036854775807) > 0) #endif - LZOCHK_ASSERT(LZO_INT64_C(-9223372036854775807) - 1 < 0) - LZOCHK_ASSERT( LZO_INT64_C(9223372036854775807) % LZO_INT32_C(2147483629) == 721) - LZOCHK_ASSERT( LZO_INT64_C(9223372036854775807) % LZO_INT32_C(2147483647) == 1) - LZOCHK_ASSERT(LZO_UINT64_C(9223372036854775807) % LZO_UINT32_C(2147483629) == 721) - LZOCHK_ASSERT(LZO_UINT64_C(9223372036854775807) % LZO_UINT32_C(2147483647) == 1) +LZOCHK_ASSERT(LZO_INT64_C(-9223372036854775807) - 1 < 0) +LZOCHK_ASSERT(LZO_INT64_C(9223372036854775807) % LZO_INT32_C(2147483629) == 721) +LZOCHK_ASSERT(LZO_INT64_C(9223372036854775807) % LZO_INT32_C(2147483647) == 1) +LZOCHK_ASSERT(LZO_UINT64_C(9223372036854775807) % LZO_UINT32_C(2147483629) == 721) +LZOCHK_ASSERT(LZO_UINT64_C(9223372036854775807) % LZO_UINT32_C(2147483647) == 1) #endif #if defined(lzo_int64f_t) #if defined(lzo_int64e_t) - LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= sizeof(lzo_int64e_t)) +LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= sizeof(lzo_int64e_t)) #endif - LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= sizeof(lzo_int64l_t)) - LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= 8) - LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= sizeof(lzo_int64l_t)) - LZOCHK_ASSERT(sizeof(lzo_int64f_t) == LZO_SIZEOF_LZO_INT64F_T) - LZOCHK_ASSERT(sizeof(lzo_uint64f_t) >= 8) - LZOCHK_ASSERT(sizeof(lzo_uint64f_t) >= sizeof(lzo_uint64l_t)) - LZOCHK_ASSERT(sizeof(lzo_int64f_t) == sizeof(lzo_uint64f_t)) - LZOCHK_ASSERT_IS_SIGNED_T(lzo_int64f_t) +LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= sizeof(lzo_int64l_t)) +LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= 8) +LZOCHK_ASSERT(sizeof(lzo_int64f_t) >= sizeof(lzo_int64l_t)) +LZOCHK_ASSERT(sizeof(lzo_int64f_t) == LZO_SIZEOF_LZO_INT64F_T) +LZOCHK_ASSERT(sizeof(lzo_uint64f_t) >= 8) +LZOCHK_ASSERT(sizeof(lzo_uint64f_t) >= sizeof(lzo_uint64l_t)) +LZOCHK_ASSERT(sizeof(lzo_int64f_t) == sizeof(lzo_uint64f_t)) +LZOCHK_ASSERT_IS_SIGNED_T(lzo_int64f_t) #if (LZO_CC_BORLANDC && (__BORLANDC__ < 0x0530)) #else - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64f_t) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64f_t) #endif #endif #if !defined(__LZO_INTPTR_T_IS_POINTER) - LZOCHK_ASSERT_IS_SIGNED_T(lzo_intptr_t) - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t) +LZOCHK_ASSERT_IS_SIGNED_T(lzo_intptr_t) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t) #endif - LZOCHK_ASSERT(sizeof(lzo_intptr_t) >= sizeof(void *)) - LZOCHK_ASSERT(sizeof(lzo_intptr_t) == LZO_SIZEOF_LZO_INTPTR_T) - LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(lzo_uintptr_t)) +LZOCHK_ASSERT(sizeof(lzo_intptr_t) >= sizeof(void*)) +LZOCHK_ASSERT(sizeof(lzo_intptr_t) == LZO_SIZEOF_LZO_INTPTR_T) +LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(lzo_uintptr_t)) #if defined(lzo_word_t) - LZOCHK_ASSERT(LZO_WORDSIZE == LZO_SIZEOF_LZO_WORD_T) - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_word_t) - LZOCHK_ASSERT_IS_SIGNED_T(lzo_sword_t) - LZOCHK_ASSERT(sizeof(lzo_word_t) == LZO_SIZEOF_LZO_WORD_T) - LZOCHK_ASSERT(sizeof(lzo_word_t) == sizeof(lzo_sword_t)) +LZOCHK_ASSERT(LZO_WORDSIZE == LZO_SIZEOF_LZO_WORD_T) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_word_t) +LZOCHK_ASSERT_IS_SIGNED_T(lzo_sword_t) +LZOCHK_ASSERT(sizeof(lzo_word_t) == LZO_SIZEOF_LZO_WORD_T) +LZOCHK_ASSERT(sizeof(lzo_word_t) == sizeof(lzo_sword_t)) #endif - LZOCHK_ASSERT(sizeof(lzo_int8_t) == 1) - LZOCHK_ASSERT(sizeof(lzo_uint8_t) == 1) - LZOCHK_ASSERT(sizeof(lzo_int8_t) == sizeof(lzo_uint8_t)) - LZOCHK_ASSERT_IS_SIGNED_T(lzo_int8_t) - LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint8_t) +LZOCHK_ASSERT(sizeof(lzo_int8_t) == 1) +LZOCHK_ASSERT(sizeof(lzo_uint8_t) == 1) +LZOCHK_ASSERT(sizeof(lzo_int8_t) == sizeof(lzo_uint8_t)) +LZOCHK_ASSERT_IS_SIGNED_T(lzo_int8_t) +LZOCHK_ASSERT_IS_UNSIGNED_T(lzo_uint8_t) #if defined(LZO_INT16_C) - LZOCHK_ASSERT(sizeof(LZO_INT16_C(0)) >= 2) - LZOCHK_ASSERT(sizeof(LZO_UINT16_C(0)) >= 2) - LZOCHK_ASSERT((LZO_UINT16_C(0xffff) >> 15) == 1) +LZOCHK_ASSERT(sizeof(LZO_INT16_C(0)) >= 2) +LZOCHK_ASSERT(sizeof(LZO_UINT16_C(0)) >= 2) +LZOCHK_ASSERT((LZO_UINT16_C(0xffff) >> 15) == 1) #endif #if defined(LZO_INT32_C) - LZOCHK_ASSERT(sizeof(LZO_INT32_C(0)) >= 4) - LZOCHK_ASSERT(sizeof(LZO_UINT32_C(0)) >= 4) - LZOCHK_ASSERT((LZO_UINT32_C(0xffffffff) >> 31) == 1) +LZOCHK_ASSERT(sizeof(LZO_INT32_C(0)) >= 4) +LZOCHK_ASSERT(sizeof(LZO_UINT32_C(0)) >= 4) +LZOCHK_ASSERT((LZO_UINT32_C(0xffffffff) >> 31) == 1) #endif #if defined(LZO_INT64_C) #if (LZO_CC_BORLANDC && (__BORLANDC__ < 0x0560)) #else - LZOCHK_ASSERT(sizeof(LZO_INT64_C(0)) >= 8) - LZOCHK_ASSERT(sizeof(LZO_UINT64_C(0)) >= 8) +LZOCHK_ASSERT(sizeof(LZO_INT64_C(0)) >= 8) +LZOCHK_ASSERT(sizeof(LZO_UINT64_C(0)) >= 8) #endif - LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) >> 63) == 1) - LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & ~0) == LZO_UINT64_C(0xffffffffffffffff)) - LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & ~0l) == LZO_UINT64_C(0xffffffffffffffff)) +LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) >> 63) == 1) +LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & ~0) == LZO_UINT64_C(0xffffffffffffffff)) +LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & ~0l) == LZO_UINT64_C(0xffffffffffffffff)) #if (LZO_SIZEOF_INT == 4) # if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x020000ul)) # else - LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & (~0u+0u)) == 0xffffffffu) +LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & (~0u + 0u)) == 0xffffffffu) # endif #endif #if (LZO_SIZEOF_LONG == 4) # if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x020000ul)) # else - LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & (~0ul+0ul)) == 0xfffffffful) +LZOCHK_ASSERT((LZO_UINT64_C(0xffffffffffffffff) & (~0ul + 0ul)) == 0xfffffffful) # endif #endif #endif #if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM) - LZOCHK_ASSERT(sizeof(void*) == 2) - LZOCHK_ASSERT(sizeof(ptrdiff_t) == 2) +LZOCHK_ASSERT(sizeof(void*) == 2) +LZOCHK_ASSERT(sizeof(ptrdiff_t) == 2) #elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE) - LZOCHK_ASSERT(sizeof(void*) == 4) +LZOCHK_ASSERT(sizeof(void*) == 4) #endif #if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_COMPACT) - LZOCHK_ASSERT(sizeof(void (*)(void)) == 2) +LZOCHK_ASSERT(sizeof(void (*)(void)) == 2) #elif (LZO_MM_MEDIUM || LZO_MM_LARGE || LZO_MM_HUGE) - LZOCHK_ASSERT(sizeof(void (*)(void)) == 4) +LZOCHK_ASSERT(sizeof(void (*)(void)) == 4) #endif #if (LZO_ABI_ILP32) - LZOCHK_ASSERT(sizeof(int) == 4) - LZOCHK_ASSERT(sizeof(long) == 4) - LZOCHK_ASSERT(sizeof(void*) == 4) - LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) - LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) - LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) +LZOCHK_ASSERT(sizeof(int) == 4) +LZOCHK_ASSERT(sizeof(long) == 4) +LZOCHK_ASSERT(sizeof(void*) == 4) +LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) +LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) +LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void*)) #endif #if (LZO_ABI_ILP64) - LZOCHK_ASSERT(sizeof(int) == 8) - LZOCHK_ASSERT(sizeof(long) == 8) - LZOCHK_ASSERT(sizeof(void*) == 8) - LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) - LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) - LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) +LZOCHK_ASSERT(sizeof(int) == 8) +LZOCHK_ASSERT(sizeof(long) == 8) +LZOCHK_ASSERT(sizeof(void*) == 8) +LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) +LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) +LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void*)) #endif #if (LZO_ABI_IP32L64) - LZOCHK_ASSERT(sizeof(int) == 4) - LZOCHK_ASSERT(sizeof(long) == 8) - LZOCHK_ASSERT(sizeof(void*) == 4) - LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) - LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) - LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) +LZOCHK_ASSERT(sizeof(int) == 4) +LZOCHK_ASSERT(sizeof(long) == 8) +LZOCHK_ASSERT(sizeof(void*) == 4) +LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) +LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) +LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void*)) #endif #if (LZO_ABI_LLP64) - LZOCHK_ASSERT(sizeof(int) == 4) - LZOCHK_ASSERT(sizeof(long) == 4) - LZOCHK_ASSERT(sizeof(void*) == 8) - LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) - LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) - LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) +LZOCHK_ASSERT(sizeof(int) == 4) +LZOCHK_ASSERT(sizeof(long) == 4) +LZOCHK_ASSERT(sizeof(void*) == 8) +LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) +LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) +LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void*)) #endif #if (LZO_ABI_LP32) - LZOCHK_ASSERT(sizeof(int) == 2) - LZOCHK_ASSERT(sizeof(long) == 4) - LZOCHK_ASSERT(sizeof(void*) == 4) - LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) +LZOCHK_ASSERT(sizeof(int) == 2) +LZOCHK_ASSERT(sizeof(long) == 4) +LZOCHK_ASSERT(sizeof(void*) == 4) +LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void*)) #endif #if (LZO_ABI_LP64) - LZOCHK_ASSERT(sizeof(int) == 4) - LZOCHK_ASSERT(sizeof(long) == 8) - LZOCHK_ASSERT(sizeof(void*) == 8) - LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) - LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) - LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) +LZOCHK_ASSERT(sizeof(int) == 4) +LZOCHK_ASSERT(sizeof(long) == 8) +LZOCHK_ASSERT(sizeof(void*) == 8) +LZOCHK_ASSERT(sizeof(ptrdiff_t) == sizeof(void*)) +LZOCHK_ASSERT(sizeof(size_t) == sizeof(void*)) +LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void*)) #endif #if (LZO_ARCH_I086) - LZOCHK_ASSERT(sizeof(size_t) == 2) - LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) +LZOCHK_ASSERT(sizeof(size_t) == 2) +LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void*)) #elif (LZO_ARCH_I386 || LZO_ARCH_M68K) - LZOCHK_ASSERT(sizeof(size_t) == 4) - LZOCHK_ASSERT(sizeof(ptrdiff_t) == 4) - LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void *)) +LZOCHK_ASSERT(sizeof(size_t) == 4) +LZOCHK_ASSERT(sizeof(ptrdiff_t) == 4) +LZOCHK_ASSERT(sizeof(lzo_intptr_t) == sizeof(void*)) #endif #if (LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_WIN32) - LZOCHK_ASSERT(sizeof(size_t) == 4) - LZOCHK_ASSERT(sizeof(ptrdiff_t) == 4) - LZOCHK_ASSERT(sizeof(void (*)(void)) == 4) +LZOCHK_ASSERT(sizeof(size_t) == 4) +LZOCHK_ASSERT(sizeof(ptrdiff_t) == 4) +LZOCHK_ASSERT(sizeof(void (*)(void)) == 4) #elif (LZO_OS_WIN64) - LZOCHK_ASSERT(sizeof(size_t) == 8) - LZOCHK_ASSERT(sizeof(ptrdiff_t) == 8) - LZOCHK_ASSERT(sizeof(void (*)(void)) == 8) +LZOCHK_ASSERT(sizeof(size_t) == 8) +LZOCHK_ASSERT(sizeof(ptrdiff_t) == 8) +LZOCHK_ASSERT(sizeof(void (*)(void)) == 8) #endif #if (LZO_CC_NDPC) #elif (LZO_SIZEOF_INT > 1) - LZOCHK_ASSERT( LZO_STATIC_CAST(int, LZO_STATIC_CAST(unsigned char, LZO_STATIC_CAST(signed char, -1))) == 255) +LZOCHK_ASSERT(LZO_STATIC_CAST(int, LZO_STATIC_CAST(unsigned char, LZO_STATIC_CAST(signed char, -1))) == 255) #endif #if defined(LZOCHK_CFG_PEDANTIC) #if (LZO_CC_KEILC) #elif (LZO_CC_NDPC) #elif !(LZO_BROKEN_INTEGRAL_PROMOTION) && (LZO_SIZEOF_INT > 1) - LZOCHK_ASSERT( ((LZO_STATIC_CAST(unsigned char, 128)) << LZO_STATIC_CAST(int, (8*sizeof(int)-8))) < 0) +LZOCHK_ASSERT(((LZO_STATIC_CAST(unsigned char, 128)) << LZO_STATIC_CAST(int, (8 * sizeof(int) - 8))) < 0) #endif #endif #if defined(LZOCHK_CFG_PEDANTIC) @@ -1973,9 +1984,9 @@ LZOLIB_EXTERN(int, lzo_spawnve) (int mode, const char* fn, const char* const * a #endif extern void* volatile lzo_vget_ptr__; #if (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x030400ul) || LZO_CC_LLVM) -void* volatile __attribute__((__used__)) lzo_vget_ptr__ = LZO_STATIC_CAST(void *, 0); +void* volatile __attribute__((__used__)) lzo_vget_ptr__ = LZO_STATIC_CAST(void*, 0); #else -void* volatile lzo_vget_ptr__ = LZO_STATIC_CAST(void *, 0); +void* volatile lzo_vget_ptr__ = LZO_STATIC_CAST(void*, 0); #endif #ifndef __LZOLIB_VGET_BODY #define __LZOLIB_VGET_BODY(T) \ @@ -1988,46 +1999,46 @@ void* volatile lzo_vget_ptr__ = LZO_STATIC_CAST(void *, 0); } \ return v; #endif -LZOLIB_PUBLIC_NOINLINE(short, lzo_vget_short) (short v, int expr) +LZOLIB_PUBLIC_NOINLINE(short, lzo_vget_short)(short v, int expr) { __LZOLIB_VGET_BODY(short) } -LZOLIB_PUBLIC_NOINLINE(int, lzo_vget_int) (int v, int expr) +LZOLIB_PUBLIC_NOINLINE(int, lzo_vget_int)(int v, int expr) { __LZOLIB_VGET_BODY(int) } -LZOLIB_PUBLIC_NOINLINE(long, lzo_vget_long) (long v, int expr) +LZOLIB_PUBLIC_NOINLINE(long, lzo_vget_long)(long v, int expr) { __LZOLIB_VGET_BODY(long) } #if defined(lzo_int64l_t) -LZOLIB_PUBLIC_NOINLINE(lzo_int64l_t, lzo_vget_lzo_int64l_t) (lzo_int64l_t v, int expr) +LZOLIB_PUBLIC_NOINLINE(lzo_int64l_t, lzo_vget_lzo_int64l_t)(lzo_int64l_t v, int expr) { __LZOLIB_VGET_BODY(lzo_int64l_t) } #endif -LZOLIB_PUBLIC_NOINLINE(lzo_hsize_t, lzo_vget_lzo_hsize_t) (lzo_hsize_t v, int expr) +LZOLIB_PUBLIC_NOINLINE(lzo_hsize_t, lzo_vget_lzo_hsize_t)(lzo_hsize_t v, int expr) { __LZOLIB_VGET_BODY(lzo_hsize_t) } #if !(LZO_CFG_NO_DOUBLE) -LZOLIB_PUBLIC_NOINLINE(double, lzo_vget_double) (double v, int expr) +LZOLIB_PUBLIC_NOINLINE(double, lzo_vget_double)(double v, int expr) { __LZOLIB_VGET_BODY(double) } #endif -LZOLIB_PUBLIC_NOINLINE(lzo_hvoid_p, lzo_vget_lzo_hvoid_p) (lzo_hvoid_p v, int expr) +LZOLIB_PUBLIC_NOINLINE(lzo_hvoid_p, lzo_vget_lzo_hvoid_p)(lzo_hvoid_p v, int expr) { __LZOLIB_VGET_BODY(lzo_hvoid_p) } #if (LZO_ARCH_I086 && LZO_CC_TURBOC && (__TURBOC__ == 0x0295)) && !defined(__cplusplus) -LZOLIB_PUBLIC_NOINLINE(lzo_hvoid_p, lzo_vget_lzo_hvoid_cp) (const lzo_hvoid_p vv, int expr) +LZOLIB_PUBLIC_NOINLINE(lzo_hvoid_p, lzo_vget_lzo_hvoid_cp)(const lzo_hvoid_p vv, int expr) { lzo_hvoid_p v = (lzo_hvoid_p) vv; __LZOLIB_VGET_BODY(lzo_hvoid_p) } #else -LZOLIB_PUBLIC_NOINLINE(const lzo_hvoid_p, lzo_vget_lzo_hvoid_cp) (const lzo_hvoid_p v, int expr) +LZOLIB_PUBLIC_NOINLINE(const lzo_hvoid_p, lzo_vget_lzo_hvoid_cp)(const lzo_hvoid_p v, int expr) { __LZOLIB_VGET_BODY(const lzo_hvoid_p) } @@ -2039,72 +2050,91 @@ LZOLIB_PUBLIC_NOINLINE(const lzo_hvoid_p, lzo_vget_lzo_hvoid_cp) (const lzo_hvoi #if !defined(LZOLIB_PUBLIC) # define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) #endif -LZOLIB_PUBLIC(int, lzo_hmemcmp) (const lzo_hvoid_p s1, const lzo_hvoid_p s2, lzo_hsize_t len) +LZOLIB_PUBLIC(int, lzo_hmemcmp)(const lzo_hvoid_p s1, const lzo_hvoid_p s2, lzo_hsize_t len) { #if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMCMP) const lzo_hbyte_p p1 = LZO_STATIC_CAST(const lzo_hbyte_p, s1); const lzo_hbyte_p p2 = LZO_STATIC_CAST(const lzo_hbyte_p, s2); + if __lzo_likely(len > 0) do - { - int d = *p1 - *p2; - if (d != 0) - return d; - p1++; p2++; - } while __lzo_likely(--len > 0); + { + int d = *p1 - *p2; + + if (d != 0) + return d; + + p1++; + p2++; + } + while __lzo_likely(--len > 0); + return 0; #else return memcmp(s1, s2, len); #endif } -LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemcpy) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len) +LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemcpy)(lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len) { #if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMCPY) lzo_hbyte_p p1 = LZO_STATIC_CAST(lzo_hbyte_p, dest); const lzo_hbyte_p p2 = LZO_STATIC_CAST(const lzo_hbyte_p, src); + if (!(len > 0) || p1 == p2) return dest; + do *p1++ = *p2++; + while __lzo_likely(--len > 0); + return dest; #else return memcpy(dest, src, len); #endif } -LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemmove) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len) +LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemmove)(lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len) { #if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMMOVE) lzo_hbyte_p p1 = LZO_STATIC_CAST(lzo_hbyte_p, dest); const lzo_hbyte_p p2 = LZO_STATIC_CAST(const lzo_hbyte_p, src); + if (!(len > 0) || p1 == p2) return dest; + if (p1 < p2) { do *p1++ = *p2++; + while __lzo_likely(--len > 0); } else { p1 += len; p2 += len; + do *--p1 = *--p2; + while __lzo_likely(--len > 0); } + return dest; #else return memmove(dest, src, len); #endif } -LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemset) (lzo_hvoid_p s, int cc, lzo_hsize_t len) +LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemset)(lzo_hvoid_p s, int cc, lzo_hsize_t len) { #if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMSET) lzo_hbyte_p p = LZO_STATIC_CAST(lzo_hbyte_p, s); unsigned char c = LZO_ITRUNC(unsigned char, cc); + if __lzo_likely(len > 0) do - *p++ = c; - while __lzo_likely(--len > 0); + *p++ = c; + + while __lzo_likely(--len > 0); + return s; #else return memset(s, cc, len); @@ -2117,23 +2147,24 @@ LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemset) (lzo_hvoid_p s, int cc, lzo_hsize_t len) #if !defined(LZOLIB_PUBLIC) # define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) #endif -LZOLIB_PUBLIC(void, lzo_srand31) (lzo_rand31_p r, lzo_uint32l_t seed) +LZOLIB_PUBLIC(void, lzo_srand31)(lzo_rand31_p r, lzo_uint32l_t seed) { r->seed = seed & LZO_UINT32_C(0xffffffff); } -LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand31) (lzo_rand31_p r) +LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand31)(lzo_rand31_p r) { r->seed = r->seed * LZO_UINT32_C(1103515245) + 12345; r->seed &= LZO_UINT32_C(0x7fffffff); return r->seed; } #if defined(lzo_int64l_t) -LZOLIB_PUBLIC(void, lzo_srand48) (lzo_rand48_p r, lzo_uint32l_t seed) +LZOLIB_PUBLIC(void, lzo_srand48)(lzo_rand48_p r, lzo_uint32l_t seed) { r->seed = seed & LZO_UINT32_C(0xffffffff); - r->seed <<= 16; r->seed |= 0x330e; + r->seed <<= 16; + r->seed |= 0x330e; } -LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand48) (lzo_rand48_p r) +LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand48)(lzo_rand48_p r) { lzo_uint64l_t a; r->seed = r->seed * LZO_UINT64_C(25214903917) + 11; @@ -2141,7 +2172,7 @@ LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand48) (lzo_rand48_p r) a = r->seed >> 17; return LZO_STATIC_CAST(lzo_uint32l_t, a); } -LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand48_r32) (lzo_rand48_p r) +LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand48_r32)(lzo_rand48_p r) { lzo_uint64l_t a; r->seed = r->seed * LZO_UINT64_C(25214903917) + 11; @@ -2151,11 +2182,11 @@ LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand48_r32) (lzo_rand48_p r) } #endif #if defined(lzo_int64l_t) -LZOLIB_PUBLIC(void, lzo_srand64) (lzo_rand64_p r, lzo_uint64l_t seed) +LZOLIB_PUBLIC(void, lzo_srand64)(lzo_rand64_p r, lzo_uint64l_t seed) { r->seed = seed & LZO_UINT64_C(0xffffffffffffffff); } -LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand64) (lzo_rand64_p r) +LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand64)(lzo_rand64_p r) { lzo_uint64l_t a; r->seed = r->seed * LZO_UINT64_C(6364136223846793005) + 1; @@ -2165,7 +2196,7 @@ LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand64) (lzo_rand64_p r) a = r->seed >> 33; return LZO_STATIC_CAST(lzo_uint32l_t, a); } -LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand64_r32) (lzo_rand64_p r) +LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand64_r32)(lzo_rand64_p r) { lzo_uint64l_t a; r->seed = r->seed * LZO_UINT64_C(6364136223846793005) + 1; @@ -2176,73 +2207,111 @@ LZOLIB_PUBLIC(lzo_uint32l_t, lzo_rand64_r32) (lzo_rand64_p r) return LZO_STATIC_CAST(lzo_uint32l_t, a); } #endif -LZOLIB_PUBLIC(void, lzo_srandmt) (lzo_randmt_p r, lzo_uint32l_t seed) +LZOLIB_PUBLIC(void, lzo_srandmt)(lzo_randmt_p r, lzo_uint32l_t seed) { unsigned i = 0; - do { + + do + { r->s[i++] = (seed &= LZO_UINT32_C(0xffffffff)); seed ^= seed >> 30; seed = seed * LZO_UINT32_C(0x6c078965) + i; - } while (i != 624); + } + while (i != 624); + r->n = i; } -LZOLIB_PUBLIC(lzo_uint32l_t, lzo_randmt) (lzo_randmt_p r) +LZOLIB_PUBLIC(lzo_uint32l_t, lzo_randmt)(lzo_randmt_p r) { return (__LZOLIB_FUNCNAME(lzo_randmt_r32)(r)) >> 1; } -LZOLIB_PUBLIC(lzo_uint32l_t, lzo_randmt_r32) (lzo_randmt_p r) +LZOLIB_PUBLIC(lzo_uint32l_t, lzo_randmt_r32)(lzo_randmt_p r) { lzo_uint32l_t v; - if __lzo_unlikely(r->n == 624) { + + if __lzo_unlikely(r->n == 624) + { unsigned i = 0, j; r->n = 0; - do { - j = i - 623; if (LZO_STATIC_CAST(int, j) < 0) j += 624; + + do + { + j = i - 623; + + if (LZO_STATIC_CAST(int, j) < 0) j += 624; + v = (r->s[i] & LZO_UINT32_C(0x80000000)) ^ (r->s[j] & LZO_UINT32_C(0x7fffffff)); - j = i - 227; if (LZO_STATIC_CAST(int, j) < 0) j += 624; + j = i - 227; + + if (LZO_STATIC_CAST(int, j) < 0) j += 624; + r->s[i] = r->s[j] ^ (v >> 1); + if (v & 1) r->s[i] ^= LZO_UINT32_C(0x9908b0df); - } while (++i != 624); + } + while (++i != 624); } + { unsigned i = r->n++; v = r->s[i]; } - v ^= v >> 11; v ^= (v & LZO_UINT32_C(0x013a58ad)) << 7; - v ^= (v & LZO_UINT32_C(0x0001df8c)) << 15; v ^= v >> 18; + + v ^= v >> 11; + v ^= (v & LZO_UINT32_C(0x013a58ad)) << 7; + v ^= (v & LZO_UINT32_C(0x0001df8c)) << 15; + v ^= v >> 18; return v; } #if defined(lzo_int64l_t) -LZOLIB_PUBLIC(void, lzo_srandmt64) (lzo_randmt64_p r, lzo_uint64l_t seed) +LZOLIB_PUBLIC(void, lzo_srandmt64)(lzo_randmt64_p r, lzo_uint64l_t seed) { unsigned i = 0; - do { + + do + { r->s[i++] = (seed &= LZO_UINT64_C(0xffffffffffffffff)); seed ^= seed >> 62; seed = seed * LZO_UINT64_C(0x5851f42d4c957f2d) + i; - } while (i != 312); + } + while (i != 312); + r->n = i; } #if 0 -LZOLIB_PUBLIC(lzo_uint32l_t, lzo_randmt64) (lzo_randmt64_p r) +LZOLIB_PUBLIC(lzo_uint32l_t, lzo_randmt64)(lzo_randmt64_p r) { lzo_uint64l_t v; v = (__LZOLIB_FUNCNAME(lzo_randmt64_r64)(r)) >> 33; return LZO_STATIC_CAST(lzo_uint32l_t, v); } #endif -LZOLIB_PUBLIC(lzo_uint64l_t, lzo_randmt64_r64) (lzo_randmt64_p r) +LZOLIB_PUBLIC(lzo_uint64l_t, lzo_randmt64_r64)(lzo_randmt64_p r) { lzo_uint64l_t v; - if __lzo_unlikely(r->n == 312) { + + if __lzo_unlikely(r->n == 312) + { unsigned i = 0, j; r->n = 0; - do { - j = i - 311; if (LZO_STATIC_CAST(int, j) < 0) j += 312; + + do + { + j = i - 311; + + if (LZO_STATIC_CAST(int, j) < 0) j += 312; + v = (r->s[i] & LZO_UINT64_C(0xffffffff80000000)) ^ (r->s[j] & LZO_UINT64_C(0x7fffffff)); - j = i - 156; if (LZO_STATIC_CAST(int, j) < 0) j += 312; + j = i - 156; + + if (LZO_STATIC_CAST(int, j) < 0) j += 312; + r->s[i] = r->s[j] ^ (v >> 1); + if (v & 1) r->s[i] ^= LZO_UINT64_C(0xb5026f5aa96619e9); - } while (++i != 312); + } + while (++i != 312); } + { unsigned i = r->n++; v = r->s[i]; } + v ^= (v & LZO_UINT64_C(0xaaaaaaaaa0000000)) >> 29; v ^= (v & LZO_UINT64_C(0x38eb3ffff6d3)) << 17; v ^= (v & LZO_UINT64_C(0x7ffbf77)) << 37; @@ -2274,7 +2343,7 @@ LZOLIB_PUBLIC(lzo_uint64l_t, lzo_randmt64_r64) (lzo_randmt64_p r) # define __LZOLIB_RDTSC_REGS : : "c" (t) : "cc", "memory", "eax", "edx" #endif #endif -LZOLIB_PUBLIC(int, lzo_tsc_read) (lzo_uint32e_t* t) +LZOLIB_PUBLIC(int, lzo_tsc_read)(lzo_uint32e_t* t) { #if (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) __asm__ __volatile__( @@ -2285,7 +2354,8 @@ LZOLIB_PUBLIC(int, lzo_tsc_read) (lzo_uint32e_t* t) return 0; #elif (LZO_ARCH_I386) && (LZO_ASM_SYNTAX_MSC) LZO_UNUSED(t); - __asm { + __asm + { mov ecx, t clc # if (LZO_CC_MSC && (_MSC_VER < 1200)) @@ -2299,7 +2369,8 @@ LZOLIB_PUBLIC(int, lzo_tsc_read) (lzo_uint32e_t* t) } return 0; #else - t[0] = t[1] = 0; return -1; + t[0] = t[1] = 0; + return -1; #endif } #if (LZO_OS_WIN32 && LZO_CC_PELLESC && (__POCC__ >= 290)) @@ -2314,64 +2385,81 @@ LZOLIB_PUBLIC(int, lzo_tsc_read) (lzo_uint32e_t* t) # define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) #endif #if (LZO_OS_OS216) -LZO_EXTERN_C unsigned short __far __pascal DosAllocHuge(unsigned short, unsigned short, unsigned short __far *, unsigned short, unsigned short); +LZO_EXTERN_C unsigned short __far __pascal DosAllocHuge(unsigned short, unsigned short, unsigned short __far*, unsigned short, unsigned short); LZO_EXTERN_C unsigned short __far __pascal DosFreeSeg(unsigned short); #endif #if (LZO_OS_DOS16 || LZO_OS_WIN16) #if !(LZO_CC_AZTECC) -LZOLIB_PUBLIC(void __far*, lzo_dos_alloc) (unsigned long size) +LZOLIB_PUBLIC(void __far*, lzo_dos_alloc)(unsigned long size) { void __far* p = 0; union REGS ri, ro; + if ((long)size <= 0) return p; + size = (size + 15) >> 4; + if (size > 0xffffu) return p; + ri.x.ax = 0x4800; ri.x.bx = (unsigned short) size; int86(0x21, &ri, &ro); + if ((ro.x.cflag & 1) == 0) p = (void __far*) LZO_PTR_MK_FP(ro.x.ax, 0); + return p; } -LZOLIB_PUBLIC(int, lzo_dos_free) (void __far* p) +LZOLIB_PUBLIC(int, lzo_dos_free)(void __far* p) { union REGS ri, ro; struct SREGS rs; + if (!p) return 0; + if (LZO_PTR_FP_OFF(p) != 0) return -1; + segread(&rs); ri.x.ax = 0x4900; rs.es = LZO_PTR_FP_SEG(p); int86x(0x21, &ri, &ro, &rs); + if (ro.x.cflag & 1) return -1; + return 0; } #endif #endif #if (LZO_OS_OS216) -LZOLIB_PUBLIC(void __far*, lzo_dos_alloc) (unsigned long size) +LZOLIB_PUBLIC(void __far*, lzo_dos_alloc)(unsigned long size) { void __far* p = 0; unsigned short sel = 0; + if ((long)size <= 0) return p; + if (DosAllocHuge((unsigned short)(size >> 16), (unsigned short)size, &sel, 0, 0) == 0) p = (void __far*) LZO_PTR_MK_FP(sel, 0); + return p; } -LZOLIB_PUBLIC(int, lzo_dos_free) (void __far* p) +LZOLIB_PUBLIC(int, lzo_dos_free)(void __far* p) { if (!p) return 0; + if (LZO_PTR_FP_OFF(p) != 0) return -1; + if (DosFreeSeg(LZO_PTR_FP_SEG(p)) != 0) return -1; + return 0; } #endif @@ -2382,32 +2470,40 @@ LZOLIB_PUBLIC(int, lzo_dos_free) (void __far* p) #if !defined(LZOLIB_PUBLIC) # define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) #endif -LZOLIB_PUBLIC(void, lzo_getopt_init) (lzo_getopt_p g, - int start_argc, int argc, char** argv) +LZOLIB_PUBLIC(void, lzo_getopt_init)(lzo_getopt_p g, + int start_argc, int argc, char** argv) { memset(g, 0, sizeof(*g)); g->optind = start_argc; - g->argc = argc; g->argv = argv; + g->argc = argc; + g->argv = argv; g->optopt = -1; } -static int __LZOLIB_FUNCNAME(lzo_getopt_rotate) (char** p, int first, int middle, int last) +static int __LZOLIB_FUNCNAME(lzo_getopt_rotate)(char** p, int first, int middle, int last) { int i = middle, n = middle - first; + if (first >= middle || middle >= last) return 0; + for (;;) { - char* t = p[first]; p[first] = p[i]; p[i] = t; + char* t = p[first]; + p[first] = p[i]; + p[i] = t; + if (++first == middle) { if (++i == last) break; + middle = i; } else if (++i == last) i = middle; } + return n; } -static int __LZOLIB_FUNCNAME(lzo_getopt_perror) (lzo_getopt_p g, int ret, const char* f, ...) +static int __LZOLIB_FUNCNAME(lzo_getopt_perror)(lzo_getopt_p g, int ret, const char* f, ...) { if (g->opterr) { @@ -2420,48 +2516,62 @@ static int __LZOLIB_FUNCNAME(lzo_getopt_perror) (lzo_getopt_p g, int ret, const g->opterr(g, f, NULL); #endif } + ++g->errcount; return ret; } -LZOLIB_PUBLIC(int, lzo_getopt) (lzo_getopt_p g, - const char* shortopts, - const lzo_getopt_longopt_p longopts, - int* longind) +LZOLIB_PUBLIC(int, lzo_getopt)(lzo_getopt_p g, + const char* shortopts, + const lzo_getopt_longopt_p longopts, + int* longind) { #define pe __LZOLIB_FUNCNAME(lzo_getopt_perror) int ordering = LZO_GETOPT_PERMUTE; int missing_arg_ret = g->bad_option; char* a; + if (shortopts) { if (*shortopts == '-' || *shortopts == '+') ordering = *shortopts++ == '-' ? LZO_GETOPT_RETURN_IN_ORDER : LZO_GETOPT_REQUIRE_ORDER; + if (*shortopts == ':') missing_arg_ret = *shortopts++; } + g->optarg = NULL; + if (g->optopt == -1) g->optopt = g->bad_option; + if (longind) *longind = -1; + if (g->eof) return -1; + if (g->shortpos) goto lzo_label_next_shortopt; + g->optind -= __LZOLIB_FUNCNAME(lzo_getopt_rotate)(g->argv, g->pending_rotate_first, g->pending_rotate_middle, g->optind); g->pending_rotate_first = g->pending_rotate_middle = g->optind; + if (ordering == LZO_GETOPT_PERMUTE) { while (g->optind < g->argc && !(g->argv[g->optind][0] == '-' && g->argv[g->optind][1])) ++g->optind; + g->pending_rotate_middle = g->optind; } + if (g->optind >= g->argc) { g->optind = g->pending_rotate_first; goto lzo_label_eof; } + a = g->argv[g->optind]; + if (a[0] == '-' && a[1] == '-') { size_t l = 0; @@ -2470,74 +2580,101 @@ LZOLIB_PUBLIC(int, lzo_getopt) (lzo_getopt_p g, const lzo_getopt_longopt_p o2 = NULL; int need_exact = 0; ++g->optind; + if (!a[2]) goto lzo_label_eof; - for (a += 2; a[l] && a[l] != '=' && a[l] != '#'; ) + + for (a += 2; a[l] && a[l] != '=' && a[l] != '#';) ++l; + for (o = longopts; l && o && o->name; ++o) { if (strncmp(a, o->name, l) != 0) continue; + if (!o->name[l]) goto lzo_label_found_o; + need_exact |= o->has_arg & LZO_GETOPT_EXACT_ARG; + if (o1) o2 = o; else o1 = o; } + if (!o1 || need_exact) return pe(g, g->bad_option, "unrecognized option '--%s'", a); + if (o2) return pe(g, g->bad_option, "option '--%s' is ambiguous (could be '--%s' or '--%s')", a, o1->name, o2->name); + o = o1; - lzo_label_found_o: +lzo_label_found_o: a += l; + switch (o->has_arg & 0x2f) { - case LZO_GETOPT_OPTIONAL_ARG: - if (a[0]) - g->optarg = a + 1; - break; - case LZO_GETOPT_REQUIRED_ARG: - if (a[0]) - g->optarg = a + 1; - else if (g->optind < g->argc) - g->optarg = g->argv[g->optind++]; - if (!g->optarg) - return pe(g, missing_arg_ret, "option '--%s' requires an argument", o->name); - break; - case LZO_GETOPT_REQUIRED_ARG | 0x20: - if (a[0] && a[1]) - g->optarg = a + 1; - if (!g->optarg) - return pe(g, missing_arg_ret, "option '--%s=' requires an argument", o->name); - break; - default: - if (a[0]) - return pe(g, g->bad_option, "option '--%s' doesn't allow an argument", o->name); - break; + case LZO_GETOPT_OPTIONAL_ARG: + if (a[0]) + g->optarg = a + 1; + + break; + + case LZO_GETOPT_REQUIRED_ARG: + if (a[0]) + g->optarg = a + 1; + else if (g->optind < g->argc) + g->optarg = g->argv[g->optind++]; + + if (!g->optarg) + return pe(g, missing_arg_ret, "option '--%s' requires an argument", o->name); + + break; + + case LZO_GETOPT_REQUIRED_ARG | 0x20: + if (a[0] && a[1]) + g->optarg = a + 1; + + if (!g->optarg) + return pe(g, missing_arg_ret, "option '--%s=' requires an argument", o->name); + + break; + + default: + if (a[0]) + return pe(g, g->bad_option, "option '--%s' doesn't allow an argument", o->name); + + break; } + if (longind) - *longind = (int) (o - longopts); + *longind = (int)(o - longopts); + if (o->flag) { *o->flag = o->val; return 0; } + return o->val; } + if (a[0] == '-' && a[1]) { unsigned char c; const char* s; - lzo_label_next_shortopt: +lzo_label_next_shortopt: a = g->argv[g->optind] + ++g->shortpos; - c = (unsigned char) *a++; s = NULL; + c = (unsigned char) * a++; + s = NULL; + if (c != ':' && shortopts) s = strchr(shortopts, c); + if (!s || s[1] != ':') { if (!a[0]) ++g->optind, g->shortpos = 0; + if (!s) { g->optopt = c; @@ -2547,6 +2684,7 @@ LZOLIB_PUBLIC(int, lzo_getopt) (lzo_getopt_p g, else { ++g->optind, g->shortpos = 0; + if (a[0]) g->optarg = a; else if (s[2] != ':') @@ -2560,14 +2698,17 @@ LZOLIB_PUBLIC(int, lzo_getopt) (lzo_getopt_p g, } } } + return c; } + if (ordering == LZO_GETOPT_RETURN_IN_ORDER) { ++g->optind; g->optarg = a; return 1; } + lzo_label_eof: g->optind -= __LZOLIB_FUNCNAME(lzo_getopt_rotate)(g->argv, g->pending_rotate_first, g->pending_rotate_middle, g->optind); g->pending_rotate_first = g->pending_rotate_middle = g->optind; @@ -2599,7 +2740,7 @@ lzo_label_eof: #if 0 && (LZO_OS_OS216) #include #else -LZO_EXTERN_C unsigned short __far __pascal DosAllocHuge(unsigned short, unsigned short, unsigned short __far *, unsigned short, unsigned short); +LZO_EXTERN_C unsigned short __far __pascal DosAllocHuge(unsigned short, unsigned short, unsigned short __far*, unsigned short, unsigned short); LZO_EXTERN_C unsigned short __far __pascal DosFreeSeg(unsigned short); #endif #endif @@ -2615,73 +2756,97 @@ LZO_EXTERN_C void __far* __far __pascal GlobalLock(const void __near*); LZO_EXTERN_C int __far __pascal GlobalUnlock(const void __near*); #endif #endif -LZOLIB_PUBLIC(lzo_hvoid_p, lzo_halloc) (lzo_hsize_t size) +LZOLIB_PUBLIC(lzo_hvoid_p, lzo_halloc)(lzo_hsize_t size) { lzo_hvoid_p p = LZO_STATIC_CAST(lzo_hvoid_p, 0); + if (!(size > 0)) return p; + #if 0 && defined(__palmos__) p = MemPtrNew(size); #elif !(LZO_HAVE_MM_HUGE_PTR) + if (size < LZO_STATIC_CAST(size_t, -1)) p = malloc(LZO_STATIC_CAST(size_t, size)); + #else + if (LZO_STATIC_CAST(long, size) <= 0) return p; -{ + + { #if (__LZOLIB_HALLOC_USE_DAH) - unsigned short sel = 0; - if (DosAllocHuge((unsigned short)(size >> 16), (unsigned short)size, &sel, 0, 0) == 0) - p = (lzo_hvoid_p) LZO_PTR_MK_FP(sel, 0); + unsigned short sel = 0; + + if (DosAllocHuge((unsigned short)(size >> 16), (unsigned short)size, &sel, 0, 0) == 0) + p = (lzo_hvoid_p) LZO_PTR_MK_FP(sel, 0); + #elif (__LZOLIB_HALLOC_USE_GA) - const void __near* h = GlobalAlloc(2, size); - if (h) { - p = GlobalLock(h); - if (p && LZO_PTR_FP_OFF(p) != 0) { - GlobalUnlock(h); - p = 0; + const void __near* h = GlobalAlloc(2, size); + + if (h) + { + p = GlobalLock(h); + + if (p && LZO_PTR_FP_OFF(p) != 0) + { + GlobalUnlock(h); + p = 0; + } + + if (!p) + GlobalFree(h); } - if (!p) - GlobalFree(h); - } + #elif (LZO_CC_MSC && (_MSC_VER >= 700)) - p = _halloc(size, 1); + p = _halloc(size, 1); #elif (LZO_CC_MSC || LZO_CC_WATCOMC) - p = halloc(size, 1); + p = halloc(size, 1); #elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC) - p = farmalloc(size); + p = farmalloc(size); #elif (LZO_CC_BORLANDC || LZO_CC_TURBOC) - p = farmalloc(size); + p = farmalloc(size); #elif (LZO_CC_AZTECC) - p = lmalloc(size); + p = lmalloc(size); #else - if (size < LZO_STATIC_CAST(size_t, -1)) - p = malloc((size_t) size); + + if (size < LZO_STATIC_CAST(size_t, -1)) + p = malloc((size_t) size); + #endif -} + } #endif return p; } -LZOLIB_PUBLIC(void, lzo_hfree) (lzo_hvoid_p p) +LZOLIB_PUBLIC(void, lzo_hfree)(lzo_hvoid_p p) { if (!p) return; + #if 0 && defined(__palmos__) MemPtrFree(p); #elif !(LZO_HAVE_MM_HUGE_PTR) free(p); #else #if (__LZOLIB_HALLOC_USE_DAH) + if (LZO_PTR_FP_OFF(p) == 0) DosFreeSeg((unsigned short) LZO_PTR_FP_SEG(p)); + #elif (__LZOLIB_HALLOC_USE_GA) - if (LZO_PTR_FP_OFF(p) == 0) { - const void __near* h = (const void __near*) (unsigned) GlobalHandle(LZO_PTR_FP_SEG(p)); - if (h) { + + if (LZO_PTR_FP_OFF(p) == 0) + { + const void __near* h = (const void __near*)(unsigned) GlobalHandle(LZO_PTR_FP_SEG(p)); + + if (h) + { GlobalUnlock(h); GlobalFree(h); } } + #elif (LZO_CC_MSC && (_MSC_VER >= 700)) _hfree(p); #elif (LZO_CC_MSC || LZO_CC_WATCOMC) @@ -2704,38 +2869,50 @@ LZOLIB_PUBLIC(void, lzo_hfree) (lzo_hvoid_p p) #if !defined(LZOLIB_PUBLIC) # define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) #endif -LZOLIB_PUBLIC(lzo_hsize_t, lzo_hfread) (void* vfp, lzo_hvoid_p buf, lzo_hsize_t size) +LZOLIB_PUBLIC(lzo_hsize_t, lzo_hfread)(void* vfp, lzo_hvoid_p buf, lzo_hsize_t size) { - FILE* fp = LZO_STATIC_CAST(FILE *, vfp); + FILE* fp = LZO_STATIC_CAST(FILE*, vfp); #if (LZO_HAVE_MM_HUGE_PTR) #if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM) #define __LZOLIB_REQUIRE_HMEMCPY_CH 1 unsigned char tmp[512]; lzo_hsize_t l = 0; + while (l < size) { - size_t n = size - l > sizeof(tmp) ? sizeof(tmp) : (size_t) (size - l); + size_t n = size - l > sizeof(tmp) ? sizeof(tmp) : (size_t)(size - l); n = fread(tmp, 1, n, fp); + if (n == 0) break; + __LZOLIB_FUNCNAME(lzo_hmemcpy)((lzo_hbyte_p)buf + l, tmp, (lzo_hsize_t)n); l += n; } + return l; #elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE) lzo_hbyte_p b = (lzo_hbyte_p) buf; lzo_hsize_t l = 0; + while (l < size) { size_t n; - n = LZO_PTR_FP_OFF(b); n = (n <= 1) ? 0x8000u : (0u - n); + n = LZO_PTR_FP_OFF(b); + n = (n <= 1) ? 0x8000u : (0u - n); + if ((lzo_hsize_t) n > size - l) - n = (size_t) (size - l); + n = (size_t)(size - l); + n = fread((void __far*)b, 1, n, fp); + if (n == 0) break; - b += n; l += n; + + b += n; + l += n; } + return l; #else # error "unknown memory model" @@ -2744,38 +2921,50 @@ LZOLIB_PUBLIC(lzo_hsize_t, lzo_hfread) (void* vfp, lzo_hvoid_p buf, lzo_hsize_t return fread(buf, 1, size, fp); #endif } -LZOLIB_PUBLIC(lzo_hsize_t, lzo_hfwrite) (void* vfp, const lzo_hvoid_p buf, lzo_hsize_t size) +LZOLIB_PUBLIC(lzo_hsize_t, lzo_hfwrite)(void* vfp, const lzo_hvoid_p buf, lzo_hsize_t size) { - FILE* fp = LZO_STATIC_CAST(FILE *, vfp); + FILE* fp = LZO_STATIC_CAST(FILE*, vfp); #if (LZO_HAVE_MM_HUGE_PTR) #if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM) #define __LZOLIB_REQUIRE_HMEMCPY_CH 1 unsigned char tmp[512]; lzo_hsize_t l = 0; + while (l < size) { - size_t n = size - l > sizeof(tmp) ? sizeof(tmp) : (size_t) (size - l); + size_t n = size - l > sizeof(tmp) ? sizeof(tmp) : (size_t)(size - l); __LZOLIB_FUNCNAME(lzo_hmemcpy)(tmp, (const lzo_hbyte_p)buf + l, (lzo_hsize_t)n); n = fwrite(tmp, 1, n, fp); + if (n == 0) break; + l += n; } + return l; #elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE) const lzo_hbyte_p b = (const lzo_hbyte_p) buf; lzo_hsize_t l = 0; + while (l < size) { size_t n; - n = LZO_PTR_FP_OFF(b); n = (n <= 1) ? 0x8000u : (0u - n); + n = LZO_PTR_FP_OFF(b); + n = (n <= 1) ? 0x8000u : (0u - n); + if ((lzo_hsize_t) n > size - l) - n = (size_t) (size - l); + n = (size_t)(size - l); + n = fwrite((void __far*)b, 1, n, fp); + if (n == 0) break; - b += n; l += n; + + b += n; + l += n; } + return l; #else # error "unknown memory model" @@ -2791,71 +2980,103 @@ LZOLIB_PUBLIC(lzo_hsize_t, lzo_hfwrite) (void* vfp, const lzo_hvoid_p buf, lzo_h #if !defined(LZOLIB_PUBLIC) # define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f) #endif -LZOLIB_PUBLIC(long, lzo_safe_hread) (int fd, lzo_hvoid_p buf, long size) +LZOLIB_PUBLIC(long, lzo_safe_hread)(int fd, lzo_hvoid_p buf, long size) { lzo_hbyte_p b = (lzo_hbyte_p) buf; long l = 0; int saved_errno; saved_errno = errno; + while (l < size) { long n = size - l; #if (LZO_HAVE_MM_HUGE_PTR) # define __LZOLIB_REQUIRE_HREAD_CH 1 - errno = 0; n = lzo_hread(fd, b, n); + errno = 0; + n = lzo_hread(fd, b, n); #elif (LZO_OS_DOS32) && defined(__DJGPP__) - errno = 0; n = _read(fd, b, n); + errno = 0; + n = _read(fd, b, n); #else - errno = 0; n = read(fd, b, n); + errno = 0; + n = read(fd, b, n); #endif + if (n == 0) break; - if (n < 0) { + + if (n < 0) + { #if defined(EAGAIN) + if (errno == (EAGAIN)) continue; + #endif #if defined(EINTR) + if (errno == (EINTR)) continue; + #endif + if (errno == 0) errno = 1; + return l; } - b += n; l += n; + + b += n; + l += n; } + errno = saved_errno; return l; } -LZOLIB_PUBLIC(long, lzo_safe_hwrite) (int fd, const lzo_hvoid_p buf, long size) +LZOLIB_PUBLIC(long, lzo_safe_hwrite)(int fd, const lzo_hvoid_p buf, long size) { const lzo_hbyte_p b = (const lzo_hbyte_p) buf; long l = 0; int saved_errno; saved_errno = errno; + while (l < size) { long n = size - l; #if (LZO_HAVE_MM_HUGE_PTR) # define __LZOLIB_REQUIRE_HREAD_CH 1 - errno = 0; n = lzo_hwrite(fd, b, n); + errno = 0; + n = lzo_hwrite(fd, b, n); #elif (LZO_OS_DOS32) && defined(__DJGPP__) - errno = 0; n = _write(fd, b, n); + errno = 0; + n = _write(fd, b, n); #else - errno = 0; n = write(fd, b, n); + errno = 0; + n = write(fd, b, n); #endif + if (n == 0) break; - if (n < 0) { + + if (n < 0) + { #if defined(EAGAIN) + if (errno == (EAGAIN)) continue; + #endif #if defined(EINTR) + if (errno == (EINTR)) continue; + #endif + if (errno == 0) errno = 1; + return l; } - b += n; l += n; + + b += n; + l += n; } + errno = saved_errno; return l; } @@ -2870,10 +3091,10 @@ LZOLIB_PUBLIC(long, lzo_safe_hwrite) (int fd, const lzo_hvoid_p buf, long size) #ifndef lzo_pclock_syscall_clock_gettime #define lzo_pclock_syscall_clock_gettime lzo_pclock_syscall_clock_gettime #endif -__lzo_static_noinline long lzo_pclock_syscall_clock_gettime(long clockid, struct timespec *ts) +__lzo_static_noinline long lzo_pclock_syscall_clock_gettime(long clockid, struct timespec* ts) { unsigned long r = 228; - __asm__ __volatile__("syscall\n" : "=a" (r) : "0" (r), "D" (clockid), "S" (ts) __LZO_ASM_CLOBBER_LIST_CC_MEMORY); + __asm__ __volatile__("syscall\n" : "=a"(r) : "0"(r), "D"(clockid), "S"(ts) __LZO_ASM_CLOBBER_LIST_CC_MEMORY); return LZO_ICAST(long, r); } #endif @@ -2881,10 +3102,10 @@ __lzo_static_noinline long lzo_pclock_syscall_clock_gettime(long clockid, struct #ifndef lzo_pclock_syscall_clock_gettime #define lzo_pclock_syscall_clock_gettime lzo_pclock_syscall_clock_gettime #endif -__lzo_static_noinline long lzo_pclock_syscall_clock_gettime(long clockid, struct timespec *ts) +__lzo_static_noinline long lzo_pclock_syscall_clock_gettime(long clockid, struct timespec* ts) { unsigned long r = 265; - __asm__ __volatile__("pushl %%ebx\n pushl %%edx\n popl %%ebx\n int $0x80\n popl %%ebx\n" : "=a" (r) : "0" (r), "d" (clockid), "c" (ts) __LZO_ASM_CLOBBER_LIST_CC_MEMORY); + __asm__ __volatile__("pushl %%ebx\n pushl %%edx\n popl %%ebx\n int $0x80\n popl %%ebx\n" : "=a"(r) : "0"(r), "d"(clockid), "c"(ts) __LZO_ASM_CLOBBER_LIST_CC_MEMORY); return LZO_ICAST(long, r); } #endif @@ -2894,12 +3115,15 @@ __lzo_static_noinline long lzo_pclock_syscall_clock_gettime(long clockid, struct #endif static int lzo_pclock_read_clock_gettime_r_syscall(lzo_pclock_handle_p h, lzo_pclock_p c) { - struct timespec ts; + struct timespec ts; + if (lzo_pclock_syscall_clock_gettime(0, &ts) != 0) return -1; + c->tv_sec = ts.tv_sec; c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ts.tv_nsec); - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif #if (HAVE_GETTIMEOFDAY) @@ -2909,8 +3133,10 @@ static int lzo_pclock_read_clock_gettime_r_syscall(lzo_pclock_handle_p h, lzo_pc static int lzo_pclock_read_gettimeofday(lzo_pclock_handle_p h, lzo_pclock_p c) { struct timeval tv; + if (gettimeofday(&tv, NULL) != 0) return -1; + #if defined(lzo_int64l_t) c->tv_sec = tv.tv_sec; #else @@ -2918,7 +3144,8 @@ static int lzo_pclock_read_gettimeofday(lzo_pclock_handle_p h, lzo_pclock_p c) c->tv_sec_low = tv.tv_sec; #endif c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, (tv.tv_usec * 1000u)); - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif #if defined(CLOCKS_PER_SEC) && !(LZO_CFG_NO_DOUBLE) @@ -2944,7 +3171,8 @@ static int lzo_pclock_read_clock(lzo_pclock_handle_p h, lzo_pclock_p c) c->tv_sec_low = LZO_STATIC_CAST(lzo_uint32l_t, (secs + 0.5)); c->tv_nsec = 0; #endif - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif #if 1 && defined(lzo_pclock_syscall_clock_gettime) @@ -2953,12 +3181,15 @@ static int lzo_pclock_read_clock(lzo_pclock_handle_p h, lzo_pclock_p c) #endif static int lzo_pclock_read_clock_gettime_m_syscall(lzo_pclock_handle_p h, lzo_pclock_p c) { - struct timespec ts; + struct timespec ts; + if (lzo_pclock_syscall_clock_gettime(1, &ts) != 0) return -1; + c->tv_sec = ts.tv_sec; c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ts.tv_nsec); - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif #if (LZO_OS_DOS32 && LZO_CC_GNUC) && defined(__DJGPP__) && defined(UCLOCKS_PER_SEC) && !(LZO_CFG_NO_DOUBLE) @@ -2975,7 +3206,8 @@ static int lzo_pclock_read_uclock(lzo_pclock_handle_p h, lzo_pclock_p c) nsecs = LZO_STATIC_CAST(lzo_uint64l_t, (secs * 1000000000.0)); c->tv_sec = nsecs / 1000000000ul; c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, (nsecs % 1000000000ul)); - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif #if 1 && (HAVE_CLOCK_GETTIME) && defined(CLOCK_PROCESS_CPUTIME_ID) && defined(lzo_int64l_t) @@ -2985,11 +3217,14 @@ static int lzo_pclock_read_uclock(lzo_pclock_handle_p h, lzo_pclock_p c) static int lzo_pclock_read_clock_gettime_p_libc(lzo_pclock_handle_p h, lzo_pclock_p c) { struct timespec ts; + if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) != 0) return -1; + c->tv_sec = ts.tv_sec; c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ts.tv_nsec); - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif #if 1 && defined(lzo_pclock_syscall_clock_gettime) @@ -2998,12 +3233,15 @@ static int lzo_pclock_read_clock_gettime_p_libc(lzo_pclock_handle_p h, lzo_pcloc #endif static int lzo_pclock_read_clock_gettime_p_syscall(lzo_pclock_handle_p h, lzo_pclock_p c) { - struct timespec ts; + struct timespec ts; + if (lzo_pclock_syscall_clock_gettime(2, &ts) != 0) return -1; + c->tv_sec = ts.tv_sec; c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ts.tv_nsec); - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif #if (LZO_OS_CYGWIN || LZO_OS_WIN32 || LZO_OS_WIN64) && (LZO_HAVE_WINDOWS_H) && defined(lzo_int64l_t) @@ -3014,17 +3252,22 @@ static int lzo_pclock_read_getprocesstimes(lzo_pclock_handle_p h, lzo_pclock_p c { FILETIME ct, et, kt, ut; lzo_uint64l_t ticks; + if (GetProcessTimes(GetCurrentProcess(), &ct, &et, &kt, &ut) == 0) return -1; + ticks = (LZO_STATIC_CAST(lzo_uint64l_t, ut.dwHighDateTime) << 32) | ut.dwLowDateTime; + if __lzo_unlikely(h->ticks_base == 0) h->ticks_base = ticks; else ticks -= h->ticks_base; + c->tv_sec = LZO_STATIC_CAST(lzo_int64l_t, (ticks / 10000000ul)); ticks = (ticks % 10000000ul) * 100u; c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ticks); - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif #if (HAVE_GETRUSAGE) && defined(RUSAGE_SELF) @@ -3034,8 +3277,10 @@ static int lzo_pclock_read_getprocesstimes(lzo_pclock_handle_p h, lzo_pclock_p c static int lzo_pclock_read_getrusage(lzo_pclock_handle_p h, lzo_pclock_p c) { struct rusage ru; + if (getrusage(RUSAGE_SELF, &ru) != 0) return -1; + #if defined(lzo_int64l_t) c->tv_sec = ru.ru_utime.tv_sec; #else @@ -3043,7 +3288,8 @@ static int lzo_pclock_read_getrusage(lzo_pclock_handle_p h, lzo_pclock_p c) c->tv_sec_low = ru.ru_utime.tv_sec; #endif c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, (ru.ru_utime.tv_usec * 1000u)); - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif #if 1 && (HAVE_CLOCK_GETTIME) && defined(CLOCK_THREAD_CPUTIME_ID) && defined(lzo_int64l_t) @@ -3053,11 +3299,14 @@ static int lzo_pclock_read_getrusage(lzo_pclock_handle_p h, lzo_pclock_p c) static int lzo_pclock_read_clock_gettime_t_libc(lzo_pclock_handle_p h, lzo_pclock_p c) { struct timespec ts; + if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) != 0) return -1; + c->tv_sec = ts.tv_sec; c->tv_nsec = (lzo_uint32l_t) ts.tv_nsec; - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif #if 1 && defined(lzo_pclock_syscall_clock_gettime) @@ -3066,12 +3315,15 @@ static int lzo_pclock_read_clock_gettime_t_libc(lzo_pclock_handle_p h, lzo_pcloc #endif static int lzo_pclock_read_clock_gettime_t_syscall(lzo_pclock_handle_p h, lzo_pclock_p c) { - struct timespec ts; + struct timespec ts; + if (lzo_pclock_syscall_clock_gettime(3, &ts) != 0) return -1; + c->tv_sec = ts.tv_sec; c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ts.tv_nsec); - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif #if (LZO_OS_CYGWIN || LZO_OS_WIN32 || LZO_OS_WIN64) && (LZO_HAVE_WINDOWS_H) && defined(lzo_int64l_t) @@ -3082,20 +3334,25 @@ static int lzo_pclock_read_getthreadtimes(lzo_pclock_handle_p h, lzo_pclock_p c) { FILETIME ct, et, kt, ut; lzo_uint64l_t ticks; + if (GetThreadTimes(GetCurrentThread(), &ct, &et, &kt, &ut) == 0) return -1; + ticks = (LZO_STATIC_CAST(lzo_uint64l_t, ut.dwHighDateTime) << 32) | ut.dwLowDateTime; + if __lzo_unlikely(h->ticks_base == 0) h->ticks_base = ticks; else ticks -= h->ticks_base; + c->tv_sec = LZO_STATIC_CAST(lzo_int64l_t, (ticks / 10000000ul)); ticks = (ticks % 10000000ul) * 100u; c->tv_nsec = LZO_STATIC_CAST(lzo_uint32l_t, ticks); - LZO_UNUSED(h); return 0; + LZO_UNUSED(h); + return 0; } #endif -LZOLIB_PUBLIC(int, lzo_pclock_open) (lzo_pclock_handle_p h, int mode) +LZOLIB_PUBLIC(int, lzo_pclock_open)(lzo_pclock_handle_p h, int mode) { lzo_pclock_t c; int i; @@ -3107,126 +3364,173 @@ LZOLIB_PUBLIC(int, lzo_pclock_open) (lzo_pclock_handle_p h, int mode) #if defined(lzo_int64l_t) h->ticks_base = 0; #endif + switch (mode) { - case LZO_PCLOCK_REALTIME: + case LZO_PCLOCK_REALTIME: # if defined(lzo_pclock_read_clock_gettime_r_syscall) - if (lzo_pclock_read_clock_gettime_r_syscall(h, &c) == 0) { - h->gettime = lzo_pclock_read_clock_gettime_r_syscall; - h->name = "CLOCK_REALTIME/syscall"; - break; - } + if (lzo_pclock_read_clock_gettime_r_syscall(h, &c) == 0) + { + h->gettime = lzo_pclock_read_clock_gettime_r_syscall; + h->name = "CLOCK_REALTIME/syscall"; + break; + } + # endif # if defined(lzo_pclock_read_gettimeofday) - if (lzo_pclock_read_gettimeofday(h, &c) == 0) { - h->gettime = lzo_pclock_read_gettimeofday; - h->name = "gettimeofday"; - break; - } + + if (lzo_pclock_read_gettimeofday(h, &c) == 0) + { + h->gettime = lzo_pclock_read_gettimeofday; + h->name = "gettimeofday"; + break; + } + # endif - break; - case LZO_PCLOCK_MONOTONIC: -# if defined(lzo_pclock_read_clock_gettime_m_syscall) - if (lzo_pclock_read_clock_gettime_m_syscall(h, &c) == 0) { - h->gettime = lzo_pclock_read_clock_gettime_m_syscall; - h->name = "CLOCK_MONOTONIC/syscall"; break; - } + + case LZO_PCLOCK_MONOTONIC: +# if defined(lzo_pclock_read_clock_gettime_m_syscall) + if (lzo_pclock_read_clock_gettime_m_syscall(h, &c) == 0) + { + h->gettime = lzo_pclock_read_clock_gettime_m_syscall; + h->name = "CLOCK_MONOTONIC/syscall"; + break; + } + # endif # if defined(lzo_pclock_read_uclock) - if (lzo_pclock_read_uclock(h, &c) == 0) { - h->gettime = lzo_pclock_read_uclock; - h->name = "uclock"; - break; - } + + if (lzo_pclock_read_uclock(h, &c) == 0) + { + h->gettime = lzo_pclock_read_uclock; + h->name = "uclock"; + break; + } + # endif # if defined(lzo_pclock_read_clock) - if (lzo_pclock_read_clock(h, &c) == 0) { - h->gettime = lzo_pclock_read_clock; - h->name = "clock"; - break; - } + + if (lzo_pclock_read_clock(h, &c) == 0) + { + h->gettime = lzo_pclock_read_clock; + h->name = "clock"; + break; + } + # endif - break; - case LZO_PCLOCK_PROCESS_CPUTIME_ID: -# if defined(lzo_pclock_read_getprocesstimes) - if (lzo_pclock_read_getprocesstimes(h, &c) == 0) { - h->gettime = lzo_pclock_read_getprocesstimes; - h->name = "GetProcessTimes"; break; - } + + case LZO_PCLOCK_PROCESS_CPUTIME_ID: +# if defined(lzo_pclock_read_getprocesstimes) + if (lzo_pclock_read_getprocesstimes(h, &c) == 0) + { + h->gettime = lzo_pclock_read_getprocesstimes; + h->name = "GetProcessTimes"; + break; + } + # endif # if defined(lzo_pclock_read_clock_gettime_p_syscall) - if (lzo_pclock_read_clock_gettime_p_syscall(h, &c) == 0) { - h->gettime = lzo_pclock_read_clock_gettime_p_syscall; - h->name = "CLOCK_PROCESS_CPUTIME_ID/syscall"; - break; - } + + if (lzo_pclock_read_clock_gettime_p_syscall(h, &c) == 0) + { + h->gettime = lzo_pclock_read_clock_gettime_p_syscall; + h->name = "CLOCK_PROCESS_CPUTIME_ID/syscall"; + break; + } + # endif # if defined(lzo_pclock_read_clock_gettime_p_libc) - if (lzo_pclock_read_clock_gettime_p_libc(h, &c) == 0) { - h->gettime = lzo_pclock_read_clock_gettime_p_libc; - h->name = "CLOCK_PROCESS_CPUTIME_ID/libc"; - break; - } + + if (lzo_pclock_read_clock_gettime_p_libc(h, &c) == 0) + { + h->gettime = lzo_pclock_read_clock_gettime_p_libc; + h->name = "CLOCK_PROCESS_CPUTIME_ID/libc"; + break; + } + # endif # if defined(lzo_pclock_read_getrusage) - if (lzo_pclock_read_getrusage(h, &c) == 0) { - h->gettime = lzo_pclock_read_getrusage; - h->name = "getrusage"; - break; - } + + if (lzo_pclock_read_getrusage(h, &c) == 0) + { + h->gettime = lzo_pclock_read_getrusage; + h->name = "getrusage"; + break; + } + # endif - break; - case LZO_PCLOCK_THREAD_CPUTIME_ID: + break; + + case LZO_PCLOCK_THREAD_CPUTIME_ID: # if defined(lzo_pclock_read_getthreadtimes) - if (lzo_pclock_read_getthreadtimes(h, &c) == 0) { - h->gettime = lzo_pclock_read_getthreadtimes; - h->name = "GetThreadTimes"; - } + if (lzo_pclock_read_getthreadtimes(h, &c) == 0) + { + h->gettime = lzo_pclock_read_getthreadtimes; + h->name = "GetThreadTimes"; + } + # endif # if defined(lzo_pclock_read_clock_gettime_t_syscall) - if (lzo_pclock_read_clock_gettime_t_syscall(h, &c) == 0) { - h->gettime = lzo_pclock_read_clock_gettime_t_syscall; - h->name = "CLOCK_THREAD_CPUTIME_ID/syscall"; - break; - } + + if (lzo_pclock_read_clock_gettime_t_syscall(h, &c) == 0) + { + h->gettime = lzo_pclock_read_clock_gettime_t_syscall; + h->name = "CLOCK_THREAD_CPUTIME_ID/syscall"; + break; + } + # endif # if defined(lzo_pclock_read_clock_gettime_t_libc) - if (lzo_pclock_read_clock_gettime_t_libc(h, &c) == 0) { - h->gettime = lzo_pclock_read_clock_gettime_t_libc; - h->name = "CLOCK_THREAD_CPUTIME_ID/libc"; - break; - } + + if (lzo_pclock_read_clock_gettime_t_libc(h, &c) == 0) + { + h->gettime = lzo_pclock_read_clock_gettime_t_libc; + h->name = "CLOCK_THREAD_CPUTIME_ID/libc"; + break; + } + # endif - break; + break; } + if (!h->gettime) return -1; + if (!h->h) h->h = LZO_STATIC_CAST(lzolib_handle_t, 1); + h->mode = mode; h->read_error = 0; + if (!h->name) h->name = "unknown"; - for (i = 0; i < 10; i++) { + + for (i = 0; i < 10; i++) + { __LZOLIB_FUNCNAME(lzo_pclock_read)(h, &c); } + return 0; } -LZOLIB_PUBLIC(int, lzo_pclock_open_default) (lzo_pclock_handle_p h) +LZOLIB_PUBLIC(int, lzo_pclock_open_default)(lzo_pclock_handle_p h) { if (__LZOLIB_FUNCNAME(lzo_pclock_open)(h, LZO_PCLOCK_PROCESS_CPUTIME_ID) == 0) return 0; + if (__LZOLIB_FUNCNAME(lzo_pclock_open)(h, LZO_PCLOCK_MONOTONIC) == 0) return 0; + if (__LZOLIB_FUNCNAME(lzo_pclock_open)(h, LZO_PCLOCK_REALTIME) == 0) return 0; + if (__LZOLIB_FUNCNAME(lzo_pclock_open)(h, LZO_PCLOCK_THREAD_CPUTIME_ID) == 0) return 0; + return -1; } -LZOLIB_PUBLIC(int, lzo_pclock_close) (lzo_pclock_handle_p h) +LZOLIB_PUBLIC(int, lzo_pclock_close)(lzo_pclock_handle_p h) { h->h = LZO_STATIC_CAST(lzolib_handle_t, 0); h->mode = -1; @@ -3234,12 +3538,14 @@ LZOLIB_PUBLIC(int, lzo_pclock_close) (lzo_pclock_handle_p h) h->gettime = LZO_STATIC_CAST(lzo_pclock_gettime_t, 0); return 0; } -LZOLIB_PUBLIC(void, lzo_pclock_read) (lzo_pclock_handle_p h, lzo_pclock_p c) +LZOLIB_PUBLIC(void, lzo_pclock_read)(lzo_pclock_handle_p h, lzo_pclock_p c) { - if (h->gettime) { + if (h->gettime) + { if (h->gettime(h, c) == 0) return; } + h->read_error = 1; #if defined(lzo_int64l_t) c->tv_sec = 0; @@ -3250,37 +3556,45 @@ LZOLIB_PUBLIC(void, lzo_pclock_read) (lzo_pclock_handle_p h, lzo_pclock_p c) c->tv_nsec = 0; } #if !(LZO_CFG_NO_DOUBLE) -LZOLIB_PUBLIC(double, lzo_pclock_get_elapsed) (lzo_pclock_handle_p h, const lzo_pclock_p start, const lzo_pclock_p stop) +LZOLIB_PUBLIC(double, lzo_pclock_get_elapsed)(lzo_pclock_handle_p h, const lzo_pclock_p start, const lzo_pclock_p stop) { if (!h->h) { h->mode = -1; return 0.0; } + { #if 1 && (LZO_ARCH_I386 && LZO_CC_GNUC) && defined(__STRICT_ALIGNMENT__) - float tstop, tstart; - tstop = LZO_STATIC_CAST(float, (stop->tv_sec + stop->tv_nsec / 1000000000.0)); - tstart = LZO_STATIC_CAST(float, (start->tv_sec + start->tv_nsec / 1000000000.0)); + float tstop, tstart; + tstop = LZO_STATIC_CAST(float, (stop->tv_sec + stop->tv_nsec / 1000000000.0)); + tstart = LZO_STATIC_CAST(float, (start->tv_sec + start->tv_nsec / 1000000000.0)); #elif defined(lzo_int64l_t) - double tstop, tstart; + double tstop, tstart; #if 1 && (LZO_CC_INTELC) - { lzo_int64l_t a = stop->tv_sec; lzo_uint32l_t b = stop->tv_nsec; - tstop = a + b / 1000000000.0; } - { lzo_int64l_t a = start->tv_sec; lzo_uint32l_t b = start->tv_nsec; - tstart = a + b / 1000000000.0; } + { + lzo_int64l_t a = stop->tv_sec; + lzo_uint32l_t b = stop->tv_nsec; + tstop = a + b / 1000000000.0; + } + { + lzo_int64l_t a = start->tv_sec; + lzo_uint32l_t b = start->tv_nsec; + tstart = a + b / 1000000000.0; + } #else - tstop = stop->tv_sec + stop->tv_nsec / 1000000000.0; - tstart = start->tv_sec + start->tv_nsec / 1000000000.0; + tstop = stop->tv_sec + stop->tv_nsec / 1000000000.0; + tstart = start->tv_sec + start->tv_nsec / 1000000000.0; #endif #else - double tstop, tstart; - tstop = stop->tv_sec_low + stop->tv_nsec / 1000000000.0; - tstart = start->tv_sec_low + start->tv_nsec / 1000000000.0; + double tstop, tstart; + tstop = stop->tv_sec_low + stop->tv_nsec / 1000000000.0; + tstart = start->tv_sec_low + start->tv_nsec / 1000000000.0; #endif - return tstop - tstart; + return tstop - tstart; } } #endif -LZOLIB_PUBLIC(int, lzo_pclock_flush_cpu_cache) (lzo_pclock_handle_p h, unsigned flags) +LZOLIB_PUBLIC(int, lzo_pclock_flush_cpu_cache)(lzo_pclock_handle_p h, unsigned flags) { - LZO_UNUSED(h); LZO_UNUSED(flags); + LZO_UNUSED(h); + LZO_UNUSED(flags); return -1; } #if defined(__LZOLIB_PCLOCK_NEED_WARN_POP) @@ -3311,18 +3625,20 @@ LZOLIB_PUBLIC(int, lzo_pclock_flush_cpu_cache) (lzo_pclock_handle_p h, unsigned # pragma warn(push) # pragma warn(disable:2007) #endif -LZOLIB_PUBLIC(const char *, lzo_getenv) (const char *s) +LZOLIB_PUBLIC(const char*, lzo_getenv)(const char* s) { #if (HAVE_GETENV) return getenv(s); #else - LZO_UNUSED(s); return LZO_STATIC_CAST(const char *, 0); + LZO_UNUSED(s); + return LZO_STATIC_CAST(const char*, 0); #endif } -LZOLIB_PUBLIC(lzo_intptr_t, lzo_get_osfhandle) (int fd) +LZOLIB_PUBLIC(lzo_intptr_t, lzo_get_osfhandle)(int fd) { if (fd < 0) return -1; + #if (LZO_OS_CYGWIN) return get_osfhandle(fd); #elif (LZO_OS_EMX && defined(__RSXNT__)) @@ -3343,51 +3659,71 @@ LZOLIB_PUBLIC(lzo_intptr_t, lzo_get_osfhandle) (int fd) return fd; #endif } -LZOLIB_PUBLIC(int, lzo_set_binmode) (int fd, int binary) +LZOLIB_PUBLIC(int, lzo_set_binmode)(int fd, int binary) { #if (LZO_ARCH_M68K && LZO_OS_TOS && LZO_CC_GNUC) && defined(__MINT__) - FILE* fp; int old_binary; + FILE* fp; + int old_binary; + if (fd == STDIN_FILENO) fp = stdin; else if (fd == STDOUT_FILENO) fp = stdout; else if (fd == STDERR_FILENO) fp = stderr; else return -1; + old_binary = fp->__mode.__binary; __set_binmode(fp, binary ? 1 : 0); return old_binary ? 1 : 0; #elif (LZO_ARCH_M68K && LZO_OS_TOS) - LZO_UNUSED(fd); LZO_UNUSED(binary); + LZO_UNUSED(fd); + LZO_UNUSED(binary); return -1; #elif (LZO_OS_DOS16 && (LZO_CC_AZTECC || LZO_CC_PACIFICC)) - LZO_UNUSED(fd); LZO_UNUSED(binary); + LZO_UNUSED(fd); + LZO_UNUSED(binary); return -1; #elif (LZO_OS_DOS32 && LZO_CC_GNUC) && defined(__DJGPP__) - int r; unsigned old_flags = __djgpp_hwint_flags; + int r; + unsigned old_flags = __djgpp_hwint_flags; LZO_COMPILE_TIME_ASSERT(O_BINARY > 0) LZO_COMPILE_TIME_ASSERT(O_TEXT > 0) + if (fd < 0) return -1; + r = setmode(fd, binary ? O_BINARY : O_TEXT); + if ((old_flags & 1u) != (__djgpp_hwint_flags & 1u)) __djgpp_set_ctrl_c(!(old_flags & 1)); + if (r == -1) return -1; + return (r & O_TEXT) ? 0 : 1; #elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__) + if (fd < 0) return -1; + LZO_UNUSED(binary); return 1; #elif (LZO_OS_DOS32 && LZO_CC_HIGHC) - FILE* fp; int r; + FILE* fp; + int r; + if (fd == fileno(stdin)) fp = stdin; else if (fd == fileno(stdout)) fp = stdout; else if (fd == fileno(stderr)) fp = stderr; else return -1; + r = _setmode(fp, binary ? _BINARY : _TEXT); + if (r == -1) return -1; + return (r & _BINARY) ? 1 : 0; #elif (LZO_OS_WIN32 && LZO_CC_MWERKS) && defined(__MSL__) - LZO_UNUSED(fd); LZO_UNUSED(binary); + LZO_UNUSED(fd); + LZO_UNUSED(binary); return -1; #elif (LZO_OS_CYGWIN && (LZO_CC_GNUC < 0x025a00ul)) - LZO_UNUSED(fd); LZO_UNUSED(binary); + LZO_UNUSED(fd); + LZO_UNUSED(binary); return -1; #elif (LZO_OS_CYGWIN || LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_EMX || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64) int r; @@ -3395,25 +3731,34 @@ LZOLIB_PUBLIC(int, lzo_set_binmode) (int fd, int binary) LZO_COMPILE_TIME_ASSERT(O_BINARY > 0) #endif LZO_COMPILE_TIME_ASSERT(O_TEXT > 0) + if (fd < 0) return -1; + r = setmode(fd, binary ? O_BINARY : O_TEXT); + if (r == -1) return -1; + return (r & O_TEXT) ? 0 : 1; #else + if (fd < 0) return -1; + LZO_UNUSED(binary); return 1; #endif } -LZOLIB_PUBLIC(int, lzo_isatty) (int fd) +LZOLIB_PUBLIC(int, lzo_isatty)(int fd) { if (fd < 0) return 0; + #if (LZO_OS_DOS16 && !(LZO_CC_AZTECC)) { union REGS ri, ro; - ri.x.ax = 0x4400; ri.x.bx = fd; + ri.x.ax = 0x4400; + ri.x.bx = fd; int86(0x21, &ri, &ro); + if ((ro.x.cflag & 1) == 0) if ((ro.x.ax & 0x83) != 0x83) return 0; @@ -3421,8 +3766,10 @@ LZOLIB_PUBLIC(int, lzo_isatty) (int fd) #elif (LZO_OS_DOS32 && LZO_CC_WATCOMC) { union REGS ri, ro; - ri.w.ax = 0x4400; ri.w.bx = LZO_STATIC_CAST(unsigned short, fd); + ri.w.ax = 0x4400; + ri.w.bx = LZO_STATIC_CAST(unsigned short, fd); int386(0x21, &ri, &ro); + if ((ro.w.cflag & 1) == 0) if ((ro.w.ax & 0x83) != 0x83) return 0; @@ -3431,9 +3778,11 @@ LZOLIB_PUBLIC(int, lzo_isatty) (int fd) { lzo_intptr_t h = __LZOLIB_FUNCNAME(lzo_get_osfhandle)(fd); LZO_COMPILE_TIME_ASSERT(sizeof(h) == sizeof(HANDLE)) + if (h != -1) { DWORD d = 0; + if (GetConsoleMode(LZO_REINTERPRET_CAST(HANDLE, h), &d) == 0) return 0; } @@ -3445,10 +3794,11 @@ LZOLIB_PUBLIC(int, lzo_isatty) (int fd) return 0; #endif } -LZOLIB_PUBLIC(int, lzo_mkdir) (const char* name, unsigned mode) +LZOLIB_PUBLIC(int, lzo_mkdir)(const char* name, unsigned mode) { #if !(HAVE_MKDIR) - LZO_UNUSED(name); LZO_UNUSED(mode); + LZO_UNUSED(name); + LZO_UNUSED(mode); return -1; #elif (LZO_ARCH_M68K && LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC)) LZO_UNUSED(mode); @@ -3459,7 +3809,7 @@ LZOLIB_PUBLIC(int, lzo_mkdir) (const char* name, unsigned mode) return mkdir(name, mode); #elif ((LZO_OS_DOS16 || LZO_OS_DOS32) && (LZO_CC_HIGHC || LZO_CC_PACIFICC)) LZO_UNUSED(mode); - return mkdir(LZO_UNCONST_CAST(char *, name)); + return mkdir(LZO_UNCONST_CAST(char*, name)); #elif (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64) LZO_UNUSED(mode); return mkdir(name); @@ -3469,56 +3819,62 @@ LZOLIB_PUBLIC(int, lzo_mkdir) (const char* name, unsigned mode) return mkdir(name, mode); #endif } -LZOLIB_PUBLIC(int, lzo_rmdir) (const char* name) +LZOLIB_PUBLIC(int, lzo_rmdir)(const char* name) { #if !(HAVE_RMDIR) LZO_UNUSED(name); return -1; #elif ((LZO_OS_DOS16 || LZO_OS_DOS32) && (LZO_CC_HIGHC || LZO_CC_PACIFICC)) - return rmdir(LZO_UNCONST_CAST(char *, name)); + return rmdir(LZO_UNCONST_CAST(char*, name)); #else return rmdir(name); #endif } #if defined(lzo_int32e_t) -LZOLIB_PUBLIC(lzo_int32e_t, lzo_muldiv32s) (lzo_int32e_t a, lzo_int32e_t b, lzo_int32e_t x) +LZOLIB_PUBLIC(lzo_int32e_t, lzo_muldiv32s)(lzo_int32e_t a, lzo_int32e_t b, lzo_int32e_t x) { lzo_int32e_t r = 0; + if __lzo_likely(x != 0) { #if defined(lzo_int64l_t) lzo_int64l_t rr = (LZO_ICONV(lzo_int64l_t, a) * b) / x; r = LZO_ITRUNC(lzo_int32e_t, rr); #else - LZO_UNUSED(a); LZO_UNUSED(b); + LZO_UNUSED(a); + LZO_UNUSED(b); #endif } + return r; } -LZOLIB_PUBLIC(lzo_uint32e_t, lzo_muldiv32u) (lzo_uint32e_t a, lzo_uint32e_t b, lzo_uint32e_t x) +LZOLIB_PUBLIC(lzo_uint32e_t, lzo_muldiv32u)(lzo_uint32e_t a, lzo_uint32e_t b, lzo_uint32e_t x) { lzo_uint32e_t r = 0; + if __lzo_likely(x != 0) { #if defined(lzo_int64l_t) lzo_uint64l_t rr = (LZO_ICONV(lzo_uint64l_t, a) * b) / x; r = LZO_ITRUNC(lzo_uint32e_t, rr); #else - LZO_UNUSED(a); LZO_UNUSED(b); + LZO_UNUSED(a); + LZO_UNUSED(b); #endif } + return r; } #endif #if 0 -LZOLIB_PUBLIC_NOINLINE(int, lzo_syscall_clock_gettime) (int c) +LZOLIB_PUBLIC_NOINLINE(int, lzo_syscall_clock_gettime)(int c) { } #endif #if (LZO_OS_WIN16) LZO_EXTERN_C void __far __pascal DebugBreak(void); #endif -LZOLIB_PUBLIC_NOINLINE(void, lzo_debug_break) (void) +LZOLIB_PUBLIC_NOINLINE(void, lzo_debug_break)(void) { #if (LZO_OS_WIN16) DebugBreak(); @@ -3533,13 +3889,13 @@ LZOLIB_PUBLIC_NOINLINE(void, lzo_debug_break) (void) DebugBreak(); #else volatile lzo_intptr_t a = -1; - * LZO_STATIC_CAST(volatile unsigned long *, LZO_REINTERPRET_CAST(volatile void *, a)) = ~0ul; + * LZO_STATIC_CAST(volatile unsigned long*, LZO_REINTERPRET_CAST(volatile void*, a)) = ~0ul; #endif } -LZOLIB_PUBLIC_NOINLINE(void, lzo_debug_nop) (void) +LZOLIB_PUBLIC_NOINLINE(void, lzo_debug_nop)(void) { } -LZOLIB_PUBLIC_NOINLINE(int, lzo_debug_align_check_query) (void) +LZOLIB_PUBLIC_NOINLINE(int, lzo_debug_align_check_query)(void) { #if (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) # if (LZO_ARCH_AMD64) @@ -3547,77 +3903,108 @@ LZOLIB_PUBLIC_NOINLINE(int, lzo_debug_align_check_query) (void) # else size_t r = 0; # endif - __asm__ __volatile__("pushf\n pop %0\n" : "=a" (r) : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); + __asm__ __volatile__("pushf\n pop %0\n" : "=a"(r) : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); return LZO_ICONV(int, (r >> 18) & 1); #elif (LZO_ARCH_I386) && (LZO_ASM_SYNTAX_MSC) unsigned long r; - __asm { + __asm + { pushf pop eax - mov r,eax + mov r, eax } return LZO_ICONV(int, (r >> 18) & 1); #else return -1; #endif } -LZOLIB_PUBLIC_NOINLINE(int, lzo_debug_align_check_enable) (int v) +LZOLIB_PUBLIC_NOINLINE(int, lzo_debug_align_check_enable)(int v) { #if (LZO_ARCH_AMD64) && (LZO_ASM_SYNTAX_GNUC) - if (v) { + + if (v) + { __asm__ __volatile__("pushf\n orl $262144,(%%rsp)\n popf\n" : : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); - } else { + } + else + { __asm__ __volatile__("pushf\n andl $-262145,(%%rsp)\n popf\n" : : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); } + return 0; #elif (LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) - if (v) { + + if (v) + { __asm__ __volatile__("pushf\n orl $262144,(%%esp)\n popf\n" : : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); - } else { + } + else + { __asm__ __volatile__("pushf\n andl $-262145,(%%esp)\n popf\n" : : __LZO_ASM_CLOBBER_LIST_CC_MEMORY); } + return 0; #elif (LZO_ARCH_I386) && (LZO_ASM_SYNTAX_MSC) - if (v) { __asm { - pushf - or dword ptr [esp],262144 - popf - }} else { __asm { - pushf - and dword ptr [esp],-262145 - popf - }} + + if (v) + { + __asm + { + pushf + or dword ptr [esp], 262144 + popf + } + } + else + { + __asm + { + pushf + and dword ptr [esp], -262145 + popf + } + } + return 0; #else - LZO_UNUSED(v); return -1; + LZO_UNUSED(v); + return -1; #endif } -LZOLIB_PUBLIC_NOINLINE(unsigned, lzo_debug_running_on_qemu) (void) +LZOLIB_PUBLIC_NOINLINE(unsigned, lzo_debug_running_on_qemu)(void) { unsigned r = 0; #if (LZO_OS_POSIX_LINUX || LZO_OS_WIN32 || LZO_OS_WIN64) const char* p; p = __LZOLIB_FUNCNAME(lzo_getenv)(LZO_PP_STRINGIZE(LZO_ENV_RUNNING_ON_QEMU)); - if (p) { + + if (p) + { if (p[0] == 0) r = 0; else if ((p[0] >= '0' && p[0] <= '9') && p[1] == 0) r = LZO_ICAST(unsigned, p[0]) - '0'; else r = 1; } + #endif return r; } -LZOLIB_PUBLIC_NOINLINE(unsigned, lzo_debug_running_on_valgrind) (void) +LZOLIB_PUBLIC_NOINLINE(unsigned, lzo_debug_running_on_valgrind)(void) { #if (LZO_ARCH_AMD64 && LZO_ABI_ILP32) return 0; #elif (LZO_ARCH_AMD64 || LZO_ARCH_I386) && (LZO_ASM_SYNTAX_GNUC) volatile size_t a[6]; size_t r = 0; - a[0] = 0x1001; a[1] = 0; a[2] = 0; a[3] = 0; a[4] = 0; a[5] = 0; + a[0] = 0x1001; + a[1] = 0; + a[2] = 0; + a[3] = 0; + a[4] = 0; + a[5] = 0; # if (LZO_ARCH_AMD64) - __asm__ __volatile__(".byte 0x48,0xc1,0xc7,0x03,0x48,0xc1,0xc7,0x0d,0x48,0xc1,0xc7,0x3d,0x48,0xc1,0xc7,0x33,0x48,0x87,0xdb\n" : "=d" (r) : "a" (&a[0]), "d" (r) __LZO_ASM_CLOBBER_LIST_CC_MEMORY); + __asm__ __volatile__(".byte 0x48,0xc1,0xc7,0x03,0x48,0xc1,0xc7,0x0d,0x48,0xc1,0xc7,0x3d,0x48,0xc1,0xc7,0x33,0x48,0x87,0xdb\n" : "=d"(r) : "a"(&a[0]), "d"(r) __LZO_ASM_CLOBBER_LIST_CC_MEMORY); # elif (LZO_ARCH_I386) - __asm__ __volatile__(".byte 0xc1,0xc7,0x03,0xc1,0xc7,0x0d,0xc1,0xc7,0x1d,0xc1,0xc7,0x13,0x87,0xdb\n" : "=d" (r) : "a" (&a[0]), "d" (r) __LZO_ASM_CLOBBER_LIST_CC_MEMORY); + __asm__ __volatile__(".byte 0xc1,0xc7,0x03,0xc1,0xc7,0x0d,0xc1,0xc7,0x1d,0xc1,0xc7,0x13,0x87,0xdb\n" : "=d"(r) : "a"(&a[0]), "d"(r) __LZO_ASM_CLOBBER_LIST_CC_MEMORY); # endif return LZO_ITRUNC(unsigned, r); #else @@ -3650,9 +4037,10 @@ LZO_EXTERN_C int __lzo_cdecl _setargv(void) { return __setargv(); } #endif #if (LZO_OS_EMX) #define __LZOLIB_HAVE_LZO_WILDARGV 1 -LZOLIB_PUBLIC(void, lzo_wildargv) (int* argc, char*** argv) +LZOLIB_PUBLIC(void, lzo_wildargv)(int* argc, char** * argv) { - if (argc && argv) { + if (argc && argv) + { _response(argc, argv); _wildcard(argc, argv); } @@ -3661,23 +4049,29 @@ LZOLIB_PUBLIC(void, lzo_wildargv) (int* argc, char*** argv) #if (LZO_OS_CONSOLE_PSP) && defined(__PSPSDK_DEBUG__) #define __LZOLIB_HAVE_LZO_WILDARGV 1 LZO_EXTERN_C int lzo_psp_init_module(int*, char***, int); -LZOLIB_PUBLIC(void, lzo_wildargv) (int* argc, char*** argv) +LZOLIB_PUBLIC(void, lzo_wildargv)(int* argc, char** * argv) { lzo_psp_init_module(argc, argv, -1); } #endif #if !(__LZOLIB_HAVE_LZO_WILDARGV) #define __LZOLIB_HAVE_LZO_WILDARGV 1 -LZOLIB_PUBLIC(void, lzo_wildargv) (int* argc, char*** argv) +LZOLIB_PUBLIC(void, lzo_wildargv)(int* argc, char** * argv) { #if 1 && (LZO_ARCH_I086PM) + if (LZO_MM_AHSHIFT != 3) { exit(1); } + #elif 1 && (LZO_ARCH_M68K && LZO_OS_TOS && LZO_CC_GNUC) && defined(__MINT__) __binmode(1); + if (isatty(1)) __set_binmode(stdout, 0); + if (isatty(2)) __set_binmode(stderr, 0); + #endif - LZO_UNUSED(argc); LZO_UNUSED(argv); + LZO_UNUSED(argc); + LZO_UNUSED(argv); } #endif #endif diff --git a/extern/lzo/src/lzo_swd.ch b/extern/lzo/src/lzo_swd.ch index 4a73a6b..dfa8ebb 100644 --- a/extern/lzo/src/lzo_swd.ch +++ b/extern/lzo/src/lzo_swd.ch @@ -43,10 +43,10 @@ /* unsigned type for dictionary access - don't waste memory here */ #if (0UL + SWD_N + SWD_F + SWD_F < 65535UL) - typedef lzo_uint16_t swd_uint; +typedef lzo_uint16_t swd_uint; # define SWD_UINT_MAX 0xffffu #else - typedef lzo_uint32_t swd_uint; +typedef lzo_uint32_t swd_uint; # define SWD_UINT_MAX 0xffffffffu #endif #define swd_uintp swd_uint * @@ -85,18 +85,18 @@ typedef struct { -/* public - "built-in" */ + /* public - "built-in" */ lzo_uint swd_n; lzo_uint swd_f; lzo_uint swd_threshold; -/* public - configuration */ + /* public - configuration */ lzo_uint max_chain; lzo_uint nice_length; lzo_bool use_best_off; lzo_uint lazy_insert; -/* public - output */ + /* public - output */ lzo_uint m_len; lzo_uint m_off; lzo_uint look; @@ -105,19 +105,19 @@ typedef struct lzo_uint best_off[ SWD_BEST_OFF ]; #endif -/* semi public */ - LZO_COMPRESS_T *c; + /* semi public */ + LZO_COMPRESS_T* c; lzo_uint m_pos; #if defined(SWD_BEST_OFF) lzo_uint best_pos[ SWD_BEST_OFF ]; #endif -/* private */ + /* private */ const lzo_bytep dict; const lzo_bytep dict_end; lzo_uint dict_len; -/* private */ + /* private */ lzo_uint ip; /* input pointer (lookahead) */ lzo_uint bp; /* buffer pointer */ lzo_uint rp; /* remove pointer */ @@ -130,13 +130,13 @@ typedef struct #if defined(__LZO_CHECKER) /* malloc arrays of the exact size to detect any overrun */ - unsigned char *b; - swd_uint *head3; - swd_uint *succ3; - swd_uint *best3; - swd_uint *llen3; + unsigned char* b; + swd_uint* head3; + swd_uint* succ3; + swd_uint* best3; + swd_uint* llen3; # ifdef HEAD2 - swd_uint *head2; + swd_uint* head2; # endif #else @@ -189,6 +189,7 @@ void swd_initdict(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len) if (!dict || dict_len == 0) return; + if (dict_len > s->swd_n) { dict += dict_len - s->swd_n; @@ -198,7 +199,7 @@ void swd_initdict(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len) s->dict = dict; s->dict_len = dict_len; s->dict_end = dict + dict_len; - lzo_memcpy(s_b(s),dict,dict_len); + lzo_memcpy(s_b(s), dict, dict_len); s->ip = dict_len; } @@ -212,24 +213,25 @@ void swd_insertdict(lzo_swd_p s, lzo_uint node, lzo_uint len) s->first_rp = node; if (len) do - { - key = HEAD3(s_b(s),node); - s_succ3(s)[node] = s_get_head3(s,key); - s_head3(s)[key] = SWD_UINT(node); - s_best3(s)[node] = SWD_UINT(s->swd_f + 1); - s_llen3(s)[key]++; - assert(s_llen3(s)[key] <= s->swd_n); + { + key = HEAD3(s_b(s), node); + s_succ3(s)[node] = s_get_head3(s, key); + s_head3(s)[key] = SWD_UINT(node); + s_best3(s)[node] = SWD_UINT(s->swd_f + 1); + s_llen3(s)[key]++; + assert(s_llen3(s)[key] <= s->swd_n); #ifdef HEAD2 - IF_HEAD2(s) { - key = HEAD2(s_b(s),node); - s_head2(s)[key] = SWD_UINT(node); - } + IF_HEAD2(s) + { + key = HEAD2(s_b(s), node); + s_head2(s)[key] = SWD_UINT(node); + } #endif - node++; - } - while (--len != 0); + node++; + } + while (--len != 0); } @@ -255,15 +257,19 @@ int swd_init(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len) r &= s->best3 != NULL; r &= s->llen3 != NULL; #ifdef HEAD2 - IF_HEAD2(s) { + IF_HEAD2(s) + { s->head2 = (swd_uintp) malloc(sizeof(swd_uint) * 65536L); r &= s->head2 != NULL; } #endif - if (r != 1) { + + if (r != 1) + { swd_exit(s); return LZO_E_OUT_OF_MEMORY; } + #endif s->m_len = 0; @@ -271,6 +277,7 @@ int swd_init(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len) #if defined(SWD_BEST_OFF) { unsigned i; + for (i = 0; i < SWD_BEST_OFF; i++) s->best_off[i] = s->best_pos[i] = 0; } @@ -288,8 +295,10 @@ int swd_init(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len) s->b_size = s->swd_n + s->swd_f; #if 0 + if (2 * s->swd_f >= s->swd_n || s->b_size + s->swd_f >= SWD_UINT_MAX) return LZO_E_ERROR; + #else LZO_COMPILE_TIME_ASSERT(!(0ul + 2 * SWD_F >= SWD_N)) LZO_COMPILE_TIME_ASSERT(!(0ul + SWD_N + SWD_F + SWD_F >= SWD_UINT_MAX)) @@ -299,65 +308,80 @@ int swd_init(lzo_swd_p s, const lzo_bytep dict, lzo_uint dict_len) lzo_memset(s_llen3(s), 0, (lzo_uint)sizeof(s_llen3(s)[0]) * (lzo_uint)SWD_HSIZE); #ifdef HEAD2 - IF_HEAD2(s) { + IF_HEAD2(s) + { #if 1 lzo_memset(s_head2(s), 0xff, (lzo_uint)sizeof(s_head2(s)[0]) * 65536L); assert(s_head2(s)[0] == NIL2); #else lzo_xint i; + for (i = 0; i < 65536L; i++) s_head2(s)[i] = NIL2; + #endif } #endif s->ip = 0; - swd_initdict(s,dict,dict_len); + swd_initdict(s, dict, dict_len); s->bp = s->ip; s->first_rp = s->ip; assert(s->ip + s->swd_f <= s->b_size); #if 1 - s->look = (lzo_uint) (s->c->in_end - s->c->ip); + s->look = (lzo_uint)(s->c->in_end - s->c->ip); + if (s->look > 0) { if (s->look > s->swd_f) s->look = s->swd_f; - lzo_memcpy(&s_b(s)[s->ip],s->c->ip,s->look); + + lzo_memcpy(&s_b(s)[s->ip], s->c->ip, s->look); s->c->ip += s->look; s->ip += s->look; } + #else s->look = 0; + while (s->look < s->swd_f) { int c; + if ((c = getbyte(*(s->c))) < 0) break; + s_b(s)[s->ip] = LZO_BYTE(c); s->ip++; s->look++; } + #endif + if (s->ip == s->b_size) s->ip = 0; if (s->look >= 2 && s->dict_len > 0) - swd_insertdict(s,0,s->dict_len); + swd_insertdict(s, 0, s->dict_len); s->rp = s->first_rp; + if (s->rp >= s->node_count) s->rp -= s->node_count; else s->rp += s->b_size - s->node_count; #if 1 || defined(__LZO_CHECKER) + /* initialize memory for the first few HEAD3 (if s->ip is not far * enough ahead to do this job for us). The value doesn't matter. */ - if (s->look < 3) { - lzo_bytep p = &s_b(s)[s->bp+s->look]; + if (s->look < 3) + { + lzo_bytep p = &s_b(s)[s->bp + s->look]; p[0] = p[1] = p[2] = 0; } + #endif return LZO_E_OK; @@ -370,13 +394,19 @@ void swd_exit(lzo_swd_p s) #if defined(__LZO_CHECKER) /* free in reverse order of allocations */ #ifdef HEAD2 - free(s->head2); s->head2 = NULL; + free(s->head2); + s->head2 = NULL; #endif - free(s->llen3); s->llen3 = NULL; - free(s->best3); s->best3 = NULL; - free(s->succ3); s->succ3 = NULL; - free(s->head3); s->head3 = NULL; - free(s->b); s->b = NULL; + free(s->llen3); + s->llen3 = NULL; + free(s->best3); + s->best3 = NULL; + free(s->succ3); + s->succ3 = NULL; + free(s->head3); + s->head3 = NULL; + free(s->b); + s->b = NULL; #else LZO_UNUSED(s); #endif @@ -400,23 +430,30 @@ void swd_getbyte(lzo_swd_p s) { if (s->look > 0) --s->look; + #if 1 || defined(__LZO_CHECKER) /* initialize memory - value doesn't matter */ s_b(s)[s->ip] = 0; + if (s->ip < s->swd_f) s->b_wrap[s->ip] = 0; + #endif } else { s_b(s)[s->ip] = LZO_BYTE(c); + if (s->ip < s->swd_f) s->b_wrap[s->ip] = LZO_BYTE(c); } + if (++s->ip == s->b_size) s->ip = 0; + if (++s->bp == s->b_size) s->bp = 0; + if (++s->rp == s->b_size) s->rp = 0; } @@ -434,26 +471,31 @@ void swd_remove_node(lzo_swd_p s, lzo_uint node) lzo_uint key; #ifdef LZO_DEBUG + if (s->first_rp != LZO_UINT_MAX) { if (node != s->first_rp) printf("Remove %5ld: %5ld %5ld %5ld %5ld %6ld %6ld\n", - (long)node, (long)s->rp, (long)s->ip, (long)s->bp, - (long)s->first_rp, (long)(s->ip - node), - (long)(s->ip - s->bp)); + (long)node, (long)s->rp, (long)s->ip, (long)s->bp, + (long)s->first_rp, (long)(s->ip - node), + (long)(s->ip - s->bp)); + assert(node == s->first_rp); s->first_rp = LZO_UINT_MAX; } + #endif - key = HEAD3(s_b(s),node); + key = HEAD3(s_b(s), node); assert(s_llen3(s)[key] > 0); --s_llen3(s)[key]; #ifdef HEAD2 - IF_HEAD2(s) { - key = HEAD2(s_b(s),node); + IF_HEAD2(s) + { + key = HEAD2(s_b(s), node); assert(s_head2(s)[key] != NIL2); + if ((lzo_uint) s_head2(s)[key] == node) s_head2(s)[key] = NIL2; } @@ -474,29 +516,31 @@ void swd_accept(lzo_swd_p s, lzo_uint n) assert(n <= s->look); if (n) do - { - lzo_uint key; + { + lzo_uint key; - swd_remove_node(s,s->rp); + swd_remove_node(s, s->rp); - /* add bp into HEAD3 */ - key = HEAD3(s_b(s),s->bp); - s_succ3(s)[s->bp] = s_get_head3(s,key); - s_head3(s)[key] = SWD_UINT(s->bp); - s_best3(s)[s->bp] = SWD_UINT(s->swd_f + 1); - s_llen3(s)[key]++; - assert(s_llen3(s)[key] <= s->swd_n); + /* add bp into HEAD3 */ + key = HEAD3(s_b(s), s->bp); + s_succ3(s)[s->bp] = s_get_head3(s, key); + s_head3(s)[key] = SWD_UINT(s->bp); + s_best3(s)[s->bp] = SWD_UINT(s->swd_f + 1); + s_llen3(s)[key]++; + assert(s_llen3(s)[key] <= s->swd_n); #ifdef HEAD2 - /* add bp into HEAD2 */ - IF_HEAD2(s) { - key = HEAD2(s_b(s),s->bp); - s_head2(s)[key] = SWD_UINT(s->bp); - } + /* add bp into HEAD2 */ + IF_HEAD2(s) + { + key = HEAD2(s_b(s), s->bp); + s_head2(s)[key] = SWD_UINT(s->bp); + } #endif - swd_getbyte(s); - } while (--n != 0); + swd_getbyte(s); + } + while (--n != 0); } @@ -519,7 +563,8 @@ void swd_search(lzo_swd_p s, lzo_uint node, lzo_uint cnt) assert(s->m_len > 0); scan_end1 = bp[m_len - 1]; - for ( ; cnt-- > 0; node = s_succ3(s)[node]) + + for (; cnt-- > 0; node = s_succ3(s)[node]) { p1 = bp; p2 = b + node; @@ -536,45 +581,62 @@ void swd_search(lzo_swd_p s, lzo_uint node, lzo_uint cnt) p2[1] == p1[1]) { lzo_uint i; - assert(lzo_memcmp(bp,&b[node],3) == 0); + assert(lzo_memcmp(bp, &b[node], 3) == 0); #if 0 && (LZO_OPT_UNALIGNED32) - p1 += 3; p2 += 3; + p1 += 3; + p2 += 3; + while (p1 + 4 <= px && UA_GET_NE32(p1) == UA_GET_NE32(p2)) p1 += 4, p2 += 4; + while (p1 < px && *p1 == *p2) p1 += 1, p2 += 1; + #else - p1 += 2; p2 += 2; - do {} while (++p1 < px && *p1 == *++p2); + p1 += 2; + p2 += 2; + + do {} + while (++p1 < px && *p1 == *++p2); + #endif i = pd(p1, bp); #ifdef LZO_DEBUG - if (lzo_memcmp(bp,&b[node],i) != 0) + + if (lzo_memcmp(bp, &b[node], i) != 0) printf("%5ld %5ld %5ld %02x/%02x %02x/%02x\n", - (long)s->bp, (long) node, (long) i, - bp[0], bp[1], b[node], b[node+1]); + (long)s->bp, (long) node, (long) i, + bp[0], bp[1], b[node], b[node + 1]); + #endif - assert(lzo_memcmp(bp,&b[node],i) == 0); + assert(lzo_memcmp(bp, &b[node], i) == 0); #if defined(SWD_BEST_OFF) + if (i < SWD_BEST_OFF) { if (s->best_pos[i] == 0) s->best_pos[i] = node + 1; } + #endif + if (i > m_len) { s->m_len = m_len = i; s->m_pos = node; + if (m_len == s->look) return; + if (m_len >= s->nice_length) return; + if (m_len > (lzo_uint) s_best3(s)[node]) return; + scan_end1 = bp[m_len - 1]; } } @@ -596,18 +658,24 @@ lzo_bool swd_search2(lzo_swd_p s) assert(s->look >= 2); assert(s->m_len > 0); - key = s_head2(s)[ HEAD2(s_b(s),s->bp) ]; + key = s_head2(s)[ HEAD2(s_b(s), s->bp) ]; + if (key == NIL2) return 0; + #ifdef LZO_DEBUG - if (lzo_memcmp(&s_b(s)[s->bp],&s_b(s)[key],2) != 0) + + if (lzo_memcmp(&s_b(s)[s->bp], &s_b(s)[key], 2) != 0) printf("%5ld %5ld %02x/%02x %02x/%02x\n", (long)s->bp, (long)key, - s_b(s)[s->bp], s_b(s)[s->bp+1], s_b(s)[key], s_b(s)[key+1]); + s_b(s)[s->bp], s_b(s)[s->bp + 1], s_b(s)[key], s_b(s)[key + 1]); + #endif - assert(lzo_memcmp(&s_b(s)[s->bp],&s_b(s)[key],2) == 0); + assert(lzo_memcmp(&s_b(s)[s->bp], &s_b(s)[key], 2) == 0); #if defined(SWD_BEST_OFF) + if (s->best_pos[2] == 0) s->best_pos[2] = key + 1; + #endif if (s->m_len < 2) @@ -615,6 +683,7 @@ lzo_bool swd_search2(lzo_swd_p s) s->m_len = 2; s->m_pos = key; } + return 1; } @@ -635,55 +704,69 @@ void swd_findbest(lzo_swd_p s) assert(s->m_len > 0); /* get current head, add bp into HEAD3 */ - key = HEAD3(s_b(s),s->bp); - node = s_succ3(s)[s->bp] = s_get_head3(s,key); + key = HEAD3(s_b(s), s->bp); + node = s_succ3(s)[s->bp] = s_get_head3(s, key); cnt = s_llen3(s)[key]++; assert(s_llen3(s)[key] <= s->swd_n + s->swd_f); + if (cnt > s->max_chain && s->max_chain > 0) cnt = s->max_chain; + s_head3(s)[key] = SWD_UINT(s->bp); s->b_char = s_b(s)[s->bp]; len = s->m_len; + if (s->m_len >= s->look) { if (s->look == 0) s->b_char = -1; + s->m_off = 0; s_best3(s)[s->bp] = SWD_UINT(s->swd_f + 1); } else { #if defined(HEAD2) + if (swd_search2(s) && s->look >= 3) - swd_search(s,node,cnt); + swd_search(s, node, cnt); + #else + if (s->look >= 3) - swd_search(s,node,cnt); + swd_search(s, node, cnt); + #endif + if (s->m_len > len) - s->m_off = swd_pos2off(s,s->m_pos); + s->m_off = swd_pos2off(s, s->m_pos); + s_best3(s)[s->bp] = SWD_UINT(s->m_len); #if defined(SWD_BEST_OFF) + if (s->use_best_off) { unsigned i; + for (i = 2; i < SWD_BEST_OFF; i++) if (s->best_pos[i] > 0) - s->best_off[i] = swd_pos2off(s,s->best_pos[i]-1); + s->best_off[i] = swd_pos2off(s, s->best_pos[i] - 1); else s->best_off[i] = 0; } + #endif } - swd_remove_node(s,s->rp); + swd_remove_node(s, s->rp); #ifdef HEAD2 /* add bp into HEAD2 */ - IF_HEAD2(s) { - key = HEAD2(s_b(s),s->bp); + IF_HEAD2(s) + { + key = HEAD2(s_b(s), s->bp); s_head2(s)[key] = SWD_UINT(s->bp); } #endif diff --git a/extern/lzo/src/lzo_util.c b/extern/lzo/src/lzo_util.c index 2f8059f..1f35fc9 100644 --- a/extern/lzo/src/lzo_util.c +++ b/extern/lzo/src/lzo_util.c @@ -66,13 +66,13 @@ lzo_version(void) return LZO_VERSION; } -LZO_PUBLIC(const char *) +LZO_PUBLIC(const char*) lzo_version_string(void) { return lzo_version_string_; } -LZO_PUBLIC(const char *) +LZO_PUBLIC(const char*) lzo_version_date(void) { return lzo_version_date_; @@ -121,20 +121,26 @@ lzo_adler32(lzo_uint32_t adler, const lzo_bytep buf, lzo_uint len) { k = len < LZO_NMAX ? (unsigned) len : LZO_NMAX; len -= k; + if (k >= 16) do - { - LZO_DO16(buf,0); - buf += 16; - k -= 16; - } while (k >= 16); + { + LZO_DO16(buf, 0); + buf += 16; + k -= 16; + } + while (k >= 16); + if (k != 0) do - { - s1 += *buf++; - s2 += s1; - } while (--k > 0); + { + s1 += *buf++; + s2 += s1; + } + while (--k > 0); + s1 %= LZO_BASE; s2 %= LZO_BASE; } + return (s2 << 16) | s1; } diff --git a/extern/lzo/src/stats1a.h b/extern/lzo/src/stats1a.h index 8edfd90..1e33e9d 100644 --- a/extern/lzo/src/stats1a.h +++ b/extern/lzo/src/stats1a.h @@ -57,17 +57,18 @@ extern "C" { // ************************************************************************/ -typedef struct { +typedef struct +{ -/* configuration */ + /* configuration */ unsigned rbits; unsigned clevel; -/* internal configuration */ + /* internal configuration */ unsigned dbits; unsigned lbits; -/* constants */ + /* constants */ unsigned min_match_short; unsigned max_match_short; unsigned min_match_long; @@ -78,7 +79,7 @@ typedef struct { unsigned r0fast; unsigned r0max; -/* counts */ + /* counts */ long short_matches; long long_matches; long r1_matches; @@ -88,14 +89,14 @@ typedef struct { long r0fast_runs; long r0long_runs; -/* */ + /* */ long lit_run[RSIZE]; long lit_run_after_long_match[RSIZE]; long short_match[MAX_MATCH_SHORT + 1]; long long_match[MAX_MATCH_LONG + 1]; long marker[256]; -/* these could prove useful for further optimizations */ + /* these could prove useful for further optimizations */ long short_match_offset_osize[MAX_MATCH_SHORT + 1]; long short_match_offset_256[MAX_MATCH_SHORT + 1]; long short_match_offset_1024[MAX_MATCH_SHORT + 1]; @@ -104,13 +105,13 @@ typedef struct { long matches_out_of_range_4; long match_out_of_range[MAX_MATCH_SHORT + 1]; -/* */ + /* */ long in_len; long out_len; } lzo1a_stats_t; -extern lzo1a_stats_t *lzo1a_stats; +extern lzo1a_stats_t* lzo1a_stats; diff --git a/extern/lzo/src/stats1b.h b/extern/lzo/src/stats1b.h index 20274cd..33ef03e 100644 --- a/extern/lzo/src/stats1b.h +++ b/extern/lzo/src/stats1b.h @@ -57,19 +57,19 @@ extern "C" { typedef struct { -/* algorithm configuration */ + /* algorithm configuration */ unsigned r_bits; unsigned m3o_bits; unsigned dd_bits; unsigned clevel; -/* internal configuration */ + /* internal configuration */ unsigned d_bits; long min_lookahead; long max_lookbehind; - const char *compress_id; + const char* compress_id; -/* counts */ + /* counts */ long lit_runs; long r0short_runs; long r0fast_runs; @@ -80,16 +80,16 @@ typedef struct long m4_matches; long r1_matches; -/* */ + /* */ long lit_run[R0MIN]; long m2_match[M2_MAX_LEN + 1]; long m3_match[M3_MAX_LEN + 1]; #if (M3O_BITS < 8) long lit_runs_after_m3_match; - long lit_run_after_m3_match[LZO_SIZE(8-M3O_BITS)]; + long lit_run_after_m3_match[LZO_SIZE(8 - M3O_BITS)]; #endif -/* */ + /* */ long matches; long match_bytes; long literals; @@ -97,21 +97,21 @@ typedef struct long literal_bytes; double literal_overhead_percent; -/* */ + /* */ long unused_dict_entries; double unused_dict_entries_percent; -/* */ + /* */ long in_len; long out_len; } lzo1b_stats_t; -void _lzo1b_stats_init(lzo1b_stats_t *lzo_stats); -void _lzo1b_stats_calc(lzo1b_stats_t *lzo_stats); +void _lzo1b_stats_init(lzo1b_stats_t* lzo_stats); +void _lzo1b_stats_calc(lzo1b_stats_t* lzo_stats); -extern lzo1b_stats_t * const lzo1b_stats; +extern lzo1b_stats_t* const lzo1b_stats; #define lzo_stats_t lzo1b_stats_t #define lzo_stats lzo1b_stats diff --git a/extern/zlib/adler32.c b/extern/zlib/adler32.c index b55868c..6ef6ac2 100644 --- a/extern/zlib/adler32.c +++ b/extern/zlib/adler32.c @@ -63,12 +63,12 @@ local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2)); /* ========================================================================= */ #ifdef WIN32 -uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len) +uLong ZEXPORT adler32(uLong adler, const Bytef* buf, uInt len) #else uLong ZEXPORT adler32(adler, buf, len) - uLong adler; - const Bytef *buf; - uInt len; +uLong adler; +const Bytef* buf; +uInt len; #endif { unsigned long sum2; @@ -79,13 +79,18 @@ uLong ZEXPORT adler32(adler, buf, len) adler &= 0xffff; /* in case user likes doing a byte at a time, keep it fast */ - if (len == 1) { + if (len == 1) + { adler += buf[0]; + if (adler >= BASE) adler -= BASE; + sum2 += adler; + if (sum2 >= BASE) sum2 -= BASE; + return adler | (sum2 << 16); } @@ -94,40 +99,54 @@ uLong ZEXPORT adler32(adler, buf, len) return 1L; /* in case short lengths are provided, keep it somewhat fast */ - if (len < 16) { - while (len--) { + if (len < 16) + { + while (len--) + { adler += *buf++; sum2 += adler; } + if (adler >= BASE) adler -= BASE; + MOD28(sum2); /* only added so many BASE's */ return adler | (sum2 << 16); } /* do length NMAX blocks -- requires just one modulo operation */ - while (len >= NMAX) { + while (len >= NMAX) + { len -= NMAX; n = NMAX / 16; /* NMAX is divisible by 16 */ - do { + + do + { DO16(buf); /* 16 sums unrolled */ buf += 16; - } while (--n); + } + while (--n); + MOD(adler); MOD(sum2); } /* do remaining bytes (less than NMAX, still just one modulo) */ - if (len) { /* avoid modulos if none remaining */ - while (len >= 16) { + if (len) /* avoid modulos if none remaining */ + { + while (len >= 16) + { len -= 16; DO16(buf); buf += 16; } - while (len--) { + + while (len--) + { adler += *buf++; sum2 += adler; } + MOD(adler); MOD(sum2); } @@ -141,9 +160,9 @@ uLong ZEXPORT adler32(adler, buf, len) local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2) #else local uLong adler32_combine_(adler1, adler2, len2) - uLong adler1; - uLong adler2; - z_off64_t len2; +uLong adler1; +uLong adler2; +z_off64_t len2; #endif { unsigned long sum1; @@ -162,10 +181,15 @@ local uLong adler32_combine_(adler1, adler2, len2) MOD(sum2); sum1 += (adler2 & 0xffff) + BASE - 1; sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; + if (sum1 >= BASE) sum1 -= BASE; + if (sum1 >= BASE) sum1 -= BASE; + if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1); + if (sum2 >= BASE) sum2 -= BASE; + return sum1 | (sum2 << 16); } @@ -174,9 +198,9 @@ local uLong adler32_combine_(adler1, adler2, len2) uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2, z_off_t len2) #else uLong ZEXPORT adler32_combine(adler1, adler2, len2) - uLong adler1; - uLong adler2; - z_off_t len2; +uLong adler1; +uLong adler2; +z_off_t len2; #endif { return adler32_combine_(adler1, adler2, len2); @@ -186,9 +210,9 @@ uLong ZEXPORT adler32_combine(adler1, adler2, len2) uLong ZEXPORT adler32_combine64(uLong adler1, uLong adler2, z_off64_t len2) #else uLong ZEXPORT adler32_combine64(adler1, adler2, len2) - uLong adler1; - uLong adler2; - z_off64_t len2; +uLong adler1; +uLong adler2; +z_off64_t len2; #endif { return adler32_combine_(adler1, adler2, len2); diff --git a/extern/zlib/compress.c b/extern/zlib/compress.c index d9b0254..a2557e9 100644 --- a/extern/zlib/compress.c +++ b/extern/zlib/compress.c @@ -20,14 +20,14 @@ Z_STREAM_ERROR if the level parameter is invalid. */ #ifdef WIN32 -int ZEXPORT compress2 (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level) +int ZEXPORT compress2(Bytef* dest, uLongf* destLen, const Bytef* source, uLong sourceLen, int level) #else -int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) - Bytef *dest; - uLongf *destLen; - const Bytef *source; - uLong sourceLen; - int level; +int ZEXPORT compress2(dest, destLen, source, sourceLen, level) +Bytef* dest; +uLongf* destLen; +const Bytef* source; +uLong sourceLen; +int level; #endif { z_stream stream; @@ -36,11 +36,14 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) stream.next_in = (Bytef*)source; stream.avail_in = (uInt)sourceLen; #ifdef MAXSEG_64K + /* Check for source > 64K on 16-bit machine: */ if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; + #endif stream.next_out = dest; - stream.avail_out = (uInt)*destLen; + stream.avail_out = (uInt) * destLen; + if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; stream.zalloc = (alloc_func)0; @@ -48,13 +51,17 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) stream.opaque = (voidpf)0; err = deflateInit(&stream, level); + if (err != Z_OK) return err; err = deflate(&stream, Z_FINISH); - if (err != Z_STREAM_END) { + + if (err != Z_STREAM_END) + { deflateEnd(&stream); return err == Z_OK ? Z_BUF_ERROR : err; } + *destLen = stream.total_out; err = deflateEnd(&stream); @@ -64,13 +71,13 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) /* =========================================================================== */ #ifdef WIN32 -int ZEXPORT compress(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen) +int ZEXPORT compress(Bytef* dest, uLongf* destLen, const Bytef* source, uLong sourceLen) #else -int ZEXPORT compress (dest, destLen, source, sourceLen) - Bytef *dest; - uLongf *destLen; - const Bytef *source; - uLong sourceLen; +int ZEXPORT compress(dest, destLen, source, sourceLen) +Bytef* dest; +uLongf* destLen; +const Bytef* source; +uLong sourceLen; #endif { return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); @@ -81,10 +88,10 @@ int ZEXPORT compress (dest, destLen, source, sourceLen) this function needs to be updated. */ #ifdef WIN32 -uLong ZEXPORT compressBound (uLong sourceLen) +uLong ZEXPORT compressBound(uLong sourceLen) #else -uLong ZEXPORT compressBound (sourceLen) - uLong sourceLen; +uLong ZEXPORT compressBound(sourceLen) +uLong sourceLen; #endif { return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + diff --git a/extern/zlib/crc32.c b/extern/zlib/crc32.c index 01fda12..5ef072f 100644 --- a/extern/zlib/crc32.c +++ b/extern/zlib/crc32.c @@ -37,19 +37,19 @@ # define BYFOUR #endif #ifdef BYFOUR - local unsigned long crc32_little OF((unsigned long, - const unsigned char FAR *, unsigned)); - local unsigned long crc32_big OF((unsigned long, - const unsigned char FAR *, unsigned)); +local unsigned long crc32_little OF((unsigned long, + const unsigned char FAR*, unsigned)); +local unsigned long crc32_big OF((unsigned long, + const unsigned char FAR*, unsigned)); # define TBLS 8 #else # define TBLS 1 #endif /* BYFOUR */ /* Local functions for crc concatenation */ -local unsigned long gf2_matrix_times OF((unsigned long *mat, - unsigned long vec)); -local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); +local unsigned long gf2_matrix_times OF((unsigned long* mat, + unsigned long vec)); +local void gf2_matrix_square OF((unsigned long* square, unsigned long* mat)); local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2)); @@ -59,7 +59,7 @@ local volatile int crc_table_empty = 1; local z_crc_t FAR crc_table[TBLS][256]; local void make_crc_table OF((void)); #ifdef MAKECRCH - local void write_table OF((FILE *, const z_crc_t FAR *)); +local void write_table OF((FILE*, const z_crc_t FAR*)); #endif /* MAKECRCH */ /* Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: @@ -94,44 +94,55 @@ local void make_crc_table() z_crc_t poly; /* polynomial exclusive-or pattern */ /* terms of polynomial defining this crc (except x^32): */ static volatile int first = 1; /* flag to limit concurrent making */ - static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; + static const unsigned char p[] = {0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26}; /* See if another task is already doing this (not thread-safe, but better than nothing -- significantly reduces duration of vulnerability in case the advice about DYNAMIC_CRC_TABLE is ignored) */ - if (first) { + if (first) + { first = 0; /* make exclusive-or pattern from polynomial (0xedb88320UL) */ poly = 0; - for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++) + + for (n = 0; n < (int)(sizeof(p) / sizeof(unsigned char)); n++) poly |= (z_crc_t)1 << (31 - p[n]); /* generate a crc for every 8-bit value */ - for (n = 0; n < 256; n++) { + for (n = 0; n < 256; n++) + { c = (z_crc_t)n; + for (k = 0; k < 8; k++) c = c & 1 ? poly ^ (c >> 1) : c >> 1; + crc_table[0][n] = c; } #ifdef BYFOUR + /* generate crc for each value followed by one, two, and three zeros, and then the byte reversal of those as well as the first table */ - for (n = 0; n < 256; n++) { + for (n = 0; n < 256; n++) + { c = crc_table[0][n]; crc_table[4][n] = ZSWAP32(c); - for (k = 1; k < 4; k++) { + + for (k = 1; k < 4; k++) + { c = crc_table[0][c & 0xff] ^ (c >> 8); crc_table[k][n] = c; crc_table[k + 4][n] = ZSWAP32(c); } } + #endif /* BYFOUR */ crc_table_empty = 0; } - else { /* not first */ + else /* not first */ + { /* wait for the other guy to finish (not efficient, but rare) */ while (crc_table_empty) ; @@ -140,10 +151,12 @@ local void make_crc_table() #ifdef MAKECRCH /* write out CRC tables to crc32.h */ { - FILE *out; + FILE* out; out = fopen("crc32.h", "w"); + if (out == NULL) return; + fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); fprintf(out, "local const z_crc_t FAR "); @@ -151,10 +164,13 @@ local void make_crc_table() write_table(out, crc_table[0]); # ifdef BYFOUR fprintf(out, "#ifdef BYFOUR\n"); - for (k = 1; k < 8; k++) { + + for (k = 1; k < 8; k++) + { fprintf(out, " },\n {\n"); write_table(out, crc_table[k]); } + fprintf(out, "#endif\n"); # endif /* BYFOUR */ fprintf(out, " }\n};\n"); @@ -165,8 +181,8 @@ local void make_crc_table() #ifdef MAKECRCH local void write_table(out, table) - FILE *out; - const z_crc_t FAR *table; +FILE* out; +const z_crc_t FAR* table; { int n; @@ -187,13 +203,15 @@ local void write_table(out, table) /* ========================================================================= * This function can be used by asm versions of crc32() */ -const z_crc_t FAR * ZEXPORT get_crc_table() +const z_crc_t FAR* ZEXPORT get_crc_table() { #ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) make_crc_table(); + #endif /* DYNAMIC_CRC_TABLE */ - return (const z_crc_t FAR *)crc_table; + return (const z_crc_t FAR*)crc_table; } /* ========================================================================= */ @@ -202,45 +220,59 @@ const z_crc_t FAR * ZEXPORT get_crc_table() /* ========================================================================= */ #ifdef WIN32 -unsigned long ZEXPORT crc32(unsigned long crc, const unsigned char FAR *buf, uInt len) +unsigned long ZEXPORT crc32(unsigned long crc, const unsigned char FAR* buf, uInt len) #else unsigned long ZEXPORT crc32(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - uInt len; +unsigned long crc; +const unsigned char FAR* buf; +uInt len; #endif { if (buf == Z_NULL) return 0UL; #ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) make_crc_table(); + #endif /* DYNAMIC_CRC_TABLE */ #ifdef BYFOUR #ifdef WIN32 - int size_match = (sizeof(void *) == sizeof(ptrdiff_t)); - if (size_match) { -#else - if (sizeof(void *) == sizeof(ptrdiff_t)) { -#endif /* WIN32 */ - z_crc_t endian; + int size_match = (sizeof(void*) == sizeof(ptrdiff_t)); - endian = 1; - if (*((unsigned char *)(&endian))) + if (size_match) + { +#else + + if (sizeof(void*) == sizeof(ptrdiff_t)) + { +#endif /* WIN32 */ + z_crc_t endian; + + endian = 1; + + if (*((unsigned char*)(&endian))) return crc32_little(crc, buf, len); - else + else return crc32_big(crc, buf, len); } + #endif /* BYFOUR */ crc = crc ^ 0xffffffffUL; - while (len >= 8) { + + while (len >= 8) + { DO8; len -= 8; } - if (len) do { - DO1; - } while (--len); + + if (len) do + { + DO1; + } + while (--len); + return crc ^ 0xffffffffUL; } @@ -254,38 +286,48 @@ unsigned long ZEXPORT crc32(crc, buf, len) /* ========================================================================= */ #ifdef WIN32 -local unsigned long crc32_little(unsigned long crc, const unsigned char FAR *buf, unsigned len) +local unsigned long crc32_little(unsigned long crc, const unsigned char FAR* buf, unsigned len) #else local unsigned long crc32_little(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - unsigned len; +unsigned long crc; +const unsigned char FAR* buf; +unsigned len; #endif { register z_crc_t c; - register const z_crc_t FAR *buf4; + register const z_crc_t FAR* buf4; c = (z_crc_t)crc; c = ~c; - while (len && ((ptrdiff_t)buf & 3)) { + + while (len && ((ptrdiff_t)buf & 3)) + { c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); len--; } - buf4 = (const z_crc_t FAR *)(const void FAR *)buf; - while (len >= 32) { + buf4 = (const z_crc_t FAR*)(const void FAR*)buf; + + while (len >= 32) + { DOLIT32; len -= 32; } - while (len >= 4) { + + while (len >= 4) + { DOLIT4; len -= 4; } - buf = (const unsigned char FAR *)buf4; - if (len) do { - c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); - } while (--len); + buf = (const unsigned char FAR*)buf4; + + if (len) do + { + c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); + } + while (--len); + c = ~c; return (unsigned long)c; } @@ -298,40 +340,50 @@ local unsigned long crc32_little(crc, buf, len) /* ========================================================================= */ #ifdef WIN32 -local unsigned long crc32_big(unsigned long crc, const unsigned char FAR *buf, unsigned len) +local unsigned long crc32_big(unsigned long crc, const unsigned char FAR* buf, unsigned len) #else local unsigned long crc32_big(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - unsigned len; +unsigned long crc; +const unsigned char FAR* buf; +unsigned len; #endif { register z_crc_t c; - register const z_crc_t FAR *buf4; + register const z_crc_t FAR* buf4; c = ZSWAP32((z_crc_t)crc); c = ~c; - while (len && ((ptrdiff_t)buf & 3)) { + + while (len && ((ptrdiff_t)buf & 3)) + { c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); len--; } - buf4 = (const z_crc_t FAR *)(const void FAR *)buf; + buf4 = (const z_crc_t FAR*)(const void FAR*)buf; buf4--; - while (len >= 32) { + + while (len >= 32) + { DOBIG32; len -= 32; } - while (len >= 4) { + + while (len >= 4) + { DOBIG4; len -= 4; } - buf4++; - buf = (const unsigned char FAR *)buf4; - if (len) do { - c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); - } while (--len); + buf4++; + buf = (const unsigned char FAR*)buf4; + + if (len) do + { + c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); + } + while (--len); + c = ~c; return (unsigned long)(ZSWAP32(c)); } @@ -342,32 +394,36 @@ local unsigned long crc32_big(crc, buf, len) /* ========================================================================= */ #ifdef WIN32 -local unsigned long gf2_matrix_times(unsigned long *mat, unsigned long vec) +local unsigned long gf2_matrix_times(unsigned long* mat, unsigned long vec) #else local unsigned long gf2_matrix_times(mat, vec) - unsigned long *mat; - unsigned long vec; +unsigned long* mat; +unsigned long vec; #endif { unsigned long sum; sum = 0; - while (vec) { + + while (vec) + { if (vec & 1) sum ^= *mat; + vec >>= 1; mat++; } + return sum; } /* ========================================================================= */ #ifdef WIN32 -local void gf2_matrix_square(unsigned long *square, unsigned long *mat) +local void gf2_matrix_square(unsigned long* square, unsigned long* mat) #else local void gf2_matrix_square(square, mat) - unsigned long *square; - unsigned long *mat; +unsigned long* square; +unsigned long* mat; #endif { int n; @@ -381,9 +437,9 @@ local void gf2_matrix_square(square, mat) local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2) #else local uLong crc32_combine_(crc1, crc2, len2) - uLong crc1; - uLong crc2; - z_off64_t len2; +uLong crc1; +uLong crc2; +z_off64_t len2; #endif { int n; @@ -398,7 +454,9 @@ local uLong crc32_combine_(crc1, crc2, len2) /* put operator for one zero bit in odd */ odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ row = 1; - for (n = 1; n < GF2_DIM; n++) { + + for (n = 1; n < GF2_DIM; n++) + { odd[n] = row; row <<= 1; } @@ -411,11 +469,14 @@ local uLong crc32_combine_(crc1, crc2, len2) /* apply len2 zeros to crc1 (first square will put the operator for one zero byte, eight zero bits, in even) */ - do { + do + { /* apply zeros operator for this bit of len2 */ gf2_matrix_square(even, odd); + if (len2 & 1) crc1 = gf2_matrix_times(even, crc1); + len2 >>= 1; /* if no more bits set, then done */ @@ -424,12 +485,15 @@ local uLong crc32_combine_(crc1, crc2, len2) /* another iteration of the loop with odd and even swapped */ gf2_matrix_square(odd, even); + if (len2 & 1) crc1 = gf2_matrix_times(odd, crc1); + len2 >>= 1; /* if no more bits set, then done */ - } while (len2 != 0); + } + while (len2 != 0); /* return combined crc */ crc1 ^= crc2; @@ -441,9 +505,9 @@ local uLong crc32_combine_(crc1, crc2, len2) uLong ZEXPORT crc32_combine(uLong crc1, uLong crc2, z_off_t len2) #else uLong ZEXPORT crc32_combine(crc1, crc2, len2) - uLong crc1; - uLong crc2; - z_off_t len2; +uLong crc1; +uLong crc2; +z_off_t len2; #endif { return crc32_combine_(crc1, crc2, len2); @@ -453,9 +517,9 @@ uLong ZEXPORT crc32_combine(crc1, crc2, len2) uLong ZEXPORT crc32_combine64(uLong crc1, uLong crc2, z_off64_t len2) #else uLong ZEXPORT crc32_combine64(crc1, crc2, len2) - uLong crc1; - uLong crc2; - z_off64_t len2; +uLong crc1; +uLong crc2; +z_off64_t len2; #endif { return crc32_combine_(crc1, crc2, len2); diff --git a/extern/zlib/crc32.h b/extern/zlib/crc32.h index 9e0c778..115bbcd 100644 --- a/extern/zlib/crc32.h +++ b/extern/zlib/crc32.h @@ -4,438 +4,438 @@ local const z_crc_t FAR crc_table[TBLS][256] = { - { - 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, - 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL, - 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL, - 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL, - 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL, - 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL, - 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL, - 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL, - 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL, - 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL, - 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL, - 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL, - 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL, - 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL, - 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL, - 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL, - 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL, - 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL, - 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL, - 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL, - 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL, - 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL, - 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL, - 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL, - 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL, - 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL, - 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL, - 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL, - 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL, - 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL, - 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL, - 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL, - 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL, - 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL, - 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL, - 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL, - 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL, - 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL, - 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL, - 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL, - 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL, - 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL, - 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL, - 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL, - 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL, - 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL, - 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL, - 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL, - 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL, - 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL, - 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL, - 0x2d02ef8dUL + { + 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, + 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL, + 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL, + 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL, + 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL, + 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL, + 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL, + 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL, + 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL, + 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL, + 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL, + 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL, + 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL, + 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL, + 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL, + 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL, + 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL, + 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL, + 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL, + 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL, + 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL, + 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL, + 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL, + 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL, + 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL, + 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL, + 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL, + 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL, + 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL, + 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL, + 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL, + 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL, + 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL, + 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL, + 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL, + 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL, + 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL, + 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL, + 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL, + 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL, + 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL, + 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL, + 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL, + 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL, + 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL, + 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL, + 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL, + 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL, + 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL, + 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL, + 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL, + 0x2d02ef8dUL #ifdef BYFOUR - }, - { - 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL, - 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL, - 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL, - 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL, - 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL, - 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL, - 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL, - 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL, - 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL, - 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL, - 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL, - 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL, - 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL, - 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL, - 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL, - 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL, - 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL, - 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL, - 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL, - 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL, - 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL, - 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL, - 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL, - 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL, - 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL, - 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL, - 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL, - 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL, - 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL, - 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL, - 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL, - 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL, - 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL, - 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL, - 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL, - 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL, - 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL, - 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL, - 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL, - 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL, - 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL, - 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL, - 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL, - 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL, - 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL, - 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL, - 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL, - 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL, - 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL, - 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL, - 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL, - 0x9324fd72UL - }, - { - 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL, - 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL, - 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL, - 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL, - 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL, - 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL, - 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL, - 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL, - 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL, - 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL, - 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL, - 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL, - 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL, - 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL, - 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL, - 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL, - 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL, - 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL, - 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL, - 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL, - 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL, - 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL, - 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL, - 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL, - 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL, - 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL, - 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL, - 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL, - 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL, - 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL, - 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL, - 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL, - 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL, - 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL, - 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL, - 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL, - 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL, - 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL, - 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL, - 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL, - 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL, - 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL, - 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL, - 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL, - 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL, - 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL, - 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL, - 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL, - 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL, - 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL, - 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL, - 0xbe9834edUL - }, - { - 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL, - 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL, - 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL, - 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL, - 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL, - 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL, - 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL, - 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL, - 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL, - 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL, - 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL, - 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL, - 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL, - 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL, - 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL, - 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL, - 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL, - 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL, - 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL, - 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL, - 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL, - 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL, - 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL, - 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL, - 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL, - 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL, - 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL, - 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL, - 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL, - 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL, - 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL, - 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL, - 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL, - 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL, - 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL, - 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL, - 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL, - 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL, - 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL, - 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL, - 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL, - 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL, - 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL, - 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL, - 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL, - 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL, - 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL, - 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL, - 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL, - 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL, - 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL, - 0xde0506f1UL - }, - { - 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL, - 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL, - 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL, - 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL, - 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL, - 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL, - 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL, - 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL, - 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL, - 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL, - 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL, - 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL, - 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL, - 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL, - 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL, - 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL, - 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL, - 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL, - 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL, - 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL, - 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL, - 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL, - 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL, - 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL, - 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL, - 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL, - 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL, - 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL, - 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL, - 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL, - 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL, - 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL, - 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL, - 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL, - 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL, - 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL, - 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL, - 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL, - 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL, - 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL, - 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL, - 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL, - 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL, - 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL, - 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL, - 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL, - 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL, - 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL, - 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL, - 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL, - 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL, - 0x8def022dUL - }, - { - 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL, - 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL, - 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL, - 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL, - 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL, - 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL, - 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL, - 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL, - 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL, - 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL, - 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL, - 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL, - 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL, - 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL, - 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL, - 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL, - 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL, - 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL, - 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL, - 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL, - 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL, - 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL, - 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL, - 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL, - 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL, - 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL, - 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL, - 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL, - 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL, - 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL, - 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL, - 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL, - 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL, - 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL, - 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL, - 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL, - 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL, - 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL, - 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL, - 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL, - 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL, - 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL, - 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL, - 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL, - 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL, - 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL, - 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL, - 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL, - 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL, - 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL, - 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL, - 0x72fd2493UL - }, - { - 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL, - 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL, - 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL, - 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL, - 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL, - 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL, - 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL, - 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL, - 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL, - 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL, - 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL, - 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL, - 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL, - 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL, - 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL, - 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL, - 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL, - 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL, - 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL, - 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL, - 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL, - 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL, - 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL, - 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL, - 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL, - 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL, - 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL, - 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL, - 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL, - 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL, - 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL, - 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL, - 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL, - 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL, - 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL, - 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL, - 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL, - 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL, - 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL, - 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL, - 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL, - 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL, - 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL, - 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL, - 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL, - 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL, - 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL, - 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL, - 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL, - 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL, - 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL, - 0xed3498beUL - }, - { - 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL, - 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL, - 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL, - 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL, - 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL, - 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL, - 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL, - 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL, - 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL, - 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL, - 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL, - 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL, - 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL, - 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL, - 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL, - 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL, - 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL, - 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL, - 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL, - 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL, - 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL, - 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL, - 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL, - 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL, - 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL, - 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL, - 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL, - 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL, - 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL, - 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL, - 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL, - 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL, - 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL, - 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL, - 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL, - 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL, - 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL, - 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL, - 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL, - 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL, - 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL, - 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL, - 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL, - 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL, - 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL, - 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL, - 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL, - 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL, - 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL, - 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL, - 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL, - 0xf10605deUL + }, + { + 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL, + 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL, + 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL, + 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL, + 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL, + 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL, + 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL, + 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL, + 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL, + 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL, + 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL, + 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL, + 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL, + 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL, + 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL, + 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL, + 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL, + 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL, + 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL, + 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL, + 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL, + 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL, + 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL, + 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL, + 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL, + 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL, + 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL, + 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL, + 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL, + 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL, + 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL, + 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL, + 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL, + 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL, + 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL, + 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL, + 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL, + 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL, + 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL, + 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL, + 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL, + 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL, + 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL, + 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL, + 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL, + 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL, + 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL, + 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL, + 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL, + 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL, + 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL, + 0x9324fd72UL + }, + { + 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL, + 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL, + 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL, + 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL, + 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL, + 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL, + 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL, + 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL, + 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL, + 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL, + 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL, + 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL, + 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL, + 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL, + 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL, + 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL, + 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL, + 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL, + 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL, + 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL, + 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL, + 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL, + 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL, + 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL, + 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL, + 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL, + 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL, + 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL, + 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL, + 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL, + 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL, + 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL, + 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL, + 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL, + 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL, + 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL, + 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL, + 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL, + 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL, + 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL, + 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL, + 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL, + 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL, + 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL, + 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL, + 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL, + 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL, + 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL, + 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL, + 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL, + 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL, + 0xbe9834edUL + }, + { + 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL, + 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL, + 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL, + 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL, + 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL, + 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL, + 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL, + 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL, + 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL, + 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL, + 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL, + 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL, + 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL, + 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL, + 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL, + 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL, + 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL, + 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL, + 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL, + 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL, + 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL, + 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL, + 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL, + 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL, + 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL, + 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL, + 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL, + 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL, + 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL, + 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL, + 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL, + 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL, + 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL, + 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL, + 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL, + 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL, + 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL, + 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL, + 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL, + 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL, + 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL, + 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL, + 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL, + 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL, + 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL, + 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL, + 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL, + 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL, + 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL, + 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL, + 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL, + 0xde0506f1UL + }, + { + 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL, + 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL, + 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL, + 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL, + 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL, + 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL, + 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL, + 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL, + 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL, + 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL, + 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL, + 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL, + 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL, + 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL, + 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL, + 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL, + 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL, + 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL, + 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL, + 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL, + 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL, + 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL, + 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL, + 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL, + 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL, + 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL, + 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL, + 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL, + 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL, + 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL, + 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL, + 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL, + 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL, + 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL, + 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL, + 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL, + 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL, + 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL, + 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL, + 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL, + 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL, + 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL, + 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL, + 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL, + 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL, + 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL, + 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL, + 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL, + 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL, + 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL, + 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL, + 0x8def022dUL + }, + { + 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL, + 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL, + 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL, + 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL, + 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL, + 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL, + 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL, + 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL, + 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL, + 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL, + 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL, + 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL, + 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL, + 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL, + 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL, + 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL, + 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL, + 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL, + 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL, + 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL, + 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL, + 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL, + 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL, + 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL, + 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL, + 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL, + 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL, + 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL, + 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL, + 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL, + 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL, + 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL, + 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL, + 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL, + 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL, + 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL, + 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL, + 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL, + 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL, + 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL, + 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL, + 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL, + 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL, + 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL, + 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL, + 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL, + 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL, + 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL, + 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL, + 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL, + 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL, + 0x72fd2493UL + }, + { + 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL, + 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL, + 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL, + 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL, + 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL, + 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL, + 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL, + 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL, + 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL, + 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL, + 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL, + 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL, + 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL, + 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL, + 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL, + 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL, + 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL, + 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL, + 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL, + 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL, + 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL, + 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL, + 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL, + 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL, + 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL, + 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL, + 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL, + 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL, + 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL, + 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL, + 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL, + 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL, + 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL, + 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL, + 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL, + 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL, + 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL, + 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL, + 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL, + 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL, + 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL, + 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL, + 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL, + 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL, + 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL, + 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL, + 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL, + 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL, + 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL, + 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL, + 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL, + 0xed3498beUL + }, + { + 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL, + 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL, + 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL, + 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL, + 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL, + 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL, + 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL, + 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL, + 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL, + 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL, + 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL, + 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL, + 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL, + 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL, + 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL, + 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL, + 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL, + 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL, + 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL, + 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL, + 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL, + 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL, + 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL, + 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL, + 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL, + 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL, + 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL, + 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL, + 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL, + 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL, + 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL, + 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL, + 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL, + 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL, + 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL, + 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL, + 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL, + 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL, + 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL, + 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL, + 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL, + 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL, + 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL, + 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL, + 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL, + 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL, + 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL, + 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL, + 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL, + 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL, + 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL, + 0xf10605deUL #endif - } + } }; diff --git a/extern/zlib/deflate.c b/extern/zlib/deflate.c index 06931b6..2574230 100644 --- a/extern/zlib/deflate.c +++ b/extern/zlib/deflate.c @@ -52,8 +52,8 @@ #include "deflate.h" const char deflate_copyright[] = -// " deflate 1.2.7 Copyright 1995-2012 Jean-loup Gailly and Mark Adler "; - " deflate 1.2.7.f-hanba-win64 Copyright (C) 2012-2014 Jonathan Hanba"; + // " deflate 1.2.7 Copyright 1995-2012 Jean-loup Gailly and Mark Adler "; + " deflate 1.2.7.f-hanba-win64 Copyright (C) 2012-2014 Jonathan Hanba"; /* If you use the zlib library in a product, an acknowledgment is welcome in the documentation of your product. If for some reason you cannot @@ -76,37 +76,38 @@ const char deflate_copyright[] = /* =========================================================================== * Function prototypes. */ -typedef enum { +typedef enum +{ need_more, /* block not completed, need more input or more output */ block_done, /* block flush performed */ finish_started, /* finish started, need only more output at next deflate */ finish_done /* finish done, accept no more input or output */ } block_state; -typedef block_state (*compress_func) OF((deflate_state *s, int flush)); +typedef block_state(*compress_func) OF((deflate_state* s, int flush)); /* Compression function. Returns the block state after the call. */ -local void fill_window OF((deflate_state *s)); -local block_state deflate_stored OF((deflate_state *s, int flush)); -local block_state deflate_fast OF((deflate_state *s, int flush)); +local void fill_window OF((deflate_state* s)); +local block_state deflate_stored OF((deflate_state* s, int flush)); +local block_state deflate_fast OF((deflate_state* s, int flush)); #ifndef FASTEST -local block_state deflate_slow OF((deflate_state *s, int flush)); +local block_state deflate_slow OF((deflate_state* s, int flush)); #endif -local block_state deflate_rle OF((deflate_state *s, int flush)); -local block_state deflate_huff OF((deflate_state *s, int flush)); -local void lm_init OF((deflate_state *s)); -local void putShortMSB OF((deflate_state *s, uInt b)); +local block_state deflate_rle OF((deflate_state* s, int flush)); +local block_state deflate_huff OF((deflate_state* s, int flush)); +local void lm_init OF((deflate_state* s)); +local void putShortMSB OF((deflate_state* s, uInt b)); local void flush_pending OF((z_streamp strm)); -local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); +local int read_buf OF((z_streamp strm, Bytef* buf, unsigned size)); #ifdef ASMV - void match_init OF((void)); /* asm code initialization */ - uInt longest_match OF((deflate_state *s, IPos cur_match)); +void match_init OF((void)); /* asm code initialization */ +uInt longest_match OF((deflate_state* s, IPos cur_match)); #else -local uInt longest_match OF((deflate_state *s, IPos cur_match)); +local uInt longest_match OF((deflate_state* s, IPos cur_match)); #endif #ifdef DEBUG -local void check_match OF((deflate_state *s, IPos start, IPos match, +local void check_match OF((deflate_state* s, IPos start, IPos match, int length)); #endif @@ -127,33 +128,38 @@ local void check_match OF((deflate_state *s, IPos start, IPos match, * exclude worst case performance for pathological files. Better values may be * found for specific files. */ -typedef struct config_s { - ush good_length; /* reduce lazy search above this match length */ - ush max_lazy; /* do not perform lazy search above this match length */ - ush nice_length; /* quit search above this match length */ - ush max_chain; - compress_func func; +typedef struct config_s +{ + ush good_length; /* reduce lazy search above this match length */ + ush max_lazy; /* do not perform lazy search above this match length */ + ush nice_length; /* quit search above this match length */ + ush max_chain; + compress_func func; } config; #ifdef FASTEST -local const config configuration_table[2] = { -/* good lazy nice chain */ -/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ -/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */ +local const config configuration_table[2] = +{ + /* good lazy nice chain */ + /* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ + /* 1 */ {4, 4, 8, 4, deflate_fast} +}; /* max speed, no lazy matches */ #else -local const config configuration_table[10] = { -/* good lazy nice chain */ -/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ -/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ -/* 2 */ {4, 5, 16, 8, deflate_fast}, -/* 3 */ {4, 6, 32, 32, deflate_fast}, +local const config configuration_table[10] = +{ + /* good lazy nice chain */ + /* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ + /* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ + /* 2 */ {4, 5, 16, 8, deflate_fast}, + /* 3 */ {4, 6, 32, 32, deflate_fast}, -/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ -/* 5 */ {8, 16, 32, 32, deflate_slow}, -/* 6 */ {8, 16, 128, 128, deflate_slow}, -/* 7 */ {8, 32, 128, 256, deflate_slow}, -/* 8 */ {32, 128, 258, 1024, deflate_slow}, -/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */ + /* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ + /* 5 */ {8, 16, 32, 32, deflate_slow}, + /* 6 */ {8, 16, 128, 128, deflate_slow}, + /* 7 */ {8, 32, 128, 256, deflate_slow}, + /* 8 */ {32, 128, 258, 1024, deflate_slow}, + /* 9 */ {32, 258, 258, 4096, deflate_slow} +}; /* max compression */ #endif /* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 @@ -212,13 +218,13 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ /* ========================================================================= */ #ifdef WIN32 -int ZEXPORT deflateInit_(z_streamp strm, int level, const char *version, int stream_size) +int ZEXPORT deflateInit_(z_streamp strm, int level, const char* version, int stream_size) #else int ZEXPORT deflateInit_(strm, level, version, stream_size) - z_streamp strm; - int level; - const char *version; - int stream_size; +z_streamp strm; +int level; +const char* version; +int stream_size; #endif { return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, @@ -228,37 +234,41 @@ int ZEXPORT deflateInit_(strm, level, version, stream_size) /* ========================================================================= */ #ifdef WIN32 -int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size) +int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char* version, int stream_size) #else int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, - version, stream_size) - z_streamp strm; - int level; - int method; - int windowBits; - int memLevel; - int strategy; - const char *version; - int stream_size; + version, stream_size) +z_streamp strm; +int level; +int method; +int windowBits; +int memLevel; +int strategy; +const char* version; +int stream_size; #endif { - deflate_state *s; + deflate_state* s; int wrap = 1; static const char my_version[] = ZLIB_VERSION; - ushf *overlay; + ushf* overlay; /* We overlay pending_buf and d_buf+l_buf. This works since the average * output size for (length,distance) codes is <= 24 bits. */ if (version == Z_NULL || version[0] != my_version[0] || - stream_size != sizeof(z_stream)) { + stream_size != sizeof(z_stream)) + { return Z_VERSION_ERROR; } + if (strm == Z_NULL) return Z_STREAM_ERROR; strm->msg = Z_NULL; - if (strm->zalloc == (alloc_func)0) { + + if (strm->zalloc == (alloc_func)0) + { #ifdef Z_SOLO return Z_STREAM_ERROR; #else @@ -266,38 +276,54 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, strm->opaque = (voidpf)0; #endif } + if (strm->zfree == (free_func)0) #ifdef Z_SOLO return Z_STREAM_ERROR; + #else strm->zfree = zcfree; #endif #ifdef FASTEST + if (level != 0) level = 1; + #else + if (level == Z_DEFAULT_COMPRESSION) level = 6; + #endif - if (windowBits < 0) { /* suppress zlib wrapper */ + if (windowBits < 0) /* suppress zlib wrapper */ + { wrap = 0; windowBits = -windowBits; } + #ifdef GZIP - else if (windowBits > 15) { + else if (windowBits > 15) + { wrap = 2; /* write gzip wrapper instead */ windowBits -= 16; } + #endif + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || - windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || - strategy < 0 || strategy > Z_FIXED) { + windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || + strategy < 0 || strategy > Z_FIXED) + { return Z_STREAM_ERROR; } + if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ - s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); + + s = (deflate_state*) ZALLOC(strm, 1, sizeof(deflate_state)); + if (s == Z_NULL) return Z_MEM_ERROR; - strm->state = (struct internal_state FAR *)s; + + strm->state = (struct internal_state FAR*)s; s->strm = strm; s->wrap = wrap; @@ -309,29 +335,31 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, s->hash_bits = memLevel + 7; s->hash_size = 1 << s->hash_bits; s->hash_mask = s->hash_size - 1; - s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); + s->hash_shift = ((s->hash_bits + MIN_MATCH - 1) / MIN_MATCH); - s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); - s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); - s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); + s->window = (Bytef*) ZALLOC(strm, s->w_size, 2 * sizeof(Byte)); + s->prev = (Posf*) ZALLOC(strm, s->w_size, sizeof(Pos)); + s->head = (Posf*) ZALLOC(strm, s->hash_size, sizeof(Pos)); s->high_water = 0; /* nothing written to s->window yet */ s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ - overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); - s->pending_buf = (uchf *) overlay; - s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); + overlay = (ushf*) ZALLOC(strm, s->lit_bufsize, sizeof(ush) + 2); + s->pending_buf = (uchf*) overlay; + s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush) + 2L); if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || - s->pending_buf == Z_NULL) { + s->pending_buf == Z_NULL) + { s->status = FINISH_STATE; strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); - deflateEnd (strm); + deflateEnd(strm); return Z_MEM_ERROR; } - s->d_buf = overlay + s->lit_bufsize/sizeof(ush); - s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; + + s->d_buf = overlay + s->lit_bufsize / sizeof(ush); + s->l_buf = s->pending_buf + (1 + sizeof(ush)) * s->lit_bufsize; s->level = level; s->strategy = strategy; @@ -342,40 +370,46 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, /* ========================================================================= */ #ifdef WIN32 -int ZEXPORT deflateSetDictionary (z_streamp strm, const Bytef *dictionary, uInt dictLength) +int ZEXPORT deflateSetDictionary(z_streamp strm, const Bytef* dictionary, uInt dictLength) #else -int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) - z_streamp strm; - const Bytef *dictionary; - uInt dictLength; +int ZEXPORT deflateSetDictionary(strm, dictionary, dictLength) +z_streamp strm; +const Bytef* dictionary; +uInt dictLength; #endif { - deflate_state *s; + deflate_state* s; uInt str, n; int wrap; unsigned avail; - unsigned char *next; + unsigned char* next; if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; wrap = s->wrap; + if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead) return Z_STREAM_ERROR; /* when using zlib wrappers, compute Adler-32 for provided dictionary */ if (wrap == 1) strm->adler = adler32(strm->adler, dictionary, dictLength); + s->wrap = 0; /* avoid computing Adler-32 in read_buf */ /* if dictionary would fill window, just replace the history */ - if (dictLength >= s->w_size) { - if (wrap == 0) { /* already empty otherwise */ + if (dictLength >= s->w_size) + { + if (wrap == 0) /* already empty otherwise */ + { CLEAR_HASH(s); s->strstart = 0; s->block_start = 0L; s->insert = 0; } + dictionary += dictLength - s->w_size; /* use the tail */ dictLength = s->w_size; } @@ -384,28 +418,35 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) avail = strm->avail_in; next = strm->next_in; strm->avail_in = dictLength; - strm->next_in = (Bytef *)dictionary; + strm->next_in = (Bytef*)dictionary; fill_window(s); - while (s->lookahead >= MIN_MATCH) { + + while (s->lookahead >= MIN_MATCH) + { str = s->strstart; - n = s->lookahead - (MIN_MATCH-1); - do { - UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); + n = s->lookahead - (MIN_MATCH - 1); + + do + { + UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH - 1]); #ifndef FASTEST s->prev[str & s->w_mask] = s->head[s->ins_h]; #endif s->head[s->ins_h] = (Pos)str; str++; - } while (--n); + } + while (--n); + s->strstart = str; - s->lookahead = MIN_MATCH-1; + s->lookahead = MIN_MATCH - 1; fill_window(s); } + s->strstart += s->lookahead; s->block_start = (long)s->strstart; s->insert = s->lookahead; s->lookahead = 0; - s->match_length = s->prev_length = MIN_MATCH-1; + s->match_length = s->prev_length = MIN_MATCH - 1; s->match_available = 0; strm->next_in = next; strm->avail_in = avail; @@ -415,16 +456,17 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) /* ========================================================================= */ #ifdef WIN32 -int ZEXPORT deflateResetKeep (z_streamp strm) +int ZEXPORT deflateResetKeep(z_streamp strm) #else -int ZEXPORT deflateResetKeep (strm) - z_streamp strm; +int ZEXPORT deflateResetKeep(strm) +z_streamp strm; #endif { - deflate_state *s; + deflate_state* s; if (strm == Z_NULL || strm->state == Z_NULL || - strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { + strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) + { return Z_STREAM_ERROR; } @@ -432,13 +474,15 @@ int ZEXPORT deflateResetKeep (strm) strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ strm->data_type = Z_UNKNOWN; - s = (deflate_state *)strm->state; + s = (deflate_state*)strm->state; s->pending = 0; s->pending_out = s->pending_buf; - if (s->wrap < 0) { + if (s->wrap < 0) + { s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ } + s->status = s->wrap ? INIT_STATE : BUSY_STATE; strm->adler = #ifdef GZIP @@ -454,80 +498,95 @@ int ZEXPORT deflateResetKeep (strm) /* ========================================================================= */ #ifdef WIN32 -int ZEXPORT deflateReset (z_streamp strm) +int ZEXPORT deflateReset(z_streamp strm) #else -int ZEXPORT deflateReset (strm) - z_streamp strm; +int ZEXPORT deflateReset(strm) +z_streamp strm; #endif { int ret; ret = deflateResetKeep(strm); + if (ret == Z_OK) lm_init(strm->state); + return ret; } /* ========================================================================= */ #ifdef WIN32 -int ZEXPORT deflateSetHeader (z_streamp strm, gz_headerp head) +int ZEXPORT deflateSetHeader(z_streamp strm, gz_headerp head) #else -int ZEXPORT deflateSetHeader (strm, head) - z_streamp strm; - gz_headerp head; +int ZEXPORT deflateSetHeader(strm, head) +z_streamp strm; +gz_headerp head; #endif { if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + if (strm->state->wrap != 2) return Z_STREAM_ERROR; + strm->state->gzhead = head; return Z_OK; } /* ========================================================================= */ #ifdef WIN32 -int ZEXPORT deflatePending (z_streamp strm, unsigned *pending, int *bits) +int ZEXPORT deflatePending(z_streamp strm, unsigned* pending, int* bits) #else -int ZEXPORT deflatePending (strm, pending, bits) - unsigned *pending; - int *bits; - z_streamp strm; +int ZEXPORT deflatePending(strm, pending, bits) +unsigned* pending; +int* bits; +z_streamp strm; #endif { if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + if (pending != Z_NULL) *pending = strm->state->pending; + if (bits != Z_NULL) *bits = strm->state->bi_valid; + return Z_OK; } /* ========================================================================= */ #ifdef WIN32 -int ZEXPORT deflatePrime (z_streamp strm, int bits, int value) +int ZEXPORT deflatePrime(z_streamp strm, int bits, int value) #else -int ZEXPORT deflatePrime (strm, bits, value) - z_streamp strm; - int bits; - int value; +int ZEXPORT deflatePrime(strm, bits, value) +z_streamp strm; +int bits; +int value; #endif { - deflate_state *s; + deflate_state* s; int put; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; - if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3)) + + if ((Bytef*)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3)) return Z_BUF_ERROR; - do { + + do + { put = Buf_size - s->bi_valid; + if (put > bits) put = bits; + s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid); s->bi_valid += put; _tr_flush_bits(s); value >>= put; bits -= put; - } while (bits); + } + while (bits); + return Z_OK; } @@ -536,40 +595,52 @@ int ZEXPORT deflatePrime (strm, bits, value) int ZEXPORT deflateParams(z_streamp strm, int level, int strategy) #else int ZEXPORT deflateParams(strm, level, strategy) - z_streamp strm; - int level; - int strategy; +z_streamp strm; +int level; +int strategy; #endif { - deflate_state *s; + deflate_state* s; compress_func func; int err = Z_OK; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; #ifdef FASTEST + if (level != 0) level = 1; + #else + if (level == Z_DEFAULT_COMPRESSION) level = 6; + #endif - if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { + + if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) + { return Z_STREAM_ERROR; } + func = configuration_table[s->level].func; if ((strategy != s->strategy || func != configuration_table[level].func) && - strm->total_in != 0) { + strm->total_in != 0) + { /* Flush the last buffer: */ err = deflate(strm, Z_BLOCK); } - if (s->level != level) { + + if (s->level != level) + { s->level = level; s->max_lazy_match = configuration_table[level].max_lazy; s->good_match = configuration_table[level].good_length; s->nice_match = configuration_table[level].nice_length; s->max_chain_length = configuration_table[level].max_chain; } + s->strategy = strategy; return err; } @@ -579,16 +650,17 @@ int ZEXPORT deflateParams(strm, level, strategy) int ZEXPORT deflateTune(z_streamp strm, int good_length, int max_lazy, int nice_length, int max_chain) #else int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) - z_streamp strm; - int good_length; - int max_lazy; - int nice_length; - int max_chain; +z_streamp strm; +int good_length; +int max_lazy; +int nice_length; +int max_chain; #endif { - deflate_state *s; + deflate_state* s; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; s->good_match = good_length; s->max_lazy_match = max_lazy; @@ -618,13 +690,13 @@ int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen) #else uLong ZEXPORT deflateBound(strm, sourceLen) - z_streamp strm; - uLong sourceLen; +z_streamp strm; +uLong sourceLen; #endif { - deflate_state *s; + deflate_state* s; uLong complen, wraplen; - Bytef *str; + Bytef* str; /* conservative upper bound for compressed data */ complen = sourceLen + @@ -636,34 +708,51 @@ uLong ZEXPORT deflateBound(strm, sourceLen) /* compute wrapper length */ s = strm->state; - switch (s->wrap) { - case 0: /* raw deflate */ - wraplen = 0; - break; - case 1: /* zlib wrapper */ - wraplen = 6 + (s->strstart ? 4 : 0); - break; - case 2: /* gzip wrapper */ - wraplen = 18; - if (s->gzhead != Z_NULL) { /* user-supplied gzip header */ - if (s->gzhead->extra != Z_NULL) - wraplen += 2 + s->gzhead->extra_len; - str = s->gzhead->name; - if (str != Z_NULL) - do { - wraplen++; - } while (*str++); - str = s->gzhead->comment; - if (str != Z_NULL) - do { - wraplen++; - } while (*str++); - if (s->gzhead->hcrc) - wraplen += 2; - } - break; - default: /* for compiler happiness */ - wraplen = 6; + + switch (s->wrap) + { + case 0: /* raw deflate */ + wraplen = 0; + break; + + case 1: /* zlib wrapper */ + wraplen = 6 + (s->strstart ? 4 : 0); + break; + + case 2: /* gzip wrapper */ + wraplen = 18; + + if (s->gzhead != Z_NULL) /* user-supplied gzip header */ + { + if (s->gzhead->extra != Z_NULL) + wraplen += 2 + s->gzhead->extra_len; + + str = s->gzhead->name; + + if (str != Z_NULL) + do + { + wraplen++; + } + while (*str++); + + str = s->gzhead->comment; + + if (str != Z_NULL) + do + { + wraplen++; + } + while (*str++); + + if (s->gzhead->hcrc) + wraplen += 2; + } + + break; + + default: /* for compiler happiness */ + wraplen = 6; } /* if not default parameters, return conservative bound */ @@ -681,11 +770,11 @@ uLong ZEXPORT deflateBound(strm, sourceLen) * pending_buf. */ #ifdef WIN32 -local void putShortMSB (deflate_state *s, uInt b) +local void putShortMSB(deflate_state* s, uInt b) #else -local void putShortMSB (s, b) - deflate_state *s; - uInt b; +local void putShortMSB(s, b) +deflate_state* s; +uInt b; #endif { put_byte(s, (Byte)(b >> 8)); @@ -702,15 +791,17 @@ local void putShortMSB (s, b) local void flush_pending(z_streamp strm) #else local void flush_pending(strm) - z_streamp strm; +z_streamp strm; #endif { unsigned len; - deflate_state *s = strm->state; + deflate_state* s = strm->state; _tr_flush_bits(s); len = s->pending; + if (len > strm->avail_out) len = strm->avail_out; + if (len == 0) return; zmemcpy(strm->next_out, s->pending_out, len); @@ -719,34 +810,40 @@ local void flush_pending(strm) strm->total_out += len; strm->avail_out -= len; s->pending -= len; - if (s->pending == 0) { + + if (s->pending == 0) + { s->pending_out = s->pending_buf; } } /* ========================================================================= */ #ifdef WIN32 -int ZEXPORT deflate (z_streamp strm, int flush) +int ZEXPORT deflate(z_streamp strm, int flush) #else -int ZEXPORT deflate (strm, flush) - z_streamp strm; - int flush; +int ZEXPORT deflate(strm, flush) +z_streamp strm; +int flush; #endif { int old_flush; /* value of flush param for previous deflate call */ - deflate_state *s; + deflate_state* s; if (strm == Z_NULL || strm->state == Z_NULL || - flush > Z_BLOCK || flush < 0) { + flush > Z_BLOCK || flush < 0) + { return Z_STREAM_ERROR; } + s = strm->state; if (strm->next_out == Z_NULL || - (strm->next_in == Z_NULL && strm->avail_in != 0) || - (s->status == FINISH_STATE && flush != Z_FINISH)) { + (strm->next_in == Z_NULL && strm->avail_in != 0) || + (s->status == FINISH_STATE && flush != Z_FINISH)) + { ERR_RETURN(strm, Z_STREAM_ERROR); } + if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); s->strm = strm; /* just in case */ @@ -754,47 +851,57 @@ int ZEXPORT deflate (strm, flush) s->last_flush = flush; /* Write the header */ - if (s->status == INIT_STATE) { + if (s->status == INIT_STATE) + { #ifdef GZIP - if (s->wrap == 2) { + + if (s->wrap == 2) + { strm->adler = crc32(0L, Z_NULL, 0); put_byte(s, 31); put_byte(s, 139); put_byte(s, 8); - if (s->gzhead == Z_NULL) { + + if (s->gzhead == Z_NULL) + { put_byte(s, 0); put_byte(s, 0); put_byte(s, 0); put_byte(s, 0); put_byte(s, 0); put_byte(s, s->level == 9 ? 2 : - (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? - 4 : 0)); + (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? + 4 : 0)); put_byte(s, OS_CODE); s->status = BUSY_STATE; } - else { + else + { put_byte(s, (s->gzhead->text ? 1 : 0) + - (s->gzhead->hcrc ? 2 : 0) + - (s->gzhead->extra == Z_NULL ? 0 : 4) + - (s->gzhead->name == Z_NULL ? 0 : 8) + - (s->gzhead->comment == Z_NULL ? 0 : 16) + (s->gzhead->hcrc ? 2 : 0) + + (s->gzhead->extra == Z_NULL ? 0 : 4) + + (s->gzhead->name == Z_NULL ? 0 : 8) + + (s->gzhead->comment == Z_NULL ? 0 : 16) ); put_byte(s, (Byte)(s->gzhead->time & 0xff)); put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); put_byte(s, s->level == 9 ? 2 : - (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? - 4 : 0)); + (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? + 4 : 0)); put_byte(s, s->gzhead->os & 0xff); - if (s->gzhead->extra != Z_NULL) { + + if (s->gzhead->extra != Z_NULL) + { put_byte(s, s->gzhead->extra_len & 0xff); put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); } + if (s->gzhead->hcrc) strm->adler = crc32(strm->adler, s->pending_buf, s->pending); + s->gzindex = 0; s->status = EXTRA_STATE; } @@ -802,7 +909,7 @@ int ZEXPORT deflate (strm, flush) else #endif { - uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; + uInt header = (Z_DEFLATED + ((s->w_bits - 8) << 4)) << 8; uInt level_flags; if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) @@ -813,43 +920,60 @@ int ZEXPORT deflate (strm, flush) level_flags = 2; else level_flags = 3; + header |= (level_flags << 6); + if (s->strstart != 0) header |= PRESET_DICT; + header += 31 - (header % 31); s->status = BUSY_STATE; putShortMSB(s, header); /* Save the adler32 of the preset dictionary: */ - if (s->strstart != 0) { + if (s->strstart != 0) + { putShortMSB(s, (uInt)(strm->adler >> 16)); putShortMSB(s, (uInt)(strm->adler & 0xffff)); } + strm->adler = adler32(0L, Z_NULL, 0); } } + #ifdef GZIP - if (s->status == EXTRA_STATE) { - if (s->gzhead->extra != Z_NULL) { + + if (s->status == EXTRA_STATE) + { + if (s->gzhead->extra != Z_NULL) + { uInt beg = s->pending; /* start of bytes to update crc */ - while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { - if (s->pending == s->pending_buf_size) { + while (s->gzindex < (s->gzhead->extra_len & 0xffff)) + { + if (s->pending == s->pending_buf_size) + { if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); + flush_pending(strm); beg = s->pending; + if (s->pending == s->pending_buf_size) break; } + put_byte(s, s->gzhead->extra[s->gzindex]); s->gzindex++; } + if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); - if (s->gzindex == s->gzhead->extra_len) { + + if (s->gzindex == s->gzhead->extra_len) + { s->gzindex = 0; s->status = NAME_STATE; } @@ -857,30 +981,43 @@ int ZEXPORT deflate (strm, flush) else s->status = NAME_STATE; } - if (s->status == NAME_STATE) { - if (s->gzhead->name != Z_NULL) { + + if (s->status == NAME_STATE) + { + if (s->gzhead->name != Z_NULL) + { uInt beg = s->pending; /* start of bytes to update crc */ Bytef val; - do { - if (s->pending == s->pending_buf_size) { + do + { + if (s->pending == s->pending_buf_size) + { if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); + flush_pending(strm); beg = s->pending; - if (s->pending == s->pending_buf_size) { + + if (s->pending == s->pending_buf_size) + { val = 1; break; } } + val = s->gzhead->name[s->gzindex++]; put_byte(s, val); - } while (val != 0); + } + while (val != 0); + if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); - if (val == 0) { + + if (val == 0) + { s->gzindex = 0; s->status = COMMENT_STATE; } @@ -888,40 +1025,57 @@ int ZEXPORT deflate (strm, flush) else s->status = COMMENT_STATE; } - if (s->status == COMMENT_STATE) { - if (s->gzhead->comment != Z_NULL) { + + if (s->status == COMMENT_STATE) + { + if (s->gzhead->comment != Z_NULL) + { uInt beg = s->pending; /* start of bytes to update crc */ Bytef val; - do { - if (s->pending == s->pending_buf_size) { + do + { + if (s->pending == s->pending_buf_size) + { if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); + flush_pending(strm); beg = s->pending; - if (s->pending == s->pending_buf_size) { + + if (s->pending == s->pending_buf_size) + { val = 1; break; } } + val = s->gzhead->comment[s->gzindex++]; put_byte(s, val); - } while (val != 0); + } + while (val != 0); + if (s->gzhead->hcrc && s->pending > beg) strm->adler = crc32(strm->adler, s->pending_buf + beg, s->pending - beg); + if (val == 0) s->status = HCRC_STATE; } else s->status = HCRC_STATE; } - if (s->status == HCRC_STATE) { - if (s->gzhead->hcrc) { + + if (s->status == HCRC_STATE) + { + if (s->gzhead->hcrc) + { if (s->pending + 2 > s->pending_buf_size) flush_pending(strm); - if (s->pending + 2 <= s->pending_buf_size) { + + if (s->pending + 2 <= s->pending_buf_size) + { put_byte(s, (Byte)(strm->adler & 0xff)); put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); strm->adler = crc32(0L, Z_NULL, 0); @@ -931,12 +1085,16 @@ int ZEXPORT deflate (strm, flush) else s->status = BUSY_STATE; } + #endif /* Flush as much pending output as possible */ - if (s->pending != 0) { + if (s->pending != 0) + { flush_pending(strm); - if (strm->avail_out == 0) { + + if (strm->avail_out == 0) + { /* Since avail_out is 0, deflate will be called again with * more output space, but possibly with both pending and * avail_in equal to zero. There won't be anything to do, @@ -947,37 +1105,46 @@ int ZEXPORT deflate (strm, flush) return Z_OK; } - /* Make sure there is something to do and avoid duplicate consecutive - * flushes. For repeated and useless calls with Z_FINISH, we keep - * returning Z_STREAM_END instead of Z_BUF_ERROR. - */ - } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) && - flush != Z_FINISH) { + /* Make sure there is something to do and avoid duplicate consecutive + * flushes. For repeated and useless calls with Z_FINISH, we keep + * returning Z_STREAM_END instead of Z_BUF_ERROR. + */ + } + else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) && + flush != Z_FINISH) + { ERR_RETURN(strm, Z_BUF_ERROR); } /* User must not provide more input after the first FINISH: */ - if (s->status == FINISH_STATE && strm->avail_in != 0) { + if (s->status == FINISH_STATE && strm->avail_in != 0) + { ERR_RETURN(strm, Z_BUF_ERROR); } /* Start a new block or continue the current one. */ if (strm->avail_in != 0 || s->lookahead != 0 || - (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { + (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) + { block_state bstate; bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : - (s->strategy == Z_RLE ? deflate_rle(s, flush) : - (*(configuration_table[s->level].func))(s, flush)); + (s->strategy == Z_RLE ? deflate_rle(s, flush) : + (*(configuration_table[s->level].func))(s, flush)); - if (bstate == finish_started || bstate == finish_done) { + if (bstate == finish_started || bstate == finish_done) + { s->status = FINISH_STATE; } - if (bstate == need_more || bstate == finish_started) { - if (strm->avail_out == 0) { + + if (bstate == need_more || bstate == finish_started) + { + if (strm->avail_out == 0) + { s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ } + return Z_OK; /* If flush != Z_NO_FLUSH && avail_out == 0, the next call * of deflate should use the same flush parameter to make sure @@ -987,38 +1154,54 @@ int ZEXPORT deflate (strm, flush) * one empty block. */ } - if (bstate == block_done) { - if (flush == Z_PARTIAL_FLUSH) { + + if (bstate == block_done) + { + if (flush == Z_PARTIAL_FLUSH) + { _tr_align(s); - } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ + } + else if (flush != Z_BLOCK) /* FULL_FLUSH or SYNC_FLUSH */ + { _tr_stored_block(s, (char*)0, 0L, 0); + /* For a full flush, this empty block will be recognized * as a special marker by inflate_sync(). */ - if (flush == Z_FULL_FLUSH) { + if (flush == Z_FULL_FLUSH) + { CLEAR_HASH(s); /* forget history */ - if (s->lookahead == 0) { + + if (s->lookahead == 0) + { s->strstart = 0; s->block_start = 0L; s->insert = 0; } } } + flush_pending(strm); - if (strm->avail_out == 0) { - s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ - return Z_OK; + + if (strm->avail_out == 0) + { + s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ + return Z_OK; } } } + Assert(strm->avail_out > 0, "bug2"); if (flush != Z_FINISH) return Z_OK; + if (s->wrap <= 0) return Z_STREAM_END; /* Write the trailer */ #ifdef GZIP - if (s->wrap == 2) { + + if (s->wrap == 2) + { put_byte(s, (Byte)(strm->adler & 0xff)); put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); @@ -1034,20 +1217,23 @@ int ZEXPORT deflate (strm, flush) putShortMSB(s, (uInt)(strm->adler >> 16)); putShortMSB(s, (uInt)(strm->adler & 0xffff)); } + flush_pending(strm); + /* If avail_out is zero, the application will call deflate again * to flush the rest. */ if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ + return s->pending != 0 ? Z_OK : Z_STREAM_END; } /* ========================================================================= */ #ifdef WIN32 -int ZEXPORT deflateEnd (z_streamp strm) +int ZEXPORT deflateEnd(z_streamp strm) #else -int ZEXPORT deflateEnd (strm) - z_streamp strm; +int ZEXPORT deflateEnd(strm) +z_streamp strm; #endif { int status; @@ -1055,14 +1241,16 @@ int ZEXPORT deflateEnd (strm) if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; status = strm->state->status; + if (status != INIT_STATE && - status != EXTRA_STATE && - status != NAME_STATE && - status != COMMENT_STATE && - status != HCRC_STATE && - status != BUSY_STATE && - status != FINISH_STATE) { - return Z_STREAM_ERROR; + status != EXTRA_STATE && + status != NAME_STATE && + status != COMMENT_STATE && + status != HCRC_STATE && + status != BUSY_STATE && + status != FINISH_STATE) + { + return Z_STREAM_ERROR; } /* Deallocate in reverse order of allocations: */ @@ -1083,22 +1271,23 @@ int ZEXPORT deflateEnd (strm) * doesn't have enough memory anyway to duplicate compression states). */ #ifdef WIN32 -int ZEXPORT deflateCopy (z_streamp dest, z_streamp source) +int ZEXPORT deflateCopy(z_streamp dest, z_streamp source) #else -int ZEXPORT deflateCopy (dest, source) - z_streamp dest; - z_streamp source; +int ZEXPORT deflateCopy(dest, source) +z_streamp dest; +z_streamp source; #endif { #ifdef MAXSEG_64K return Z_STREAM_ERROR; #else - deflate_state *ds; - deflate_state *ss; - ushf *overlay; + deflate_state* ds; + deflate_state* ss; + ushf* overlay; - if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { + if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) + { return Z_STREAM_ERROR; } @@ -1106,23 +1295,27 @@ int ZEXPORT deflateCopy (dest, source) zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); - ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); + ds = (deflate_state*) ZALLOC(dest, 1, sizeof(deflate_state)); + if (ds == Z_NULL) return Z_MEM_ERROR; - dest->state = (struct internal_state FAR *) ds; + + dest->state = (struct internal_state FAR*) ds; zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state)); ds->strm = dest; - ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); - ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); - ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); - overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); - ds->pending_buf = (uchf *) overlay; + ds->window = (Bytef*) ZALLOC(dest, ds->w_size, 2 * sizeof(Byte)); + ds->prev = (Posf*) ZALLOC(dest, ds->w_size, sizeof(Pos)); + ds->head = (Posf*) ZALLOC(dest, ds->hash_size, sizeof(Pos)); + overlay = (ushf*) ZALLOC(dest, ds->lit_bufsize, sizeof(ush) + 2); + ds->pending_buf = (uchf*) overlay; if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || - ds->pending_buf == Z_NULL) { - deflateEnd (dest); + ds->pending_buf == Z_NULL) + { + deflateEnd(dest); return Z_MEM_ERROR; } + /* following zmemcpy do not work for 16-bit MSDOS */ zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos)); @@ -1130,8 +1323,8 @@ int ZEXPORT deflateCopy (dest, source) zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); - ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); - ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; + ds->d_buf = overlay + ds->lit_bufsize / sizeof(ush); + ds->l_buf = ds->pending_buf + (1 + sizeof(ush)) * ds->lit_bufsize; ds->l_desc.dyn_tree = ds->dyn_ltree; ds->d_desc.dyn_tree = ds->dyn_dtree; @@ -1149,29 +1342,35 @@ int ZEXPORT deflateCopy (dest, source) * (See also flush_pending()). */ #ifdef WIN32 -local int read_buf(z_streamp strm, Bytef *buf, unsigned size) +local int read_buf(z_streamp strm, Bytef* buf, unsigned size) #else local int read_buf(strm, buf, size) - z_streamp strm; - Bytef *buf; - unsigned size; +z_streamp strm; +Bytef* buf; +unsigned size; #endif { unsigned len = strm->avail_in; if (len > size) len = size; + if (len == 0) return 0; strm->avail_in -= len; zmemcpy(buf, strm->next_in, len); - if (strm->state->wrap == 1) { + + if (strm->state->wrap == 1) + { strm->adler = adler32(strm->adler, buf, len); } + #ifdef GZIP - else if (strm->state->wrap == 2) { + else if (strm->state->wrap == 2) + { strm->adler = crc32(strm->adler, buf, len); } + #endif strm->next_in += len; strm->total_in += len; @@ -1183,13 +1382,13 @@ local int read_buf(strm, buf, size) * Initialize the "longest match" routines for a new zlib stream */ #ifdef WIN32 -local void lm_init (deflate_state *s) +local void lm_init(deflate_state* s) #else -local void lm_init (s) - deflate_state *s; +local void lm_init(s) +deflate_state* s; #endif { - s->window_size = (ulg)2L*s->w_size; + s->window_size = (ulg)2L * s->w_size; CLEAR_HASH(s); @@ -1204,7 +1403,7 @@ local void lm_init (s) s->block_start = 0L; s->lookahead = 0; s->insert = 0; - s->match_length = s->prev_length = MIN_MATCH-1; + s->match_length = s->prev_length = MIN_MATCH - 1; s->match_available = 0; s->ins_h = 0; #ifndef FASTEST @@ -1229,37 +1428,37 @@ local void lm_init (s) * match.S. The code will be functionally equivalent. */ #ifdef WIN32 -local uInt longest_match(deflate_state *s, IPos cur_match) +local uInt longest_match(deflate_state* s, IPos cur_match) #else local uInt longest_match(s, cur_match) - deflate_state *s; - IPos cur_match; /* current match */ +deflate_state* s; +IPos cur_match; /* current match */ #endif { unsigned chain_length = s->max_chain_length;/* max hash chain length */ - register Bytef *scan = s->window + s->strstart; /* current string */ - register Bytef *match; /* matched string */ + register Bytef* scan = s->window + s->strstart; /* current string */ + register Bytef* match; /* matched string */ register int len; /* length of current match */ int best_len = s->prev_length; /* best match length so far */ int nice_match = s->nice_match; /* stop if match long enough */ IPos limit = s->strstart > (IPos)MAX_DIST(s) ? - s->strstart - (IPos)MAX_DIST(s) : NIL; + s->strstart - (IPos)MAX_DIST(s) : NIL; /* Stop when cur_match becomes <= limit. To simplify the code, * we prevent matches with the string of window index 0. */ - Posf *prev = s->prev; + Posf* prev = s->prev; uInt wmask = s->w_mask; #ifdef UNALIGNED_OK /* Compare two bytes at a time. Note: this is not always beneficial. * Try with and without -DUNALIGNED_OK to check. */ - register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; + register Bytef* strend = s->window + s->strstart + MAX_MATCH - 1; register ush scan_start = *(ushf*)scan; - register ush scan_end = *(ushf*)(scan+best_len-1); + register ush scan_end = *(ushf*)(scan + best_len - 1); #else - register Bytef *strend = s->window + s->strstart + MAX_MATCH; - register Byte scan_end1 = scan[best_len-1]; + register Bytef* strend = s->window + s->strstart + MAX_MATCH; + register Byte scan_end1 = scan[best_len - 1]; register Byte scan_end = scan[best_len]; #endif @@ -1269,17 +1468,20 @@ local uInt longest_match(s, cur_match) Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); /* Do not waste too much time if we already have a good match: */ - if (s->prev_length >= s->good_match) { + if (s->prev_length >= s->good_match) + { chain_length >>= 2; } + /* Do not look for matches beyond the end of the input. This is necessary * to make deflate deterministic. */ if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; - Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, "need lookahead"); - do { + do + { Assert(cur_match < s->strstart, "no future"); match = s->window + cur_match; @@ -1292,11 +1494,12 @@ local uInt longest_match(s, cur_match) * the output of deflate is not affected by the uninitialized values. */ #if (defined(UNALIGNED_OK) && MAX_MATCH == 258) + /* This code assumes sizeof(unsigned short) == 2. Do not use * UNALIGNED_OK if your compiler uses a different size. */ - if (*(ushf*)(match+best_len-1) != scan_end || - *(ushf*)match != scan_start) continue; + if (*(ushf*)(match + best_len - 1) != scan_end || + *(ushf*)match != scan_start) continue; /* It is not necessary to compare scan[2] and match[2] since they are * always equal when the other bytes match, given that the hash keys @@ -1309,27 +1512,32 @@ local uInt longest_match(s, cur_match) */ Assert(scan[2] == match[2], "scan[2]?"); scan++, match++; - do { - } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - scan < strend); + + do + { + } + while (*(ushf*)(scan += 2) == *(ushf*)(match += 2) && + *(ushf*)(scan += 2) == *(ushf*)(match += 2) && + *(ushf*)(scan += 2) == *(ushf*)(match += 2) && + *(ushf*)(scan += 2) == *(ushf*)(match += 2) && + scan < strend); + /* The funny "do {}" generates better code on most compilers */ /* Here, scan <= window+strstart+257 */ - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + Assert(scan <= s->window + (unsigned)(s->window_size - 1), "wild scan"); + if (*scan == *match) scan++; - len = (MAX_MATCH - 1) - (int)(strend-scan); - scan = strend - (MAX_MATCH-1); + len = (MAX_MATCH - 1) - (int)(strend - scan); + scan = strend - (MAX_MATCH - 1); #else /* UNALIGNED_OK */ if (match[best_len] != scan_end || - match[best_len-1] != scan_end1 || - *match != *scan || - *++match != scan[1]) continue; + match[best_len - 1] != scan_end1 || + *match != *scan || + *++match != scan[1]) continue; /* The check at best_len-1 can be removed because it will be made * again later. (This heuristic is not always a win.) @@ -1343,35 +1551,42 @@ local uInt longest_match(s, cur_match) /* We check for insufficient lookahead only every 8th comparison; * the 256th check will be made at strstart+258. */ - do { - } while (*++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - scan < strend); + do + { + } + while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + Assert(scan <= s->window + (unsigned)(s->window_size - 1), "wild scan"); len = MAX_MATCH - (int)(strend - scan); scan = strend - MAX_MATCH; #endif /* UNALIGNED_OK */ - if (len > best_len) { + if (len > best_len) + { s->match_start = cur_match; best_len = len; + if (len >= nice_match) break; + #ifdef UNALIGNED_OK - scan_end = *(ushf*)(scan+best_len-1); + scan_end = *(ushf*)(scan + best_len - 1); #else - scan_end1 = scan[best_len-1]; + scan_end1 = scan[best_len - 1]; scan_end = scan[best_len]; #endif } - } while ((cur_match = prev[cur_match & wmask]) > limit - && --chain_length != 0); + } + while ((cur_match = prev[cur_match & wmask]) > limit + && --chain_length != 0); if ((uInt)best_len <= s->lookahead) return (uInt)best_len; + return s->lookahead; } #endif /* ASMV */ @@ -1382,24 +1597,24 @@ local uInt longest_match(s, cur_match) * Optimized version for FASTEST only */ #ifdef WIN32 -local uInt longest_match(deflate_state *s, IPos cur_match) +local uInt longest_match(deflate_state* s, IPos cur_match) #else local uInt longest_match(s, cur_match) - deflate_state *s; - IPos cur_match; /* current match */ +deflate_state* s; +IPos cur_match; /* current match */ #endif { - register Bytef *scan = s->window + s->strstart; /* current string */ - register Bytef *match; /* matched string */ + register Bytef* scan = s->window + s->strstart; /* current string */ + register Bytef* match; /* matched string */ register int len; /* length of current match */ - register Bytef *strend = s->window + s->strstart + MAX_MATCH; + register Bytef* strend = s->window + s->strstart + MAX_MATCH; /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. * It is easy to get rid of this optimization if necessary. */ Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); - Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, "need lookahead"); Assert(cur_match < s->strstart, "no future"); @@ -1407,7 +1622,7 @@ local uInt longest_match(s, cur_match) /* Return failure if the match length is less than 2: */ - if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; + if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH - 1; /* The check at best_len-1 can be removed because it will be made * again later. (This heuristic is not always a win.) @@ -1421,14 +1636,16 @@ local uInt longest_match(s, cur_match) /* We check for insufficient lookahead only every 8th comparison; * the 256th check will be made at strstart+258. */ - do { - } while (*++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - scan < strend); + do + { + } + while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + Assert(scan <= s->window + (unsigned)(s->window_size - 1), "wild scan"); len = MAX_MATCH - (int)(strend - scan); @@ -1445,27 +1662,36 @@ local uInt longest_match(s, cur_match) * Check that the match at match_start is indeed a match. */ #ifdef WIN32 -local void check_match(deflate_state *s, IPos start, IPos match, int length) +local void check_match(deflate_state* s, IPos start, IPos match, int length) #else local void check_match(s, start, match, length) - deflate_state *s; - IPos start, match; - int length; +deflate_state* s; +IPos start, match; +int length; #endif { /* check that the match is indeed a match */ if (zmemcmp(s->window + match, - s->window + start, length) != EQUAL) { + s->window + start, length) != EQUAL) + { fprintf(stderr, " start %u, match %u, length %d\n", start, match, length); - do { + + do + { fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); - } while (--length != 0); + } + while (--length != 0); + z_error("invalid match"); } - if (z_verbose > 1) { - fprintf(stderr,"\\[%d,%d]", start-match, length); - do { putc(s->window[start++], stderr); } while (--length != 0); + + if (z_verbose > 1) + { + fprintf(stderr, "\\[%d,%d]", start - match, length); + + do { putc(s->window[start++], stderr); } + while (--length != 0); } } #else @@ -1483,30 +1709,36 @@ local void check_match(s, start, match, length) * option -- not supported here). */ #ifdef WIN32 -local void fill_window(deflate_state *s) +local void fill_window(deflate_state* s) #else local void fill_window(s) - deflate_state *s; +deflate_state* s; #endif { register unsigned n, m; - register Posf *p; + register Posf* p; unsigned more; /* Amount of free space at the end of the window. */ uInt wsize = s->w_size; uch int_16_bit; Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); - do { - more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); + do + { + more = (unsigned)(s->window_size - (ulg)s->lookahead - (ulg)s->strstart); /* Deal with !@#$% 64K limit: */ - int_16_bit = sizeof (int) <= 2 ? 1 : 0; - if (int_16_bit) { - if (more == 0 && s->strstart == 0 && s->lookahead == 0) { + int_16_bit = sizeof(int) <= 2 ? 1 : 0; + + if (int_16_bit) + { + if (more == 0 && s->strstart == 0 && s->lookahead == 0) + { more = wsize; - } else if (more == (unsigned)(-1)) { + } + else if (more == (unsigned)(-1)) + { /* Very unlikely, but possible on 16 bit machine if * strstart == 0 && lookahead == 1 (input done a byte at time) */ @@ -1517,9 +1749,10 @@ local void fill_window(s) /* If the window is almost full and there is insufficient lookahead, * move the upper half to the lower one to make room in the upper half. */ - if (s->strstart >= wsize+MAX_DIST(s)) { + if (s->strstart >= wsize + MAX_DIST(s)) + { - zmemcpy(s->window, s->window+wsize, (unsigned)wsize); + zmemcpy(s->window, s->window + wsize, (unsigned)wsize); s->match_start -= wsize; s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ s->block_start -= (long) wsize; @@ -1532,24 +1765,32 @@ local void fill_window(s) */ n = s->hash_size; p = &s->head[n]; - do { + + do + { m = *--p; - *p = (Pos)(m >= wsize ? m-wsize : NIL); - } while (--n); + *p = (Pos)(m >= wsize ? m - wsize : NIL); + } + while (--n); n = wsize; #ifndef FASTEST p = &s->prev[n]; - do { + + do + { m = *--p; - *p = (Pos)(m >= wsize ? m-wsize : NIL); + *p = (Pos)(m >= wsize ? m - wsize : NIL); /* If n is not on any hash chain, prev[n] is garbage but * its value will never be used. */ - } while (--n); + } + while (--n); + #endif more += wsize; } + if (s->strm->avail_in == 0) break; /* If there was no sliding: @@ -1569,30 +1810,36 @@ local void fill_window(s) s->lookahead += n; /* Initialize the hash value now that we have some input: */ - if (s->lookahead + s->insert >= MIN_MATCH) { + if (s->lookahead + s->insert >= MIN_MATCH) + { uInt str = s->strstart - s->insert; s->ins_h = s->window[str]; UPDATE_HASH(s, s->ins_h, s->window[str + 1]); #if MIN_MATCH != 3 - Call UPDATE_HASH() MIN_MATCH-3 more times + Call UPDATE_HASH() MIN_MATCH - 3 more times #endif - while (s->insert) { - UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); + + while (s->insert) + { + UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH - 1]); #ifndef FASTEST s->prev[str & s->w_mask] = s->head[s->ins_h]; #endif s->head[s->ins_h] = (Pos)str; str++; s->insert--; + if (s->lookahead + s->insert < MIN_MATCH) break; } } + /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, * but this is not important since only literal bytes will be emitted. */ - } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); + } + while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); /* If the WIN_INIT bytes after the end of the current data have never been * written, then zero those bytes in order to avoid memory check reports of @@ -1601,28 +1848,35 @@ local void fill_window(s) * time through here. WIN_INIT is set to MAX_MATCH since the longest match * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. */ - if (s->high_water < s->window_size) { + if (s->high_water < s->window_size) + { ulg curr = s->strstart + (ulg)(s->lookahead); ulg init; - if (s->high_water < curr) { + if (s->high_water < curr) + { /* Previous high water mark below current data -- zero WIN_INIT * bytes or up to end of window, whichever is less. */ init = s->window_size - curr; + if (init > WIN_INIT) init = WIN_INIT; + zmemzero(s->window + curr, (unsigned)init); s->high_water = curr + init; } - else if (s->high_water < (ulg)curr + WIN_INIT) { + else if (s->high_water < (ulg)curr + WIN_INIT) + { /* High water mark at or above current data, but below current data * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up * to end of window, whichever is less. */ init = (ulg)curr + WIN_INIT - s->high_water; + if (init > s->window_size - s->high_water) init = s->window_size - s->high_water; + zmemzero(s->window + s->high_water, (unsigned)init); s->high_water += init; } @@ -1663,11 +1917,11 @@ local void fill_window(s) * window to pending_buf. */ #ifdef WIN32 -local block_state deflate_stored(deflate_state *s, int flush) +local block_state deflate_stored(deflate_state* s, int flush) #else local block_state deflate_stored(s, flush) - deflate_state *s; - int flush; +deflate_state* s; +int flush; #endif { /* Stored blocks are limited to 0xffff bytes, pending_buf is limited @@ -1676,23 +1930,28 @@ local block_state deflate_stored(s, flush) ulg max_block_size = 0xffff; ulg max_start; - if (max_block_size > s->pending_buf_size - 5) { + if (max_block_size > s->pending_buf_size - 5) + { max_block_size = s->pending_buf_size - 5; } /* Copy as much as possible from input to output: */ - for (;;) { + for (;;) + { /* Fill the window as much as possible: */ - if (s->lookahead <= 1) { + if (s->lookahead <= 1) + { - Assert(s->strstart < s->w_size+MAX_DIST(s) || + Assert(s->strstart < s->w_size + MAX_DIST(s) || s->block_start >= (long)s->w_size, "slide too late"); fill_window(s); + if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; if (s->lookahead == 0) break; /* flush the current block */ } + Assert(s->block_start >= 0L, "block gone"); s->strstart += s->lookahead; @@ -1700,26 +1959,35 @@ local block_state deflate_stored(s, flush) /* Emit a stored block if pending_buf will be full: */ max_start = s->block_start + max_block_size; - if (s->strstart == 0 || (ulg)s->strstart >= max_start) { + + if (s->strstart == 0 || (ulg)s->strstart >= max_start) + { /* strstart == 0 is possible when wraparound on 16-bit machine */ s->lookahead = (uInt)(s->strstart - max_start); s->strstart = (uInt)max_start; FLUSH_BLOCK(s, 0); } + /* Flush if we may have to slide, otherwise block_start may become * negative and the data will be gone: */ - if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { + if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) + { FLUSH_BLOCK(s, 0); } } + s->insert = 0; - if (flush == Z_FINISH) { + + if (flush == Z_FINISH) + { FLUSH_BLOCK(s, 1); return finish_done; } + if ((long)s->strstart > s->block_start) FLUSH_BLOCK(s, 0); + return block_done; } @@ -1731,27 +1999,32 @@ local block_state deflate_stored(s, flush) * matches. It is used only for the fast compression options. */ #ifdef WIN32 -local block_state deflate_fast(deflate_state *s, int flush) +local block_state deflate_fast(deflate_state* s, int flush) #else local block_state deflate_fast(s, flush) - deflate_state *s; - int flush; +deflate_state* s; +int flush; #endif { IPos hash_head; /* head of the hash chain */ int bflush; /* set if current block must be flushed */ - for (;;) { + for (;;) + { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need MAX_MATCH bytes * for the next match, plus MIN_MATCH bytes to insert the * string following the next match. */ - if (s->lookahead < MIN_LOOKAHEAD) { + if (s->lookahead < MIN_LOOKAHEAD) + { fill_window(s); - if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + + if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) + { return need_more; } + if (s->lookahead == 0) break; /* flush the current block */ } @@ -1759,26 +2032,31 @@ local block_state deflate_fast(s, flush) * dictionary, and set hash_head to the head of the hash chain: */ hash_head = NIL; - if (s->lookahead >= MIN_MATCH) { + + if (s->lookahead >= MIN_MATCH) + { INSERT_STRING(s, s->strstart, hash_head); } /* Find the longest match, discarding those <= prev_length. * At this point we have always match_length < MIN_MATCH */ - if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { + if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) + { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ - s->match_length = longest_match (s, hash_head); + s->match_length = longest_match(s, hash_head); /* longest_match() sets match_start */ } - if (s->match_length >= MIN_MATCH) { + + if (s->match_length >= MIN_MATCH) + { check_match(s, s->strstart, s->match_start, s->match_length); - _tr_tally_dist(s, (ush) (s->strstart - s->match_start), - (uch) (s->match_length - MIN_MATCH), bflush); + _tr_tally_dist(s, (ush)(s->strstart - s->match_start), + (uch)(s->match_length - MIN_MATCH), bflush); s->lookahead -= s->match_length; @@ -1786,47 +2064,62 @@ local block_state deflate_fast(s, flush) * is not too large. This saves time but degrades compression. */ #ifndef FASTEST + if (s->match_length <= s->max_insert_length && - s->lookahead >= MIN_MATCH) { + s->lookahead >= MIN_MATCH) + { s->match_length--; /* string at strstart already in table */ - do { + + do + { s->strstart++; INSERT_STRING(s, s->strstart, hash_head); /* strstart never exceeds WSIZE-MAX_MATCH, so there are * always MIN_MATCH bytes ahead. */ - } while (--s->match_length != 0); + } + while (--s->match_length != 0); + s->strstart++; - } else + } + else #endif { s->strstart += s->match_length; s->match_length = 0; s->ins_h = s->window[s->strstart]; - UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); + UPDATE_HASH(s, s->ins_h, s->window[s->strstart + 1]); #if MIN_MATCH != 3 - Call UPDATE_HASH() MIN_MATCH-3 more times + Call UPDATE_HASH() MIN_MATCH - 3 more times #endif /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not * matter since it will be recomputed at next deflate call. */ } - } else { + } + else + { /* No match, output a literal byte */ - Tracevv((stderr,"%c", s->window[s->strstart])); - _tr_tally_lit (s, s->window[s->strstart], bflush); + Tracevv((stderr, "%c", s->window[s->strstart])); + _tr_tally_lit(s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; } + if (bflush) FLUSH_BLOCK(s, 0); } - s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; - if (flush == Z_FINISH) { + + s->insert = s->strstart < MIN_MATCH - 1 ? s->strstart : MIN_MATCH - 1; + + if (flush == Z_FINISH) + { FLUSH_BLOCK(s, 1); return finish_done; } + if (s->last_lit) FLUSH_BLOCK(s, 0); + return block_done; } @@ -1837,28 +2130,33 @@ local block_state deflate_fast(s, flush) * no better match at the next window position. */ #ifdef WIN32 -local block_state deflate_slow(deflate_state *s, int flush) +local block_state deflate_slow(deflate_state* s, int flush) #else local block_state deflate_slow(s, flush) - deflate_state *s; - int flush; +deflate_state* s; +int flush; #endif { IPos hash_head; /* head of hash chain */ int bflush; /* set if current block must be flushed */ /* Process the input block. */ - for (;;) { + for (;;) + { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need MAX_MATCH bytes * for the next match, plus MIN_MATCH bytes to insert the * string following the next match. */ - if (s->lookahead < MIN_LOOKAHEAD) { + if (s->lookahead < MIN_LOOKAHEAD) + { fill_window(s); - if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + + if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) + { return need_more; } + if (s->lookahead == 0) break; /* flush the current block */ } @@ -1866,81 +2164,100 @@ local block_state deflate_slow(s, flush) * dictionary, and set hash_head to the head of the hash chain: */ hash_head = NIL; - if (s->lookahead >= MIN_MATCH) { + + if (s->lookahead >= MIN_MATCH) + { INSERT_STRING(s, s->strstart, hash_head); } /* Find the longest match, discarding those <= prev_length. */ s->prev_length = s->match_length, s->prev_match = s->match_start; - s->match_length = MIN_MATCH-1; + s->match_length = MIN_MATCH - 1; if (hash_head != NIL && s->prev_length < s->max_lazy_match && - s->strstart - hash_head <= MAX_DIST(s)) { + s->strstart - hash_head <= MAX_DIST(s)) + { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ - s->match_length = longest_match (s, hash_head); + s->match_length = longest_match(s, hash_head); /* longest_match() sets match_start */ if (s->match_length <= 5 && (s->strategy == Z_FILTERED #if TOO_FAR <= 32767 - || (s->match_length == MIN_MATCH && - s->strstart - s->match_start > TOO_FAR) + || (s->match_length == MIN_MATCH && + s->strstart - s->match_start > TOO_FAR) #endif - )) { + )) + { /* If prev_match is also MIN_MATCH, match_start is garbage * but we will ignore the current match anyway. */ - s->match_length = MIN_MATCH-1; + s->match_length = MIN_MATCH - 1; } } + /* If there was a match at the previous step and the current * match is not better, output the previous match: */ - if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { + if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) + { uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; /* Do not insert strings in hash table beyond this. */ - check_match(s, s->strstart-1, s->prev_match, s->prev_length); + check_match(s, s->strstart - 1, s->prev_match, s->prev_length); - _tr_tally_dist(s, (ush) (s->strstart -1 - s->prev_match), - (uch) (s->prev_length - MIN_MATCH), bflush); + _tr_tally_dist(s, (ush)(s->strstart - 1 - s->prev_match), + (uch)(s->prev_length - MIN_MATCH), bflush); /* Insert in hash table all strings up to the end of the match. * strstart-1 and strstart are already inserted. If there is not * enough lookahead, the last two strings are not inserted in * the hash table. */ - s->lookahead -= s->prev_length-1; + s->lookahead -= s->prev_length - 1; s->prev_length -= 2; - do { - if (++s->strstart <= max_insert) { + + do + { + if (++s->strstart <= max_insert) + { INSERT_STRING(s, s->strstart, hash_head); } - } while (--s->prev_length != 0); + } + while (--s->prev_length != 0); + s->match_available = 0; - s->match_length = MIN_MATCH-1; + s->match_length = MIN_MATCH - 1; s->strstart++; if (bflush) FLUSH_BLOCK(s, 0); - } else if (s->match_available) { + } + else if (s->match_available) + { /* If there was no match at the previous position, output a * single literal. If there was a match but the current match * is longer, truncate the previous match to a single literal. */ - Tracevv((stderr,"%c", s->window[s->strstart-1])); - _tr_tally_lit(s, s->window[s->strstart-1], bflush); - if (bflush) { + Tracevv((stderr, "%c", s->window[s->strstart - 1])); + _tr_tally_lit(s, s->window[s->strstart - 1], bflush); + + if (bflush) + { FLUSH_BLOCK_ONLY(s, 0); } + s->strstart++; s->lookahead--; + if (s->strm->avail_out == 0) return need_more; - } else { + } + else + { /* There is no previous match to compare with, wait for * the next step to decide. */ @@ -1949,19 +2266,27 @@ local block_state deflate_slow(s, flush) s->lookahead--; } } - Assert (flush != Z_NO_FLUSH, "no flush?"); - if (s->match_available) { - Tracevv((stderr,"%c", s->window[s->strstart-1])); - _tr_tally_lit(s, s->window[s->strstart-1], bflush); + + Assert(flush != Z_NO_FLUSH, "no flush?"); + + if (s->match_available) + { + Tracevv((stderr, "%c", s->window[s->strstart - 1])); + _tr_tally_lit(s, s->window[s->strstart - 1], bflush); s->match_available = 0; } - s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; - if (flush == Z_FINISH) { + + s->insert = s->strstart < MIN_MATCH - 1 ? s->strstart : MIN_MATCH - 1; + + if (flush == Z_FINISH) + { FLUSH_BLOCK(s, 1); return finish_done; } + if (s->last_lit) FLUSH_BLOCK(s, 0); + return block_done; } #endif /* FASTEST */ @@ -1972,75 +2297,99 @@ local block_state deflate_slow(s, flush) * deflate switches away from Z_RLE.) */ #ifdef WIN32 -local block_state deflate_rle(deflate_state *s, int flush) +local block_state deflate_rle(deflate_state* s, int flush) #else local block_state deflate_rle(s, flush) - deflate_state *s; - int flush; +deflate_state* s; +int flush; #endif { int bflush; /* set if current block must be flushed */ uInt prev; /* byte at distance one to match */ - Bytef *scan, *strend; /* scan goes up to strend for length of run */ + Bytef* scan, *strend; /* scan goes up to strend for length of run */ - for (;;) { + for (;;) + { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need MAX_MATCH bytes * for the longest run, plus one for the unrolled loop. */ - if (s->lookahead <= MAX_MATCH) { + if (s->lookahead <= MAX_MATCH) + { fill_window(s); - if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) { + + if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) + { return need_more; } + if (s->lookahead == 0) break; /* flush the current block */ } /* See how many times the previous byte repeats */ s->match_length = 0; - if (s->lookahead >= MIN_MATCH && s->strstart > 0) { + + if (s->lookahead >= MIN_MATCH && s->strstart > 0) + { scan = s->window + s->strstart - 1; prev = *scan; - if (prev == *++scan && prev == *++scan && prev == *++scan) { + + if (prev == *++scan && prev == *++scan && prev == *++scan) + { strend = s->window + s->strstart + MAX_MATCH; - do { - } while (prev == *++scan && prev == *++scan && - prev == *++scan && prev == *++scan && - prev == *++scan && prev == *++scan && - prev == *++scan && prev == *++scan && - scan < strend); + + do + { + } + while (prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + scan < strend); + s->match_length = MAX_MATCH - (int)(strend - scan); + if (s->match_length > s->lookahead) s->match_length = s->lookahead; } - Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); + + Assert(scan <= s->window + (uInt)(s->window_size - 1), "wild scan"); } /* Emit match if have run of MIN_MATCH or longer, else emit literal */ - if (s->match_length >= MIN_MATCH) { + if (s->match_length >= MIN_MATCH) + { check_match(s, s->strstart, s->strstart - 1, s->match_length); - _tr_tally_dist(s, 1, (uch) (s->match_length - MIN_MATCH), bflush); + _tr_tally_dist(s, 1, (uch)(s->match_length - MIN_MATCH), bflush); s->lookahead -= s->match_length; s->strstart += s->match_length; s->match_length = 0; - } else { + } + else + { /* No match, output a literal byte */ - Tracevv((stderr,"%c", s->window[s->strstart])); - _tr_tally_lit (s, s->window[s->strstart], bflush); + Tracevv((stderr, "%c", s->window[s->strstart])); + _tr_tally_lit(s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; } + if (bflush) FLUSH_BLOCK(s, 0); } + s->insert = 0; - if (flush == Z_FINISH) { + + if (flush == Z_FINISH) + { FLUSH_BLOCK(s, 1); return finish_done; } + if (s->last_lit) FLUSH_BLOCK(s, 0); + return block_done; } @@ -2049,40 +2398,51 @@ local block_state deflate_rle(s, flush) * (It will be regenerated if this run of deflate switches away from Huffman.) */ #ifdef WIN32 -local block_state deflate_huff(deflate_state *s, int flush) +local block_state deflate_huff(deflate_state* s, int flush) #else local block_state deflate_huff(s, flush) - deflate_state *s; - int flush; +deflate_state* s; +int flush; #endif { int bflush; /* set if current block must be flushed */ - for (;;) { + for (;;) + { /* Make sure that we have a literal to write. */ - if (s->lookahead == 0) { + if (s->lookahead == 0) + { fill_window(s); - if (s->lookahead == 0) { + + if (s->lookahead == 0) + { if (flush == Z_NO_FLUSH) return need_more; + break; /* flush the current block */ } } /* Output a literal byte */ s->match_length = 0; - Tracevv((stderr,"%c", s->window[s->strstart])); - _tr_tally_lit (s, s->window[s->strstart], bflush); + Tracevv((stderr, "%c", s->window[s->strstart])); + _tr_tally_lit(s, s->window[s->strstart], bflush); s->lookahead--; s->strstart++; + if (bflush) FLUSH_BLOCK(s, 0); } + s->insert = 0; - if (flush == Z_FINISH) { + + if (flush == Z_FINISH) + { FLUSH_BLOCK(s, 1); return finish_done; } + if (s->last_lit) FLUSH_BLOCK(s, 0); + return block_done; } diff --git a/extern/zlib/deflate.h b/extern/zlib/deflate.h index fbac44d..8698602 100644 --- a/extern/zlib/deflate.h +++ b/extern/zlib/deflate.h @@ -62,12 +62,15 @@ /* Data structure describing a single value and its code string. */ -typedef struct ct_data_s { - union { +typedef struct ct_data_s +{ + union + { ush freq; /* frequency count */ ush code; /* bit string */ } fc; - union { + union + { ush dad; /* father node in Huffman tree */ ush len; /* length of bit string */ } dl; @@ -80,10 +83,11 @@ typedef struct ct_data_s { typedef struct static_tree_desc_s static_tree_desc; -typedef struct tree_desc_s { - ct_data *dyn_tree; /* the dynamic tree */ +typedef struct tree_desc_s +{ + ct_data* dyn_tree; /* the dynamic tree */ int max_code; /* largest code with non zero frequency */ - static_tree_desc *stat_desc; /* the corresponding static tree */ + static_tree_desc* stat_desc; /* the corresponding static tree */ } FAR tree_desc; typedef ush Pos; @@ -94,12 +98,13 @@ typedef unsigned IPos; * save space in the various tables. IPos is used only for parameter passing. */ -typedef struct internal_state { +typedef struct internal_state +{ z_streamp strm; /* pointer back to this zlib stream */ int status; /* as the name implies */ - Bytef *pending_buf; /* output still pending */ + Bytef* pending_buf; /* output still pending */ ulg pending_buf_size; /* size of pending_buf */ - Bytef *pending_out; /* next pending byte to output to the stream */ + Bytef* pending_out; /* next pending byte to output to the stream */ uInt pending; /* nb of bytes in the pending buffer */ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ gz_headerp gzhead; /* gzip header information to write */ @@ -107,13 +112,13 @@ typedef struct internal_state { Byte method; /* STORED (for zip only) or DEFLATED */ int last_flush; /* value of flush param for previous deflate call */ - /* used by deflate.c: */ + /* used by deflate.c: */ uInt w_size; /* LZ77 window size (32K by default) */ uInt w_bits; /* log2(w_size) (8..16) */ uInt w_mask; /* w_size - 1 */ - Bytef *window; + Bytef* window; /* Sliding window. Input bytes are read into the second half of the window, * and move to the first half later to keep a dictionary of at least wSize * bytes. With this organization, matches are limited to a distance of @@ -128,13 +133,13 @@ typedef struct internal_state { * is directly used as sliding window. */ - Posf *prev; + Posf* prev; /* Link to older string with same hash index. To limit the size of this * array to 64K, this link is maintained only for the last 32K strings. * An index in this array is thus a window index modulo 32K. */ - Posf *head; /* Heads of the hash chains or NIL. */ + Posf* head; /* Heads of the hash chains or NIL. */ uInt ins_h; /* hash index of string to be inserted */ uInt hash_size; /* number of elements in hash table */ @@ -190,31 +195,31 @@ typedef struct internal_state { int nice_match; /* Stop searching when current match exceeds this */ - /* used by trees.c: */ + /* used by trees.c: */ /* Didn't use ct_data typedef below to suppress compiler warning */ struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ - struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ - struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ + struct ct_data_s dyn_dtree[2 * D_CODES + 1]; /* distance tree */ + struct ct_data_s bl_tree[2 * BL_CODES + 1]; /* Huffman tree for bit lengths */ struct tree_desc_s l_desc; /* desc. for literal tree */ struct tree_desc_s d_desc; /* desc. for distance tree */ struct tree_desc_s bl_desc; /* desc. for bit length tree */ - ush bl_count[MAX_BITS+1]; + ush bl_count[MAX_BITS + 1]; /* number of codes at each bit length for an optimal tree */ - int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ + int heap[2 * L_CODES + 1]; /* heap used to build the Huffman trees */ int heap_len; /* number of elements in the heap */ int heap_max; /* element of largest frequency */ /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. * The same heap array is used to build all trees. */ - uch depth[2*L_CODES+1]; + uch depth[2 * L_CODES + 1]; /* Depth of each subtree used as tie breaker for trees of equal frequency */ - uchf *l_buf; /* buffer for literals or lengths */ + uchf* l_buf; /* buffer for literals or lengths */ uInt lit_bufsize; /* Size of match buffer for literals/lengths. There are 4 reasons for @@ -238,7 +243,7 @@ typedef struct internal_state { uInt last_lit; /* running index in l_buf */ - ushf *d_buf; + ushf* d_buf; /* Buffer for distances. To simplify the code, d_buf and l_buf have * the same number of elements. To use different lengths, an extra flag * array would be necessary. @@ -292,15 +297,15 @@ typedef struct internal_state { /* Number of bytes after end of data in window to initialize in order to avoid memory checker errors from longest match routines */ - /* in trees.c */ -void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); -int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); -void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, - ulg stored_len, int last)); -void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s)); -void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); -void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, - ulg stored_len, int last)); +/* in trees.c */ +void ZLIB_INTERNAL _tr_init OF((deflate_state* s)); +int ZLIB_INTERNAL _tr_tally OF((deflate_state* s, unsigned dist, unsigned lc)); +void ZLIB_INTERNAL _tr_flush_block OF((deflate_state* s, charf* buf, + ulg stored_len, int last)); +void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state* s)); +void ZLIB_INTERNAL _tr_align OF((deflate_state* s)); +void ZLIB_INTERNAL _tr_stored_block OF((deflate_state* s, charf* buf, + ulg stored_len, int last)); #define d_code(dist) \ ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) @@ -313,11 +318,11 @@ void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, /* Inline versions of _tr_tally for speed: */ #if defined(GEN_TREES_H) || !defined(STDC) - extern uch ZLIB_INTERNAL _length_code[]; - extern uch ZLIB_INTERNAL _dist_code[]; +extern uch ZLIB_INTERNAL _length_code[]; +extern uch ZLIB_INTERNAL _dist_code[]; #else - extern const uch ZLIB_INTERNAL _length_code[]; - extern const uch ZLIB_INTERNAL _dist_code[]; +extern const uch ZLIB_INTERNAL _length_code[]; +extern const uch ZLIB_INTERNAL _dist_code[]; #endif # define _tr_tally_lit(s, c, flush) \ diff --git a/extern/zlib/gzclose.c b/extern/zlib/gzclose.c index f116d2e..94a8d01 100644 --- a/extern/zlib/gzclose.c +++ b/extern/zlib/gzclose.c @@ -12,7 +12,7 @@ int ZEXPORT gzclose(gzFile file) #else int ZEXPORT gzclose(file) - gzFile file; +gzFile file; #endif { #ifndef NO_GZCOMPRESS @@ -20,6 +20,7 @@ int ZEXPORT gzclose(file) if (file == NULL) return Z_STREAM_ERROR; + state = (gz_statep)file; return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file); diff --git a/extern/zlib/gzguts.h b/extern/zlib/gzguts.h index bb94361..215c678 100644 --- a/extern/zlib/gzguts.h +++ b/extern/zlib/gzguts.h @@ -100,8 +100,8 @@ /* gz* functions always use library allocation functions */ #ifndef STDC - extern voidp malloc OF((uInt size)); - extern void free OF((voidpf ptr)); +extern voidp malloc OF((uInt size)); +extern void free OF((voidpf ptr)); #endif /* get errno and strerror definition */ @@ -119,10 +119,10 @@ /* provide prototypes for these when building zlib without LFS */ #if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 - ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); - ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); - ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); - ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); +ZEXTERN gzFile ZEXPORT gzopen64 OF((const char*, const char*)); +ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); +ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); +ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); #endif /* default memLevel */ @@ -147,44 +147,45 @@ #define GZIP 2 /* decompress a gzip stream */ /* internal gzip file state data structure */ -typedef struct { - /* exposed contents for gzgetc() macro */ +typedef struct +{ + /* exposed contents for gzgetc() macro */ struct gzFile_s x; /* "x" for exposed */ - /* x.have: number of bytes available at x.next */ - /* x.next: next output data to deliver or write */ - /* x.pos: current position in uncompressed data */ - /* used for both reading and writing */ + /* x.have: number of bytes available at x.next */ + /* x.next: next output data to deliver or write */ + /* x.pos: current position in uncompressed data */ + /* used for both reading and writing */ int mode; /* see gzip modes above */ int fd; /* file descriptor */ - char *path; /* path or fd for error messages */ + char* path; /* path or fd for error messages */ unsigned size; /* buffer size, zero if not allocated yet */ unsigned want; /* requested buffer size, default is GZBUFSIZE */ - unsigned char *in; /* input buffer */ - unsigned char *out; /* output buffer (double-sized when reading) */ + unsigned char* in; /* input buffer */ + unsigned char* out; /* output buffer (double-sized when reading) */ int direct; /* 0 if processing gzip, 1 if transparent */ - /* just for reading */ + /* just for reading */ int how; /* 0: get header, 1: copy, 2: decompress */ z_off64_t start; /* where the gzip data started, for rewinding */ int eof; /* true if end of input file reached */ int past; /* true if read requested past end */ - /* just for writing */ + /* just for writing */ int level; /* compression level */ int strategy; /* compression strategy */ - /* seek request */ + /* seek request */ z_off64_t skip; /* amount to skip (already rewound if backwards) */ int seek; /* true if seek request pending */ - /* error information */ + /* error information */ int err; /* error code */ - char *msg; /* error message */ - /* zlib inflate or deflate stream */ + char* msg; /* error message */ + /* zlib inflate or deflate stream */ z_stream strm; /* stream structure in-place (not a pointer) */ } gz_state; -typedef gz_state FAR *gz_statep; +typedef gz_state FAR* gz_statep; /* shared functions */ -void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *)); +void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char*)); #if defined UNDER_CE -char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); +char ZLIB_INTERNAL* gz_strwinerror OF((DWORD error)); #endif /* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t diff --git a/extern/zlib/gzlib.c b/extern/zlib/gzlib.c index 2fe65c5..162d111 100644 --- a/extern/zlib/gzlib.c +++ b/extern/zlib/gzlib.c @@ -17,7 +17,7 @@ /* Local functions */ local void gz_reset OF((gz_statep)); -local gzFile gz_open OF((const void *, int, const char *)); +local gzFile gz_open OF((const void*, int, const char*)); #if defined UNDER_CE @@ -30,38 +30,43 @@ local gzFile gz_open OF((const void *, int, const char *)); The gz_strwinerror function does not change the current setting of GetLastError. */ -char ZLIB_INTERNAL *gz_strwinerror (error) - DWORD error; +char ZLIB_INTERNAL* gz_strwinerror(error) +DWORD error; { static char buf[1024]; - wchar_t *msgbuf; + wchar_t* msgbuf; DWORD lasterr = GetLastError(); DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM - | FORMAT_MESSAGE_ALLOCATE_BUFFER, - NULL, - error, - 0, /* Default language */ - (LPVOID)&msgbuf, - 0, - NULL); - if (chars != 0) { + | FORMAT_MESSAGE_ALLOCATE_BUFFER, + NULL, + error, + 0, /* Default language */ + (LPVOID)&msgbuf, + 0, + NULL); + + if (chars != 0) + { /* If there is an \r\n appended, zap it. */ if (chars >= 2 - && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') { + && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') + { chars -= 2; msgbuf[chars] = 0; } - if (chars > sizeof (buf) - 1) { - chars = sizeof (buf) - 1; + if (chars > sizeof(buf) - 1) + { + chars = sizeof(buf) - 1; msgbuf[chars] = 0; } wcstombs(buf, msgbuf, chars + 1); LocalFree(msgbuf); } - else { + else + { sprintf(buf, "unknown win32 error (%ld)", error); } @@ -76,15 +81,18 @@ char ZLIB_INTERNAL *gz_strwinerror (error) local void gz_reset(gz_statep state) #else local void gz_reset(state) - gz_statep state; +gz_statep state; #endif { state->x.have = 0; /* no output data available */ - if (state->mode == GZ_READ) { /* for reading ... */ + + if (state->mode == GZ_READ) /* for reading ... */ + { state->eof = 0; /* not at end of file */ state->past = 0; /* have not read past end yet */ state->how = LOOK; /* look for gzip header */ } + state->seek = 0; /* no seek request pending */ gz_error(state, Z_OK, NULL); /* clear error */ state->x.pos = 0; /* no uncompressed data yet */ @@ -93,12 +101,12 @@ local void gz_reset(state) /* Open a gzip file either by name or file descriptor. */ #ifdef WIN32 -local gzFile gz_open(const void *path, int fd, const char *mode) +local gzFile gz_open(const void* path, int fd, const char* mode) #else local gzFile gz_open(path, fd, mode) - const void *path; - int fd; - const char *mode; +const void* path; +int fd; +const char* mode; #endif { gz_statep state; @@ -117,8 +125,10 @@ local gzFile gz_open(path, fd, mode) /* allocate gzFile structure to return */ state = malloc(sizeof(gz_state)); + if (state == NULL) return NULL; + state->size = 0; /* no buffers allocated yet */ state->want = GZBUFSIZE; /* requested buffer size */ state->msg = NULL; /* no error message yet */ @@ -128,87 +138,115 @@ local gzFile gz_open(path, fd, mode) state->level = Z_DEFAULT_COMPRESSION; state->strategy = Z_DEFAULT_STRATEGY; state->direct = 0; - while (*mode) { + + while (*mode) + { if (*mode >= '0' && *mode <= '9') state->level = *mode - '0'; else - switch (*mode) { - case 'r': - state->mode = GZ_READ; - break; + switch (*mode) + { + case 'r': + state->mode = GZ_READ; + break; #ifndef NO_GZCOMPRESS - case 'w': - state->mode = GZ_WRITE; - break; - case 'a': - state->mode = GZ_APPEND; - break; + + case 'w': + state->mode = GZ_WRITE; + break; + + case 'a': + state->mode = GZ_APPEND; + break; #endif - case '+': /* can't read and write at the same time */ - free(state); - return NULL; - case 'b': /* ignore -- will request binary anyway */ - break; + + case '+': /* can't read and write at the same time */ + free(state); + return NULL; + + case 'b': /* ignore -- will request binary anyway */ + break; #ifdef O_CLOEXEC - case 'e': - cloexec = 1; - break; + + case 'e': + cloexec = 1; + break; #endif #ifdef O_EXCL - case 'x': - exclusive = 1; - break; + + case 'x': + exclusive = 1; + break; #endif - case 'f': - state->strategy = Z_FILTERED; - break; - case 'h': - state->strategy = Z_HUFFMAN_ONLY; - break; - case 'R': - state->strategy = Z_RLE; - break; - case 'F': - state->strategy = Z_FIXED; - case 'T': - state->direct = 1; - default: /* could consider as an error, but just ignore */ - ; + + case 'f': + state->strategy = Z_FILTERED; + break; + + case 'h': + state->strategy = Z_HUFFMAN_ONLY; + break; + + case 'R': + state->strategy = Z_RLE; + break; + + case 'F': + state->strategy = Z_FIXED; + + case 'T': + state->direct = 1; + + default: /* could consider as an error, but just ignore */ + ; } + mode++; } /* must provide an "r", "w", or "a" */ - if (state->mode == GZ_NONE) { + if (state->mode == GZ_NONE) + { free(state); return NULL; } /* can't force transparent read */ - if (state->mode == GZ_READ) { - if (state->direct) { + if (state->mode == GZ_READ) + { + if (state->direct) + { free(state); return NULL; } + state->direct = 1; /* for empty file */ } /* save the path name for error messages */ #ifdef _WIN32 - if (fd == -2) { + + if (fd == -2) + { len = wcstombs(NULL, path, 0); - if (len == (size_t)-1) + + if (len == (size_t) - 1) len = 0; } else #endif len = strlen(path); + state->path = malloc(len + 1); - if (state->path == NULL) { + + if (state->path == NULL) + { free(state); return NULL; } + #ifdef _WIN32 + if (fd == -2) if (len) wcstombs(state->path, path, len + 1); @@ -242,20 +280,25 @@ local gzFile gz_open(path, fd, mode) /* open the file with the appropriate flags (or just use fd) */ state->fd = fd > -1 ? fd : ( #ifdef _WIN32 - fd == -2 ? _wopen(path, oflag, 0666) : + fd == -2 ? _wopen(path, oflag, 0666) : #endif - open(path, oflag, 0666)); - if (state->fd == -1) { + open(path, oflag, 0666)); + + if (state->fd == -1) + { free(state->path); free(state); return NULL; } + if (state->mode == GZ_APPEND) state->mode = GZ_WRITE; /* simplify later checks */ /* save the current position for rewinding (only if reading) */ - if (state->mode == GZ_READ) { + if (state->mode == GZ_READ) + { state->start = LSEEK(state->fd, 0, SEEK_CUR); + if (state->start == -1) state->start = 0; } @@ -268,11 +311,11 @@ local gzFile gz_open(path, fd, mode) /* -- see zlib.h -- */ #ifdef WIN32 -gzFile ZEXPORT gzopen(const char *path, const char *mode) +gzFile ZEXPORT gzopen(const char* path, const char* mode) #else gzFile ZEXPORT gzopen(path, mode) - const char *path; - const char *mode; +const char* path; +const char* mode; #endif { return gz_open(path, -1, mode); @@ -280,11 +323,11 @@ gzFile ZEXPORT gzopen(path, mode) /* -- see zlib.h -- */ #ifdef WIN32 -gzFile ZEXPORT gzopen64(const char *path, const char *mode) +gzFile ZEXPORT gzopen64(const char* path, const char* mode) #else gzFile ZEXPORT gzopen64(path, mode) - const char *path; - const char *mode; +const char* path; +const char* mode; #endif { return gz_open(path, -1, mode); @@ -292,18 +335,19 @@ gzFile ZEXPORT gzopen64(path, mode) /* -- see zlib.h -- */ #ifdef WIN32 -gzFile ZEXPORT gzdopen(int fd, const char *mode) +gzFile ZEXPORT gzdopen(int fd, const char* mode) #else gzFile ZEXPORT gzdopen(fd, mode) - int fd; - const char *mode; +int fd; +const char* mode; #endif { - char *path; /* identifier for error messages */ + char* path; /* identifier for error messages */ gzFile gz; if (fd == -1 || (path = malloc(7 + 3 * sizeof(int))) == NULL) return NULL; + sprintf(path, "", fd); /* for debugging */ gz = gz_open(path, fd, mode); free(path); @@ -312,11 +356,11 @@ gzFile ZEXPORT gzdopen(fd, mode) /* -- see zlib.h -- */ #ifdef _WIN32 -gzFile ZEXPORT gzopen_w(const wchar_t *path, const char *mode) +gzFile ZEXPORT gzopen_w(const wchar_t* path, const char* mode) #else gzFile ZEXPORT gzopen_w(path, mode) - const wchar_t *path; - const char *mode; +const wchar_t* path; +const char* mode; #endif { return gz_open(path, -2, mode); @@ -327,8 +371,8 @@ gzFile ZEXPORT gzopen_w(path, mode) int ZEXPORT gzbuffer(gzFile file, unsigned size) #else int ZEXPORT gzbuffer(file, size) - gzFile file; - unsigned size; +gzFile file; +unsigned size; #endif { gz_statep state; @@ -336,7 +380,9 @@ int ZEXPORT gzbuffer(file, size) /* get internal structure and check integrity */ if (file == NULL) return -1; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) return -1; @@ -347,6 +393,7 @@ int ZEXPORT gzbuffer(file, size) /* check and set requested size */ if (size < 2) size = 2; /* need two bytes to check magic header */ + state->want = size; return 0; } @@ -356,7 +403,7 @@ int ZEXPORT gzbuffer(file, size) int ZEXPORT gzrewind(gzFile file) #else int ZEXPORT gzrewind(file) - gzFile file; +gzFile file; #endif { gz_statep state; @@ -364,6 +411,7 @@ int ZEXPORT gzrewind(file) /* get internal structure */ if (file == NULL) return -1; + state = (gz_statep)file; /* check that we're reading and that there's no error */ @@ -374,6 +422,7 @@ int ZEXPORT gzrewind(file) /* back up and start over */ if (LSEEK(state->fd, state->start, SEEK_SET) == -1) return -1; + gz_reset(state); return 0; } @@ -383,9 +432,9 @@ int ZEXPORT gzrewind(file) z_off64_t ZEXPORT gzseek64(gzFile file, z_off64_t offset, int whence) #else z_off64_t ZEXPORT gzseek64(file, offset, whence) - gzFile file; - z_off64_t offset; - int whence; +gzFile file; +z_off64_t offset; +int whence; #endif { unsigned n; @@ -395,7 +444,9 @@ z_off64_t ZEXPORT gzseek64(file, offset, whence) /* get internal structure and check integrity */ if (file == NULL) return -1; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) return -1; @@ -412,14 +463,18 @@ z_off64_t ZEXPORT gzseek64(file, offset, whence) offset -= state->x.pos; else if (state->seek) offset += state->skip; + state->seek = 0; /* if within raw area while reading, just go there */ if (state->mode == GZ_READ && state->how == COPY && - state->x.pos + offset >= 0) { + state->x.pos + offset >= 0) + { ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR); + if (ret == -1) return -1; + state->x.have = 0; state->eof = 0; state->past = 0; @@ -431,18 +486,23 @@ z_off64_t ZEXPORT gzseek64(file, offset, whence) } /* calculate skip amount, rewinding if needed for back seek when reading */ - if (offset < 0) { + if (offset < 0) + { if (state->mode != GZ_READ) /* writing -- can't go backwards */ return -1; + offset += state->x.pos; + if (offset < 0) /* before start of file! */ return -1; + if (gzrewind(file) == -1) /* rewind, then skip to offset */ return -1; } /* if reading, skip what's in output buffer (one less gzgetc() check) */ - if (state->mode == GZ_READ) { + if (state->mode == GZ_READ) + { n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ? (unsigned)offset : state->x.have; state->x.have -= n; @@ -452,10 +512,12 @@ z_off64_t ZEXPORT gzseek64(file, offset, whence) } /* request skip (if not zero) */ - if (offset) { + if (offset) + { state->seek = 1; state->skip = offset; } + return state->x.pos + offset; } @@ -464,9 +526,9 @@ z_off64_t ZEXPORT gzseek64(file, offset, whence) z_off_t ZEXPORT gzseek(gzFile file, z_off_t offset, int whence) #else z_off_t ZEXPORT gzseek(file, offset, whence) - gzFile file; - z_off_t offset; - int whence; +gzFile file; +z_off_t offset; +int whence; #endif { z_off64_t ret; @@ -480,7 +542,7 @@ z_off_t ZEXPORT gzseek(file, offset, whence) z_off64_t ZEXPORT gztell64(gzFile file) #else z_off64_t ZEXPORT gztell64(file) - gzFile file; +gzFile file; #endif { gz_statep state; @@ -488,7 +550,9 @@ z_off64_t ZEXPORT gztell64(file) /* get internal structure and check integrity */ if (file == NULL) return -1; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) return -1; @@ -501,7 +565,7 @@ z_off64_t ZEXPORT gztell64(file) z_off_t ZEXPORT gztell(gzFile file) #else z_off_t ZEXPORT gztell(file) - gzFile file; +gzFile file; #endif { z_off64_t ret; @@ -515,7 +579,7 @@ z_off_t ZEXPORT gztell(file) z_off64_t ZEXPORT gzoffset64(gzFile file) #else z_off64_t ZEXPORT gzoffset64(file) - gzFile file; +gzFile file; #endif { z_off64_t offset; @@ -524,16 +588,21 @@ z_off64_t ZEXPORT gzoffset64(file) /* get internal structure and check integrity */ if (file == NULL) return -1; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) return -1; /* compute and return effective offset in file */ offset = LSEEK(state->fd, 0, SEEK_CUR); + if (offset == -1) return -1; + if (state->mode == GZ_READ) /* reading */ offset -= state->strm.avail_in; /* don't count buffered input */ + return offset; } @@ -542,7 +611,7 @@ z_off64_t ZEXPORT gzoffset64(file) z_off_t ZEXPORT gzoffset(gzFile file) #else z_off_t ZEXPORT gzoffset(file) - gzFile file; +gzFile file; #endif { z_off64_t ret; @@ -556,7 +625,7 @@ z_off_t ZEXPORT gzoffset(file) int ZEXPORT gzeof(gzFile file) #else int ZEXPORT gzeof(file) - gzFile file; +gzFile file; #endif { gz_statep state; @@ -564,7 +633,9 @@ int ZEXPORT gzeof(file) /* get internal structure and check integrity */ if (file == NULL) return 0; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) return 0; @@ -574,11 +645,11 @@ int ZEXPORT gzeof(file) /* -- see zlib.h -- */ #ifdef WIN32 -const char * ZEXPORT gzerror(gzFile file, int *errnum) +const char* ZEXPORT gzerror(gzFile file, int* errnum) #else -const char * ZEXPORT gzerror(file, errnum) - gzFile file; - int *errnum; +const char* ZEXPORT gzerror(file, errnum) +gzFile file; +int* errnum; #endif { gz_statep state; @@ -586,13 +657,16 @@ const char * ZEXPORT gzerror(file, errnum) /* get internal structure and check integrity */ if (file == NULL) return NULL; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) return NULL; /* return error information */ if (errnum != NULL) *errnum = state->err; + return state->msg == NULL ? "" : state->msg; } @@ -601,7 +675,7 @@ const char * ZEXPORT gzerror(file, errnum) void ZEXPORT gzclearerr(gzFile file) #else void ZEXPORT gzclearerr(file) - gzFile file; +gzFile file; #endif { gz_statep state; @@ -609,15 +683,19 @@ void ZEXPORT gzclearerr(file) /* get internal structure and check integrity */ if (file == NULL) return; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) return; /* clear error and end-of-file */ - if (state->mode == GZ_READ) { + if (state->mode == GZ_READ) + { state->eof = 0; state->past = 0; } + gz_error(state, Z_OK, NULL); } @@ -628,18 +706,20 @@ void ZEXPORT gzclearerr(file) allocation failure constructing the error message, then convert the error to out of memory. */ #ifdef WIN32 -void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char *msg) +void ZLIB_INTERNAL gz_error(gz_statep state, int err, const char* msg) #else void ZLIB_INTERNAL gz_error(state, err, msg) - gz_statep state; - int err; - const char *msg; +gz_statep state; +int err; +const char* msg; #endif { /* free previously allocated message and clear */ - if (state->msg != NULL) { + if (state->msg != NULL) + { if (state->err != Z_MEM_ERROR) free(state->msg); + state->msg = NULL; } @@ -649,21 +729,25 @@ void ZLIB_INTERNAL gz_error(state, err, msg) /* set error code, and if no message, then done */ state->err = err; + if (msg == NULL) return; /* for an out of memory error, save as static string */ - if (err == Z_MEM_ERROR) { - state->msg = (char *)msg; + if (err == Z_MEM_ERROR) + { + state->msg = (char*)msg; return; } /* construct error message with path */ - if ((state->msg = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) { + if ((state->msg = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) + { state->err = Z_MEM_ERROR; - state->msg = (char *)"out of memory"; + state->msg = (char*)"out of memory"; return; } + strcpy(state->msg, state->path); strcat(state->msg, ": "); strcat(state->msg, msg); @@ -680,11 +764,15 @@ unsigned ZLIB_INTERNAL gz_intmax() unsigned p, q; p = 1; - do { + + do + { q = p; p <<= 1; p++; - } while (p > q); + } + while (p > q); + return q >> 1; } #endif diff --git a/extern/zlib/gzread.c b/extern/zlib/gzread.c index 1e16103..66c93b3 100644 --- a/extern/zlib/gzread.c +++ b/extern/zlib/gzread.c @@ -6,7 +6,7 @@ #include "gzguts.h" /* Local functions */ -local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *)); +local int gz_load OF((gz_statep, unsigned char*, unsigned, unsigned*)); local int gz_avail OF((gz_statep)); local int gz_look OF((gz_statep)); local int gz_decomp OF((gz_statep)); @@ -18,30 +18,39 @@ local int gz_skip OF((gz_statep, z_off64_t)); This function needs to loop on read(), since read() is not guaranteed to read the number of bytes requested, depending on the type of descriptor. */ #ifdef WIN32 -local int gz_load(gz_statep state, unsigned char *buf, unsigned len, unsigned *have) +local int gz_load(gz_statep state, unsigned char* buf, unsigned len, unsigned* have) #else local int gz_load(state, buf, len, have) - gz_statep state; - unsigned char *buf; - unsigned len; - unsigned *have; +gz_statep state; +unsigned char* buf; +unsigned len; +unsigned* have; #endif { int ret; *have = 0; - do { + + do + { ret = read(state->fd, buf + *have, len - *have); + if (ret <= 0) break; + *have += ret; - } while (*have < len); - if (ret < 0) { + } + while (*have < len); + + if (ret < 0) + { gz_error(state, Z_ERRNO, zstrerror()); return -1; } + if (ret == 0) state->eof = 1; + return 0; } @@ -56,7 +65,7 @@ local int gz_load(state, buf, len, have) local int gz_avail(gz_statep state) #else local int gz_avail(state) - gz_statep state; +gz_statep state; #endif { unsigned got; @@ -64,20 +73,29 @@ local int gz_avail(state) if (state->err != Z_OK && state->err != Z_BUF_ERROR) return -1; - if (state->eof == 0) { - if (strm->avail_in) { /* copy what's there to the start */ - unsigned char *p = state->in, *q = strm->next_in; + + if (state->eof == 0) + { + if (strm->avail_in) /* copy what's there to the start */ + { + unsigned char* p = state->in, *q = strm->next_in; unsigned n = strm->avail_in; - do { + + do + { *p++ = *q++; - } while (--n); + } + while (--n); } + if (gz_load(state, state->in + strm->avail_in, state->size - strm->avail_in, &got) == -1) return -1; + strm->avail_in += got; strm->next_in = state->in; } + return 0; } @@ -94,24 +112,30 @@ local int gz_avail(state) local int gz_look(gz_statep state) #else local int gz_look(state) - gz_statep state; +gz_statep state; #endif { z_streamp strm = &(state->strm); /* allocate read buffers and inflate memory */ - if (state->size == 0) { + if (state->size == 0) + { /* allocate buffers */ state->in = malloc(state->want); state->out = malloc(state->want << 1); - if (state->in == NULL || state->out == NULL) { + + if (state->in == NULL || state->out == NULL) + { if (state->out != NULL) free(state->out); + if (state->in != NULL) free(state->in); + gz_error(state, Z_MEM_ERROR, "out of memory"); return -1; } + state->size = state->want; /* allocate inflate memory */ @@ -120,7 +144,9 @@ local int gz_look(state) state->strm.opaque = Z_NULL; state->strm.avail_in = 0; state->strm.next_in = Z_NULL; - if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) { /* gunzip */ + + if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) /* gunzip */ + { free(state->out); free(state->in); state->size = 0; @@ -130,9 +156,11 @@ local int gz_look(state) } /* get at least the magic bytes in the input buffer */ - if (strm->avail_in < 2) { + if (strm->avail_in < 2) + { if (gz_avail(state) == -1) return -1; + if (strm->avail_in == 0) return 0; } @@ -145,7 +173,8 @@ local int gz_look(state) the header will be written in a single operation, so that reading a single byte is sufficient indication that it is not a gzip file) */ if (strm->avail_in > 1 && - strm->next_in[0] == 31 && strm->next_in[1] == 139) { + strm->next_in[0] == 31 && strm->next_in[1] == 139) + { inflateReset(strm); state->how = GZIP; state->direct = 0; @@ -154,7 +183,8 @@ local int gz_look(state) /* no gzip header -- if we were decoding gzip before, then this is trailing garbage. Ignore the trailing garbage and finish. */ - if (state->direct == 0) { + if (state->direct == 0) + { strm->avail_in = 0; state->eof = 1; state->x.have = 0; @@ -165,11 +195,14 @@ local int gz_look(state) the output buffer is larger than the input buffer, which also assures space for gzungetc() */ state->x.next = state->out; - if (strm->avail_in) { + + if (strm->avail_in) + { memcpy(state->x.next, strm->next_in, strm->avail_in); state->x.have = strm->avail_in; strm->avail_in = 0; } + state->how = COPY; state->direct = 1; return 0; @@ -184,7 +217,7 @@ local int gz_look(state) local int gz_decomp(gz_statep state) #else local int gz_decomp(state) - gz_statep state; +gz_statep state; #endif { int ret = Z_OK; @@ -193,32 +226,43 @@ local int gz_decomp(state) /* fill output buffer up to end of deflate stream */ had = strm->avail_out; - do { + + do + { /* get more input for inflate() */ if (strm->avail_in == 0 && gz_avail(state) == -1) return -1; - if (strm->avail_in == 0) { + + if (strm->avail_in == 0) + { gz_error(state, Z_BUF_ERROR, "unexpected end of file"); break; } /* decompress and handle errors */ ret = inflate(strm, Z_NO_FLUSH); - if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) { + + if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) + { gz_error(state, Z_STREAM_ERROR, "internal error: inflate stream corrupt"); return -1; } - if (ret == Z_MEM_ERROR) { + + if (ret == Z_MEM_ERROR) + { gz_error(state, Z_MEM_ERROR, "out of memory"); return -1; } - if (ret == Z_DATA_ERROR) { /* deflate stream invalid */ + + if (ret == Z_DATA_ERROR) /* deflate stream invalid */ + { gz_error(state, Z_DATA_ERROR, strm->msg == NULL ? "compressed data error" : strm->msg); return -1; } - } while (strm->avail_out && ret != Z_STREAM_END); + } + while (strm->avail_out && ret != Z_STREAM_END); /* update available output */ state->x.have = had - strm->avail_out; @@ -242,32 +286,42 @@ local int gz_decomp(state) local int gz_fetch(gz_statep state) #else local int gz_fetch(state) - gz_statep state; +gz_statep state; #endif { z_streamp strm = &(state->strm); - do { - switch(state->how) { - case LOOK: /* -> LOOK, COPY (only if never GZIP), or GZIP */ - if (gz_look(state) == -1) - return -1; - if (state->how == LOOK) + do + { + switch (state->how) + { + case LOOK: /* -> LOOK, COPY (only if never GZIP), or GZIP */ + if (gz_look(state) == -1) + return -1; + + if (state->how == LOOK) + return 0; + + break; + + case COPY: /* -> COPY */ + if (gz_load(state, state->out, state->size << 1, &(state->x.have)) + == -1) + return -1; + + state->x.next = state->out; return 0; - break; - case COPY: /* -> COPY */ - if (gz_load(state, state->out, state->size << 1, &(state->x.have)) - == -1) - return -1; - state->x.next = state->out; - return 0; - case GZIP: /* -> GZIP or LOOK (if end of gzip stream) */ - strm->avail_out = state->size << 1; - strm->next_out = state->out; - if (gz_decomp(state) == -1) - return -1; + + case GZIP: /* -> GZIP or LOOK (if end of gzip stream) */ + strm->avail_out = state->size << 1; + strm->next_out = state->out; + + if (gz_decomp(state) == -1) + return -1; } - } while (state->x.have == 0 && (!state->eof || strm->avail_in)); + } + while (state->x.have == 0 && (!state->eof || strm->avail_in)); + return 0; } @@ -276,16 +330,18 @@ local int gz_fetch(state) local int gz_skip(gz_statep state, z_off64_t len) #else local int gz_skip(state, len) - gz_statep state; - z_off64_t len; +gz_statep state; +z_off64_t len; #endif { unsigned n; /* skip over len bytes or reach end-of-file, whichever comes first */ while (len) + /* skip over whatever is in output buffer */ - if (state->x.have) { + if (state->x.have) + { n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ? (unsigned)len : state->x.have; state->x.have -= n; @@ -294,16 +350,18 @@ local int gz_skip(state, len) len -= n; } - /* output buffer empty -- return if we're at the end of the input */ + /* output buffer empty -- return if we're at the end of the input */ else if (state->eof && state->strm.avail_in == 0) break; - /* need more data to skip -- load up output buffer */ - else { + /* need more data to skip -- load up output buffer */ + else + { /* get more output, looking for header if required */ if (gz_fetch(state) == -1) return -1; } + return 0; } @@ -312,9 +370,9 @@ local int gz_skip(state, len) int ZEXPORT gzread(gzFile file, voidp buf, unsigned len) #else int ZEXPORT gzread(file, buf, len) - gzFile file; - voidp buf; - unsigned len; +gzFile file; +voidp buf; +unsigned len; #endif { unsigned got, n; @@ -324,6 +382,7 @@ int ZEXPORT gzread(file, buf, len) /* get internal structure */ if (file == NULL) return -1; + state = (gz_statep)file; strm = &(state->strm); @@ -334,7 +393,8 @@ int ZEXPORT gzread(file, buf, len) /* since an int is returned, make sure len fits in one, otherwise return with an error (this avoids the flaw in the interface) */ - if ((int)len < 0) { + if ((int)len < 0) + { gz_error(state, Z_DATA_ERROR, "requested length does not fit in int"); return -1; } @@ -344,17 +404,22 @@ int ZEXPORT gzread(file, buf, len) return 0; /* process a skip request */ - if (state->seek) { + if (state->seek) + { state->seek = 0; + if (gz_skip(state, state->skip) == -1) return -1; } /* get len bytes to buf, or less than len if at the end */ got = 0; - do { + + do + { /* first just try copying data from the output buffer */ - if (state->x.have) { + if (state->x.have) + { n = state->x.have > len ? len : state->x.have; memcpy(buf, state->x.next, n); state->x.next += n; @@ -362,44 +427,52 @@ int ZEXPORT gzread(file, buf, len) } /* output buffer empty -- return if we're at the end of the input */ - else if (state->eof && strm->avail_in == 0) { + else if (state->eof && strm->avail_in == 0) + { state->past = 1; /* tried to read past end */ break; } /* need output data -- for small len or new stream load up our output buffer */ - else if (state->how == LOOK || len < (state->size << 1)) { + else if (state->how == LOOK || len < (state->size << 1)) + { /* get more output, looking for header if required */ if (gz_fetch(state) == -1) return -1; + continue; /* no progress yet -- go back to copy above */ /* the copy above assures that we will leave with space in the output buffer, allowing at least one gzungetc() to succeed */ } /* large len -- read directly into user buffer */ - else if (state->how == COPY) { /* read directly */ + else if (state->how == COPY) /* read directly */ + { if (gz_load(state, buf, len, &n) == -1) return -1; } /* large len -- decompress directly into user buffer */ - else { /* state->how == GZIP */ + else /* state->how == GZIP */ + { strm->avail_out = len; strm->next_out = buf; + if (gz_decomp(state) == -1) return -1; + n = state->x.have; state->x.have = 0; } /* update progress */ len -= n; - buf = (char *)buf + n; + buf = (char*)buf + n; got += n; state->x.pos += n; - } while (len); + } + while (len); /* return number of bytes read into user buffer (will fit in int) */ return (int)got; @@ -411,7 +484,7 @@ int ZEXPORT gzread(file, buf, len) int ZEXPORT gzgetc(gzFile file) #else int ZEXPORT gzgetc(file) - gzFile file; +gzFile file; #endif { int ret; @@ -421,15 +494,17 @@ int ZEXPORT gzgetc(file) /* get internal structure */ if (file == NULL) return -1; + state = (gz_statep)file; /* check that we're reading and that there's no (serious) error */ if (state->mode != GZ_READ || - (state->err != Z_OK && state->err != Z_BUF_ERROR)) + (state->err != Z_OK && state->err != Z_BUF_ERROR)) return -1; /* try output buffer (no need to check for skip request) */ - if (state->x.have) { + if (state->x.have) + { state->x.have--; state->x.pos++; return *(state->x.next)++; @@ -455,8 +530,8 @@ gzFile file; int ZEXPORT gzungetc(signed char c, gzFile file) #else int ZEXPORT gzungetc(c, file) - int c; - gzFile file; +int c; +gzFile file; #endif { gz_statep state; @@ -464,16 +539,19 @@ int ZEXPORT gzungetc(c, file) /* get internal structure */ if (file == NULL) return -1; + state = (gz_statep)file; /* check that we're reading and that there's no (serious) error */ if (state->mode != GZ_READ || - (state->err != Z_OK && state->err != Z_BUF_ERROR)) + (state->err != Z_OK && state->err != Z_BUF_ERROR)) return -1; /* process a skip request */ - if (state->seek) { + if (state->seek) + { state->seek = 0; + if (gz_skip(state, state->skip) == -1) return -1; } @@ -483,7 +561,8 @@ int ZEXPORT gzungetc(c, file) return -1; /* if output buffer empty, put byte at end (allows more pushing) */ - if (state->x.have == 0) { + if (state->x.have == 0) + { state->x.have = 1; state->x.next = state->out + (state->size << 1) - 1; state->x.next[0] = c; @@ -493,19 +572,24 @@ int ZEXPORT gzungetc(c, file) } /* if no room, give up (must have already done a gzungetc()) */ - if (state->x.have == (state->size << 1)) { + if (state->x.have == (state->size << 1)) + { gz_error(state, Z_DATA_ERROR, "out of room to push characters"); return -1; } /* slide output data if needed and insert byte before existing data */ - if (state->x.next == state->out) { - unsigned char *src = state->out + state->x.have; - unsigned char *dest = state->out + (state->size << 1); + if (state->x.next == state->out) + { + unsigned char* src = state->out + state->x.have; + unsigned char* dest = state->out + (state->size << 1); + while (src > state->out) *--dest = *--src; + state->x.next = dest; } + state->x.have++; state->x.next--; state->x.next[0] = c; @@ -516,32 +600,35 @@ int ZEXPORT gzungetc(c, file) /* -- see zlib.h -- */ #ifdef WIN32 -char * ZEXPORT gzgets(gzFile file, char *buf, int len) +char* ZEXPORT gzgets(gzFile file, char* buf, int len) #else -char * ZEXPORT gzgets(file, buf, len) - gzFile file; - char *buf; - int len; +char* ZEXPORT gzgets(file, buf, len) +gzFile file; +char* buf; +int len; #endif { unsigned left, n; - char *str; - unsigned char *eol; + char* str; + unsigned char* eol; gz_statep state; /* check parameters and get internal structure */ if (file == NULL || buf == NULL || len < 1) return NULL; + state = (gz_statep)file; /* check that we're reading and that there's no (serious) error */ if (state->mode != GZ_READ || - (state->err != Z_OK && state->err != Z_BUF_ERROR)) + (state->err != Z_OK && state->err != Z_BUF_ERROR)) return NULL; /* process a skip request */ - if (state->seek) { + if (state->seek) + { state->seek = 0; + if (gz_skip(state, state->skip) == -1) return NULL; } @@ -551,33 +638,40 @@ char * ZEXPORT gzgets(file, buf, len) the contents, let the user worry about that) */ str = buf; left = (unsigned)len - 1; - if (left) do { - /* assure that something is in the output buffer */ - if (state->x.have == 0 && gz_fetch(state) == -1) - return NULL; /* error */ - if (state->x.have == 0) { /* end of file */ - state->past = 1; /* read past end */ - break; /* return what we have */ + + if (left) do + { + /* assure that something is in the output buffer */ + if (state->x.have == 0 && gz_fetch(state) == -1) + return NULL; /* error */ + + if (state->x.have == 0) /* end of file */ + { + state->past = 1; /* read past end */ + break; /* return what we have */ + } + + /* look for end-of-line in current output buffer */ + n = state->x.have > left ? left : state->x.have; + eol = memchr(state->x.next, '\n', n); + + if (eol != NULL) + n = (unsigned)(eol - state->x.next) + 1; + + /* copy through end-of-line, or remainder if not found */ + memcpy(buf, state->x.next, n); + state->x.have -= n; + state->x.next += n; + state->x.pos += n; + left -= n; + buf += n; } - - /* look for end-of-line in current output buffer */ - n = state->x.have > left ? left : state->x.have; - eol = memchr(state->x.next, '\n', n); - if (eol != NULL) - n = (unsigned)(eol - state->x.next) + 1; - - /* copy through end-of-line, or remainder if not found */ - memcpy(buf, state->x.next, n); - state->x.have -= n; - state->x.next += n; - state->x.pos += n; - left -= n; - buf += n; - } while (left && eol == NULL); + while (left && eol == NULL); /* return terminated string, or if nothing, end of file */ if (buf == str) return NULL; + buf[0] = 0; return str; } @@ -587,7 +681,7 @@ char * ZEXPORT gzgets(file, buf, len) int ZEXPORT gzdirect(gzFile file) #else int ZEXPORT gzdirect(file) - gzFile file; +gzFile file; #endif { gz_statep state; @@ -595,6 +689,7 @@ int ZEXPORT gzdirect(file) /* get internal structure */ if (file == NULL) return 0; + state = (gz_statep)file; /* if the state is not known, but we can find out, then do so (this is @@ -611,7 +706,7 @@ int ZEXPORT gzdirect(file) int ZEXPORT gzclose_r(gzFile file) #else int ZEXPORT gzclose_r(file) - gzFile file; +gzFile file; #endif { int ret, err; @@ -620,6 +715,7 @@ int ZEXPORT gzclose_r(file) /* get internal structure */ if (file == NULL) return Z_STREAM_ERROR; + state = (gz_statep)file; /* check that we're reading */ @@ -627,11 +723,13 @@ int ZEXPORT gzclose_r(file) return Z_STREAM_ERROR; /* free memory and close file */ - if (state->size) { + if (state->size) + { inflateEnd(&(state->strm)); free(state->out); free(state->in); } + err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK; gz_error(state, Z_OK, NULL); free(state->path); diff --git a/extern/zlib/gzwrite.c b/extern/zlib/gzwrite.c index 46f0ab4..21fad62 100644 --- a/extern/zlib/gzwrite.c +++ b/extern/zlib/gzwrite.c @@ -16,7 +16,7 @@ local int gz_zero OF((gz_statep, z_off64_t)); local int gz_init(gz_statep state) #else local int gz_init(state) - gz_statep state; +gz_statep state; #endif { int ret; @@ -24,16 +24,21 @@ local int gz_init(state) /* allocate input buffer */ state->in = malloc(state->want); - if (state->in == NULL) { + + if (state->in == NULL) + { gz_error(state, Z_MEM_ERROR, "out of memory"); return -1; } /* only need output buffer and deflate state if compressing */ - if (!state->direct) { + if (!state->direct) + { /* allocate output buffer */ state->out = malloc(state->want); - if (state->out == NULL) { + + if (state->out == NULL) + { free(state->in); gz_error(state, Z_MEM_ERROR, "out of memory"); return -1; @@ -45,7 +50,9 @@ local int gz_init(state) strm->opaque = Z_NULL; ret = deflateInit2(strm, state->level, Z_DEFLATED, MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy); - if (ret != Z_OK) { + + if (ret != Z_OK) + { free(state->out); free(state->in); gz_error(state, Z_MEM_ERROR, "out of memory"); @@ -57,11 +64,13 @@ local int gz_init(state) state->size = state->want; /* initialize write buffer if compressing */ - if (!state->direct) { + if (!state->direct) + { strm->avail_out = state->size; strm->next_out = state->out; state->x.next = strm->next_out; } + return 0; } @@ -75,8 +84,8 @@ local int gz_init(state) local int gz_comp(gz_statep state, int flush) #else local int gz_comp(state, flush) - gz_statep state; - int flush; +gz_statep state; +int flush; #endif { int ret, got; @@ -88,46 +97,62 @@ local int gz_comp(state, flush) return -1; /* write directly if requested */ - if (state->direct) { + if (state->direct) + { got = write(state->fd, strm->next_in, strm->avail_in); - if (got < 0 || (unsigned)got != strm->avail_in) { + + if (got < 0 || (unsigned)got != strm->avail_in) + { gz_error(state, Z_ERRNO, zstrerror()); return -1; } + strm->avail_in = 0; return 0; } /* run deflate() on provided input until it produces no more output */ ret = Z_OK; - do { + + do + { /* write out current buffer contents if full, or if flushing, but if doing Z_FINISH then don't write until we get to Z_STREAM_END */ if (strm->avail_out == 0 || (flush != Z_NO_FLUSH && - (flush != Z_FINISH || ret == Z_STREAM_END))) { + (flush != Z_FINISH || ret == Z_STREAM_END))) + { have = (unsigned)(strm->next_out - state->x.next); + if (have && ((got = write(state->fd, state->x.next, have)) < 0 || - (unsigned)got != have)) { + (unsigned)got != have)) + { gz_error(state, Z_ERRNO, zstrerror()); return -1; } - if (strm->avail_out == 0) { + + if (strm->avail_out == 0) + { strm->avail_out = state->size; strm->next_out = state->out; } + state->x.next = strm->next_out; } /* compress */ have = strm->avail_out; ret = deflate(strm, flush); - if (ret == Z_STREAM_ERROR) { + + if (ret == Z_STREAM_ERROR) + { gz_error(state, Z_STREAM_ERROR, - "internal error: deflate stream corrupt"); + "internal error: deflate stream corrupt"); return -1; } + have -= strm->avail_out; - } while (have); + } + while (have); /* if that completed a deflate stream, allow another to start */ if (flush == Z_FINISH) @@ -142,8 +167,8 @@ local int gz_comp(state, flush) local int gz_zero(gz_statep state, z_off64_t len) #else local int gz_zero(state, len) - gz_statep state; - z_off64_t len; +gz_statep state; +z_off64_t len; #endif { int first; @@ -156,20 +181,28 @@ local int gz_zero(state, len) /* compress len zeros (len guaranteed > 0) */ first = 1; - while (len) { + + while (len) + { n = GT_OFF(state->size) || (z_off64_t)state->size > len ? (unsigned)len : state->size; - if (first) { + + if (first) + { memset(state->in, 0, n); first = 0; } + strm->avail_in = n; strm->next_in = state->in; state->x.pos += n; + if (gz_comp(state, Z_NO_FLUSH) == -1) return -1; + len -= n; } + return 0; } @@ -178,9 +211,9 @@ local int gz_zero(state, len) int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len) #else int ZEXPORT gzwrite(file, buf, len) - gzFile file; - voidpc buf; - unsigned len; +gzFile file; +voidpc buf; +unsigned len; #endif { unsigned put = len; @@ -191,6 +224,7 @@ int ZEXPORT gzwrite(file, buf, len) /* get internal structure */ if (file == NULL) return 0; + state = (gz_statep)file; strm = &(state->strm); @@ -200,7 +234,8 @@ int ZEXPORT gzwrite(file, buf, len) /* since an int is returned, make sure len fits in one, otherwise return with an error (this avoids the flaw in the interface) */ - if ((int)len < 0) { + if ((int)len < 0) + { gz_error(state, Z_DATA_ERROR, "requested length does not fit in int"); return 0; } @@ -214,31 +249,41 @@ int ZEXPORT gzwrite(file, buf, len) return 0; /* check for seek request */ - if (state->seek) { + if (state->seek) + { state->seek = 0; + if (gz_zero(state, state->skip) == -1) return 0; } /* for small len, copy to input buffer, otherwise compress directly */ - if (len < state->size) { + if (len < state->size) + { /* copy to input buffer, compress when full */ - do { + do + { if (strm->avail_in == 0) strm->next_in = state->in; + n = state->size - strm->avail_in; + if (n > len) n = len; + memcpy(strm->next_in + strm->avail_in, buf, n); strm->avail_in += n; state->x.pos += n; - buf = (char *)buf + n; + buf = (char*)buf + n; len -= n; + if (len && gz_comp(state, Z_NO_FLUSH) == -1) return 0; - } while (len); + } + while (len); } - else { + else + { /* consume whatever's left in the input buffer */ if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) return 0; @@ -247,6 +292,7 @@ int ZEXPORT gzwrite(file, buf, len) strm->avail_in = len; strm->next_in = (voidp)buf; state->x.pos += len; + if (gz_comp(state, Z_NO_FLUSH) == -1) return 0; } @@ -260,8 +306,8 @@ int ZEXPORT gzwrite(file, buf, len) int ZEXPORT gzputc(gzFile file, unsigned char c) #else int ZEXPORT gzputc(file, c) - gzFile file; - int c; +gzFile file; +int c; #endif { unsigned char buf[1]; @@ -271,6 +317,7 @@ int ZEXPORT gzputc(file, c) /* get internal structure */ if (file == NULL) return -1; + state = (gz_statep)file; strm = &(state->strm); @@ -279,17 +326,21 @@ int ZEXPORT gzputc(file, c) return -1; /* check for seek request */ - if (state->seek) { + if (state->seek) + { state->seek = 0; + if (gz_zero(state, state->skip) == -1) return -1; } /* try writing to input buffer for speed (state->size == 0 if buffer not initialized) */ - if (strm->avail_in < state->size) { + if (strm->avail_in < state->size) + { if (strm->avail_in == 0) strm->next_in = state->in; + strm->next_in[strm->avail_in++] = c; state->x.pos++; return c & 0xff; @@ -297,18 +348,20 @@ int ZEXPORT gzputc(file, c) /* no room in buffer or not initialized, use gz_write() */ buf[0] = c; + if (gzwrite(file, buf, 1) != 1) return -1; + return c & 0xff; } /* -- see zlib.h -- */ #ifdef WIN32 -int ZEXPORT gzputs(gzFile file, const char *str) +int ZEXPORT gzputs(gzFile file, const char* str) #else int ZEXPORT gzputs(file, str) - gzFile file; - const char *str; +gzFile file; +const char* str; #endif { int ret; @@ -324,7 +377,7 @@ int ZEXPORT gzputs(file, str) #include /* -- see zlib.h -- */ -int ZEXPORTVA gzprintf (gzFile file, const char *format, ...) +int ZEXPORTVA gzprintf(gzFile file, const char* format, ...) { int size, len; gz_statep state; @@ -334,6 +387,7 @@ int ZEXPORTVA gzprintf (gzFile file, const char *format, ...) /* get internal structure */ if (file == NULL) return -1; + state = (gz_statep)file; strm = &(state->strm); @@ -346,8 +400,10 @@ int ZEXPORTVA gzprintf (gzFile file, const char *format, ...) return 0; /* check for seek request */ - if (state->seek) { + if (state->seek) + { state->seek = 0; + if (gz_zero(state, state->skip) == -1) return 0; } @@ -362,21 +418,23 @@ int ZEXPORTVA gzprintf (gzFile file, const char *format, ...) va_start(va, format); #ifdef NO_vsnprintf # ifdef HAS_vsprintf_void - (void)vsprintf((char *)(state->in), format, va); + (void)vsprintf((char*)(state->in), format, va); va_end(va); + for (len = 0; len < size; len++) if (state->in[len] == 0) break; + # else - len = vsprintf((char *)(state->in), format, va); + len = vsprintf((char*)(state->in), format, va); va_end(va); # endif #else # ifdef HAS_vsnprintf_void - (void)vsnprintf((char *)(state->in), size, format, va); + (void)vsnprintf((char*)(state->in), size, format, va); va_end(va); - len = strlen((char *)(state->in)); + len = strlen((char*)(state->in)); # else - len = vsnprintf((char *)(state->in), size, format, va); + len = vsnprintf((char*)(state->in), size, format, va); va_end(va); # endif #endif @@ -395,12 +453,12 @@ int ZEXPORTVA gzprintf (gzFile file, const char *format, ...) #else /* !STDC && !Z_HAVE_STDARG_H */ /* -- see zlib.h -- */ -int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, +int ZEXPORTVA gzprintf(file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) - gzFile file; - const char *format; - int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, - a11, a12, a13, a14, a15, a16, a17, a18, a19, a20; +gzFile file; +const char* format; +int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, + a11, a12, a13, a14, a15, a16, a17, a18, a19, a20; { int size, len; gz_statep state; @@ -409,11 +467,12 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, /* get internal structure */ if (file == NULL) return -1; + state = (gz_statep)file; strm = &(state->strm); /* check that can really pass pointer in ints */ - if (sizeof(int) != sizeof(void *)) + if (sizeof(int) != sizeof(void*)) return 0; /* check that we're writing and that there's no error */ @@ -425,8 +484,10 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, return 0; /* check for seek request */ - if (state->seek) { + if (state->seek) + { state->seek = 0; + if (gz_zero(state, state->skip) == -1) return 0; } @@ -440,21 +501,23 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, state->in[size - 1] = 0; #ifdef NO_snprintf # ifdef HAS_sprintf_void - sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8, + sprintf((char*)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); + for (len = 0; len < size; len++) if (state->in[len] == 0) break; + # else - len = sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8, + len = sprintf((char*)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); # endif #else # ifdef HAS_snprintf_void - snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8, + snprintf((char*)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); - len = strlen((char *)(state->in)); + len = strlen((char*)(state->in)); # else - len = snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, + len = snprintf((char*)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); # endif @@ -478,8 +541,8 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, int ZEXPORT gzflush(gzFile file, int flush) #else int ZEXPORT gzflush(file, flush) - gzFile file; - int flush; +gzFile file; +int flush; #endif { gz_statep state; @@ -487,6 +550,7 @@ int ZEXPORT gzflush(file, flush) /* get internal structure */ if (file == NULL) return -1; + state = (gz_statep)file; /* check that we're writing and that there's no error */ @@ -498,8 +562,10 @@ int ZEXPORT gzflush(file, flush) return Z_STREAM_ERROR; /* check for seek request */ - if (state->seek) { + if (state->seek) + { state->seek = 0; + if (gz_zero(state, state->skip) == -1) return -1; } @@ -514,9 +580,9 @@ int ZEXPORT gzflush(file, flush) int ZEXPORT gzsetparams(gzFile file, int level, int strategy) #else int ZEXPORT gzsetparams(file, level, strategy) - gzFile file; - int level; - int strategy; +gzFile file; +int level; +int strategy; #endif { gz_statep state; @@ -525,6 +591,7 @@ int ZEXPORT gzsetparams(file, level, strategy) /* get internal structure */ if (file == NULL) return Z_STREAM_ERROR; + state = (gz_statep)file; strm = &(state->strm); @@ -537,19 +604,24 @@ int ZEXPORT gzsetparams(file, level, strategy) return Z_OK; /* check for seek request */ - if (state->seek) { + if (state->seek) + { state->seek = 0; + if (gz_zero(state, state->skip) == -1) return -1; } /* change compression parameters for subsequent input */ - if (state->size) { + if (state->size) + { /* flush previous input with previous parameters before changing */ if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1) return state->err; + deflateParams(strm, level, strategy); } + state->level = level; state->strategy = strategy; return Z_OK; @@ -560,7 +632,7 @@ int ZEXPORT gzsetparams(file, level, strategy) int ZEXPORT gzclose_w(gzFile file) #else int ZEXPORT gzclose_w(file) - gzFile file; +gzFile file; #endif { int ret = Z_OK; @@ -569,6 +641,7 @@ int ZEXPORT gzclose_w(file) /* get internal structure */ if (file == NULL) return Z_STREAM_ERROR; + state = (gz_statep)file; /* check that we're writing */ @@ -576,26 +649,35 @@ int ZEXPORT gzclose_w(file) return Z_STREAM_ERROR; /* check for seek request */ - if (state->seek) { + if (state->seek) + { state->seek = 0; + if (gz_zero(state, state->skip) == -1) ret = state->err; } /* flush, free memory, and close file */ - if (state->size) { + if (state->size) + { if (gz_comp(state, Z_FINISH) == -1) ret = state->err; - if (!state->direct) { + + if (!state->direct) + { (void)deflateEnd(&(state->strm)); free(state->out); } + free(state->in); } + gz_error(state, Z_OK, NULL); free(state->path); + if (close(state->fd) == -1) ret = Z_ERRNO; + free(state); return ret; } diff --git a/extern/zlib/infback.c b/extern/zlib/infback.c index aa0c5b9..0c5f563 100644 --- a/extern/zlib/infback.c +++ b/extern/zlib/infback.c @@ -33,7 +33,7 @@ while (0) \ #endif /* function prototypes */ -local void fixedtables OF((struct inflate_state FAR *state)); +local void fixedtables OF((struct inflate_state FAR* state)); /* strm provides memory allocation functions in zalloc and zfree, or @@ -43,26 +43,30 @@ local void fixedtables OF((struct inflate_state FAR *state)); window and output buffer that is 2**windowBits bytes. */ #ifdef WIN32 -int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, unsigned char FAR *window, const char *version, int stream_size) +int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits, unsigned char FAR* window, const char* version, int stream_size) #else int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size) z_streamp strm; int windowBits; -unsigned char FAR *window; -const char *version; +unsigned char FAR* window; +const char* version; int stream_size; #endif { - struct inflate_state FAR *state; + struct inflate_state FAR* state; if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || - stream_size != (int)(sizeof(z_stream))) + stream_size != (int)(sizeof(z_stream))) return Z_VERSION_ERROR; + if (strm == Z_NULL || window == Z_NULL || - windowBits < 8 || windowBits > 15) + windowBits < 8 || windowBits > 15) return Z_STREAM_ERROR; + strm->msg = Z_NULL; /* in case we return an error */ - if (strm->zalloc == (alloc_func)0) { + + if (strm->zalloc == (alloc_func)0) + { #ifdef Z_SOLO return Z_STREAM_ERROR; #else @@ -70,17 +74,21 @@ int stream_size; strm->opaque = (voidpf)0; #endif } + if (strm->zfree == (free_func)0) #ifdef Z_SOLO return Z_STREAM_ERROR; + #else - strm->zfree = zcfree; + strm->zfree = zcfree; #endif - state = (struct inflate_state FAR *)ZALLOC(strm, 1, - sizeof(struct inflate_state)); + state = (struct inflate_state FAR*)ZALLOC(strm, 1, + sizeof(struct inflate_state)); + if (state == Z_NULL) return Z_MEM_ERROR; + Tracev((stderr, "inflate: allocated\n")); - strm->state = (struct internal_state FAR *)state; + strm->state = (struct internal_state FAR*)state; state->dmax = 32768U; state->wbits = windowBits; state->wsize = 1U << windowBits; @@ -101,28 +109,34 @@ int stream_size; may not be thread-safe. */ #ifdef WIN32 -local void fixedtables(struct inflate_state FAR *state) +local void fixedtables(struct inflate_state FAR* state) #else local void fixedtables(state) -struct inflate_state FAR *state; +struct inflate_state FAR* state; #endif { #ifdef BUILDFIXED static int virgin = 1; - static code *lenfix, *distfix; + static code* lenfix, *distfix; static code fixed[544]; /* build fixed huffman tables if first call (may not be thread safe) */ - if (virgin) { + if (virgin) + { unsigned sym, bits; - static code *next; + static code* next; /* literal/length table */ sym = 0; + while (sym < 144) state->lens[sym++] = 8; + while (sym < 256) state->lens[sym++] = 9; + while (sym < 280) state->lens[sym++] = 7; + while (sym < 288) state->lens[sym++] = 8; + next = fixed; lenfix = next; bits = 9; @@ -130,7 +144,9 @@ struct inflate_state FAR *state; /* distance table */ sym = 0; + while (sym < 32) state->lens[sym++] = 5; + distfix = next; bits = 5; inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); @@ -138,6 +154,7 @@ struct inflate_state FAR *state; /* do this just once */ virgin = 0; } + #else /* !BUILDFIXED */ # include "inffixed.h" #endif /* BUILDFIXED */ @@ -273,35 +290,36 @@ struct inflate_state FAR *state; are not correct, i.e. strm is Z_NULL or the state was not initialized. */ #ifdef WIN32 -int ZEXPORT inflateBack(z_streamp strm, in_func in, void FAR *in_desc, out_func out, void FAR *out_desc) +int ZEXPORT inflateBack(z_streamp strm, in_func in, void FAR* in_desc, out_func out, void FAR* out_desc) #else int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc) z_streamp strm; in_func in; -void FAR *in_desc; +void FAR* in_desc; out_func out; -void FAR *out_desc; +void FAR* out_desc; #endif { - struct inflate_state FAR *state; - unsigned char FAR *next; /* next input */ - unsigned char FAR *put; /* next output */ + struct inflate_state FAR* state; + unsigned char FAR* next; /* next input */ + unsigned char FAR* put; /* next output */ unsigned have, left; /* available input and output */ unsigned long hold; /* bit buffer */ unsigned bits; /* bits in bit buffer */ unsigned copy; /* number of stored or match bytes to copy */ - unsigned char FAR *from; /* where to copy match bytes from */ + unsigned char FAR* from; /* where to copy match bytes from */ code here; /* current decoding table entry */ code last; /* parent table entry */ unsigned len; /* length to copy for repeats, bits to drop */ int ret; /* return code */ static const unsigned short order[19] = /* permutation of code lengths */ - {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; /* Check that the strm exists and that the state was initialized */ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; + + state = (struct inflate_state FAR*)strm->state; /* Reset the state */ strm->msg = Z_NULL; @@ -317,341 +335,447 @@ void FAR *out_desc; /* Inflate until end of block marked as last */ for (;;) - switch (state->mode) { - case TYPE: - /* determine and dispatch block type */ - if (state->last) { - BYTEBITS(); - state->mode = DONE; - break; - } - NEEDBITS(3); - state->last = BITS(1); - DROPBITS(1); - switch (BITS(2)) { - case 0: /* stored block */ - Tracev((stderr, "inflate: stored block%s\n", - state->last ? " (last)" : "")); - state->mode = STORED; - break; - case 1: /* fixed block */ - fixedtables(state); - Tracev((stderr, "inflate: fixed codes block%s\n", - state->last ? " (last)" : "")); - state->mode = LEN; /* decode codes */ - break; - case 2: /* dynamic block */ - Tracev((stderr, "inflate: dynamic codes block%s\n", - state->last ? " (last)" : "")); - state->mode = TABLE; - break; - case 3: - strm->msg = (char *)"invalid block type"; - state->mode = BAD; - } - DROPBITS(2); - break; + switch (state->mode) + { + case TYPE: - case STORED: - /* get and verify stored block length */ - BYTEBITS(); /* go to byte boundary */ - NEEDBITS(32); - if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { - strm->msg = (char *)"invalid stored block lengths"; - state->mode = BAD; - break; - } - state->length = (unsigned)hold & 0xffff; - Tracev((stderr, "inflate: stored length %u\n", - state->length)); - INITBITS(); + /* determine and dispatch block type */ + if (state->last) + { + BYTEBITS(); + state->mode = DONE; + break; + } - /* copy stored block from input to output */ - while (state->length != 0) { - copy = state->length; - PULL(); - ROOM(); - if (copy > have) copy = have; - if (copy > left) copy = left; - zmemcpy(put, next, copy); - have -= copy; - next += copy; - left -= copy; - put += copy; - state->length -= copy; - } - Tracev((stderr, "inflate: stored end\n")); - state->mode = TYPE; - break; - - case TABLE: - /* get dynamic table entries descriptor */ - NEEDBITS(14); - state->nlen = BITS(5) + 257; - DROPBITS(5); - state->ndist = BITS(5) + 1; - DROPBITS(5); - state->ncode = BITS(4) + 4; - DROPBITS(4); -#ifndef PKZIP_BUG_WORKAROUND - if (state->nlen > 286 || state->ndist > 30) { - strm->msg = (char *)"too many length or distance symbols"; - state->mode = BAD; - break; - } -#endif - Tracev((stderr, "inflate: table sizes ok\n")); - - /* get code length code lengths (not a typo) */ - state->have = 0; - while (state->have < state->ncode) { NEEDBITS(3); - state->lens[order[state->have++]] = (unsigned short)BITS(3); - DROPBITS(3); - } - while (state->have < 19) - state->lens[order[state->have++]] = 0; - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 7; - ret = inflate_table(CODES, state->lens, 19, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid code lengths set"; - state->mode = BAD; - break; - } - Tracev((stderr, "inflate: code lengths ok\n")); + state->last = BITS(1); + DROPBITS(1); - /* get length and distance code code lengths */ - state->have = 0; - while (state->have < state->nlen + state->ndist) { - for (;;) { - here = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); + switch (BITS(2)) + { + case 0: /* stored block */ + Tracev((stderr, "inflate: stored block%s\n", + state->last ? " (last)" : "")); + state->mode = STORED; + break; + + case 1: /* fixed block */ + fixedtables(state); + Tracev((stderr, "inflate: fixed codes block%s\n", + state->last ? " (last)" : "")); + state->mode = LEN; /* decode codes */ + break; + + case 2: /* dynamic block */ + Tracev((stderr, "inflate: dynamic codes block%s\n", + state->last ? " (last)" : "")); + state->mode = TABLE; + break; + + case 3: + strm->msg = (char*)"invalid block type"; + state->mode = BAD; } - if (here.val < 16) { - DROPBITS(here.bits); - state->lens[state->have++] = here.val; + + DROPBITS(2); + break; + + case STORED: + /* get and verify stored block length */ + BYTEBITS(); /* go to byte boundary */ + NEEDBITS(32); + + if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) + { + strm->msg = (char*)"invalid stored block lengths"; + state->mode = BAD; + break; } - else { - if (here.val == 16) { - NEEDBITS(here.bits + 2); + + state->length = (unsigned)hold & 0xffff; + Tracev((stderr, "inflate: stored length %u\n", + state->length)); + INITBITS(); + + /* copy stored block from input to output */ + while (state->length != 0) + { + copy = state->length; + PULL(); + ROOM(); + + if (copy > have) copy = have; + + if (copy > left) copy = left; + + zmemcpy(put, next, copy); + have -= copy; + next += copy; + left -= copy; + put += copy; + state->length -= copy; + } + + Tracev((stderr, "inflate: stored end\n")); + state->mode = TYPE; + break; + + case TABLE: + /* get dynamic table entries descriptor */ + NEEDBITS(14); + state->nlen = BITS(5) + 257; + DROPBITS(5); + state->ndist = BITS(5) + 1; + DROPBITS(5); + state->ncode = BITS(4) + 4; + DROPBITS(4); +#ifndef PKZIP_BUG_WORKAROUND + + if (state->nlen > 286 || state->ndist > 30) + { + strm->msg = (char*)"too many length or distance symbols"; + state->mode = BAD; + break; + } + +#endif + Tracev((stderr, "inflate: table sizes ok\n")); + + /* get code length code lengths (not a typo) */ + state->have = 0; + + while (state->have < state->ncode) + { + NEEDBITS(3); + state->lens[order[state->have++]] = (unsigned short)BITS(3); + DROPBITS(3); + } + + while (state->have < 19) + state->lens[order[state->have++]] = 0; + + state->next = state->codes; + state->lencode = (code const FAR*)(state->next); + state->lenbits = 7; + ret = inflate_table(CODES, state->lens, 19, &(state->next), + &(state->lenbits), state->work); + + if (ret) + { + strm->msg = (char*)"invalid code lengths set"; + state->mode = BAD; + break; + } + + Tracev((stderr, "inflate: code lengths ok\n")); + + /* get length and distance code code lengths */ + state->have = 0; + + while (state->have < state->nlen + state->ndist) + { + for (;;) + { + here = state->lencode[BITS(state->lenbits)]; + + if ((unsigned)(here.bits) <= bits) break; + + PULLBYTE(); + } + + if (here.val < 16) + { DROPBITS(here.bits); - if (state->have == 0) { - strm->msg = (char *)"invalid bit length repeat"; + state->lens[state->have++] = here.val; + } + else + { + if (here.val == 16) + { + NEEDBITS(here.bits + 2); + DROPBITS(here.bits); + + if (state->have == 0) + { + strm->msg = (char*)"invalid bit length repeat"; + state->mode = BAD; + break; + } + + len = (unsigned)(state->lens[state->have - 1]); + copy = 3 + BITS(2); + DROPBITS(2); + } + else if (here.val == 17) + { + NEEDBITS(here.bits + 3); + DROPBITS(here.bits); + len = 0; + copy = 3 + BITS(3); + DROPBITS(3); + } + else + { + NEEDBITS(here.bits + 7); + DROPBITS(here.bits); + len = 0; + copy = 11 + BITS(7); + DROPBITS(7); + } + + if (state->have + copy > state->nlen + state->ndist) + { + strm->msg = (char*)"invalid bit length repeat"; state->mode = BAD; break; } - len = (unsigned)(state->lens[state->have - 1]); - copy = 3 + BITS(2); - DROPBITS(2); + + while (copy--) + state->lens[state->have++] = (unsigned short)len; } - else if (here.val == 17) { - NEEDBITS(here.bits + 3); - DROPBITS(here.bits); - len = 0; - copy = 3 + BITS(3); - DROPBITS(3); - } - else { - NEEDBITS(here.bits + 7); - DROPBITS(here.bits); - len = 0; - copy = 11 + BITS(7); - DROPBITS(7); - } - if (state->have + copy > state->nlen + state->ndist) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; - break; - } - while (copy--) - state->lens[state->have++] = (unsigned short)len; } - } - /* handle error breaks in while */ - if (state->mode == BAD) break; + /* handle error breaks in while */ + if (state->mode == BAD) break; - /* check for end-of-block code (better have one) */ - if (state->lens[256] == 0) { - strm->msg = (char *)"invalid code -- missing end-of-block"; - state->mode = BAD; - break; - } - - /* build code tables -- note: do not change the lenbits or distbits - values here (9 and 6) without reading the comments in inftrees.h - concerning the ENOUGH constants, which depend on those values */ - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 9; - ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid literal/lengths set"; - state->mode = BAD; - break; - } - state->distcode = (code const FAR *)(state->next); - state->distbits = 6; - ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, - &(state->next), &(state->distbits), state->work); - if (ret) { - strm->msg = (char *)"invalid distances set"; - state->mode = BAD; - break; - } - Tracev((stderr, "inflate: codes ok\n")); - state->mode = LEN; - - case LEN: - /* use inflate_fast() if we have enough input and output */ - if (have >= 6 && left >= 258) { - RESTORE(); - if (state->whave < state->wsize) - state->whave = state->wsize - left; - inflate_fast(strm, state->wsize); - LOAD(); - break; - } - - /* get a literal, length, or end-of-block code */ - for (;;) { - here = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); - } - if (here.op && (here.op & 0xf0) == 0) { - last = here; - for (;;) { - here = state->lencode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + here.bits) <= bits) break; - PULLBYTE(); + /* check for end-of-block code (better have one) */ + if (state->lens[256] == 0) + { + strm->msg = (char*)"invalid code -- missing end-of-block"; + state->mode = BAD; + break; } - DROPBITS(last.bits); - } - DROPBITS(here.bits); - state->length = (unsigned)here.val; - /* process literal */ - if (here.op == 0) { - Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? - "inflate: literal '%c'\n" : - "inflate: literal 0x%02x\n", here.val)); - ROOM(); - *put++ = (unsigned char)(state->length); - left--; + /* build code tables -- note: do not change the lenbits or distbits + values here (9 and 6) without reading the comments in inftrees.h + concerning the ENOUGH constants, which depend on those values */ + state->next = state->codes; + state->lencode = (code const FAR*)(state->next); + state->lenbits = 9; + ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), + &(state->lenbits), state->work); + + if (ret) + { + strm->msg = (char*)"invalid literal/lengths set"; + state->mode = BAD; + break; + } + + state->distcode = (code const FAR*)(state->next); + state->distbits = 6; + ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, + &(state->next), &(state->distbits), state->work); + + if (ret) + { + strm->msg = (char*)"invalid distances set"; + state->mode = BAD; + break; + } + + Tracev((stderr, "inflate: codes ok\n")); state->mode = LEN; - break; - } - /* process end of block */ - if (here.op & 32) { - Tracevv((stderr, "inflate: end of block\n")); - state->mode = TYPE; - break; - } + case LEN: - /* invalid code */ - if (here.op & 64) { - strm->msg = (char *)"invalid literal/length code"; - state->mode = BAD; - break; - } + /* use inflate_fast() if we have enough input and output */ + if (have >= 6 && left >= 258) + { + RESTORE(); - /* length code -- get extra bits, if any */ - state->extra = (unsigned)(here.op) & 15; - if (state->extra != 0) { - NEEDBITS(state->extra); - state->length += BITS(state->extra); - DROPBITS(state->extra); - } - Tracevv((stderr, "inflate: length %u\n", state->length)); + if (state->whave < state->wsize) + state->whave = state->wsize - left; + + inflate_fast(strm, state->wsize); + LOAD(); + break; + } + + /* get a literal, length, or end-of-block code */ + for (;;) + { + here = state->lencode[BITS(state->lenbits)]; + + if ((unsigned)(here.bits) <= bits) break; - /* get distance code */ - for (;;) { - here = state->distcode[BITS(state->distbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); - } - if ((here.op & 0xf0) == 0) { - last = here; - for (;;) { - here = state->distcode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + here.bits) <= bits) break; PULLBYTE(); } - DROPBITS(last.bits); - } - DROPBITS(here.bits); - if (here.op & 64) { - strm->msg = (char *)"invalid distance code"; - state->mode = BAD; - break; - } - state->offset = (unsigned)here.val; - /* get distance extra bits, if any */ - state->extra = (unsigned)(here.op) & 15; - if (state->extra != 0) { - NEEDBITS(state->extra); - state->offset += BITS(state->extra); - DROPBITS(state->extra); - } - if (state->offset > state->wsize - (state->whave < state->wsize ? - left : 0)) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } - Tracevv((stderr, "inflate: distance %u\n", state->offset)); + if (here.op && (here.op & 0xf0) == 0) + { + last = here; - /* copy match from window to output */ - do { - ROOM(); - copy = state->wsize - state->offset; - if (copy < left) { - from = put + copy; - copy = left - copy; + for (;;) + { + here = state->lencode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + + if ((unsigned)(last.bits + here.bits) <= bits) break; + + PULLBYTE(); + } + + DROPBITS(last.bits); } - else { - from = put - state->offset; - copy = left; + + DROPBITS(here.bits); + state->length = (unsigned)here.val; + + /* process literal */ + if (here.op == 0) + { + Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", here.val)); + ROOM(); + *put++ = (unsigned char)(state->length); + left--; + state->mode = LEN; + break; } - if (copy > state->length) copy = state->length; - state->length -= copy; - left -= copy; - do { - *put++ = *from++; - } while (--copy); - } while (state->length != 0); - break; - case DONE: - /* inflate stream terminated properly -- write leftover output */ - ret = Z_STREAM_END; - if (left < state->wsize) { - if (out(out_desc, state->window, state->wsize - left)) - ret = Z_BUF_ERROR; - } - goto inf_leave; + /* process end of block */ + if (here.op & 32) + { + Tracevv((stderr, "inflate: end of block\n")); + state->mode = TYPE; + break; + } - case BAD: - ret = Z_DATA_ERROR; - goto inf_leave; + /* invalid code */ + if (here.op & 64) + { + strm->msg = (char*)"invalid literal/length code"; + state->mode = BAD; + break; + } - default: /* can't happen, but makes compilers happy */ - ret = Z_STREAM_ERROR; - goto inf_leave; + /* length code -- get extra bits, if any */ + state->extra = (unsigned)(here.op) & 15; + + if (state->extra != 0) + { + NEEDBITS(state->extra); + state->length += BITS(state->extra); + DROPBITS(state->extra); + } + + Tracevv((stderr, "inflate: length %u\n", state->length)); + + /* get distance code */ + for (;;) + { + here = state->distcode[BITS(state->distbits)]; + + if ((unsigned)(here.bits) <= bits) break; + + PULLBYTE(); + } + + if ((here.op & 0xf0) == 0) + { + last = here; + + for (;;) + { + here = state->distcode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + + if ((unsigned)(last.bits + here.bits) <= bits) break; + + PULLBYTE(); + } + + DROPBITS(last.bits); + } + + DROPBITS(here.bits); + + if (here.op & 64) + { + strm->msg = (char*)"invalid distance code"; + state->mode = BAD; + break; + } + + state->offset = (unsigned)here.val; + + /* get distance extra bits, if any */ + state->extra = (unsigned)(here.op) & 15; + + if (state->extra != 0) + { + NEEDBITS(state->extra); + state->offset += BITS(state->extra); + DROPBITS(state->extra); + } + + if (state->offset > state->wsize - (state->whave < state->wsize ? + left : 0)) + { + strm->msg = (char*)"invalid distance too far back"; + state->mode = BAD; + break; + } + + Tracevv((stderr, "inflate: distance %u\n", state->offset)); + + /* copy match from window to output */ + do + { + ROOM(); + copy = state->wsize - state->offset; + + if (copy < left) + { + from = put + copy; + copy = left - copy; + } + else + { + from = put - state->offset; + copy = left; + } + + if (copy > state->length) copy = state->length; + + state->length -= copy; + left -= copy; + + do + { + *put++ = *from++; + } + while (--copy); + } + while (state->length != 0); + + break; + + case DONE: + /* inflate stream terminated properly -- write leftover output */ + ret = Z_STREAM_END; + + if (left < state->wsize) + { + if (out(out_desc, state->window, state->wsize - left)) + ret = Z_BUF_ERROR; + } + + goto inf_leave; + + case BAD: + ret = Z_DATA_ERROR; + goto inf_leave; + + default: /* can't happen, but makes compilers happy */ + ret = Z_STREAM_ERROR; + goto inf_leave; } /* Return unused input */ - inf_leave: +inf_leave: strm->next_in = next; strm->avail_in = have; return ret; @@ -666,6 +790,7 @@ z_streamp strm; { if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) return Z_STREAM_ERROR; + ZFREE(strm, strm->state); strm->state = Z_NULL; Tracev((stderr, "inflate: end\n")); diff --git a/extern/zlib/inffast.c b/extern/zlib/inffast.c index beb4fde..397aa7c 100644 --- a/extern/zlib/inffast.c +++ b/extern/zlib/inffast.c @@ -72,34 +72,34 @@ z_streamp strm; unsigned start; /* inflate()'s starting value for strm->avail_out */ #endif { - struct inflate_state FAR *state; - unsigned char FAR *in; /* local strm->next_in */ - unsigned char FAR *last; /* while in < last, enough input available */ - unsigned char FAR *out; /* local strm->next_out */ - unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ - unsigned char FAR *end; /* while out < end, enough space available */ + struct inflate_state FAR* state; + unsigned char FAR* in; /* local strm->next_in */ + unsigned char FAR* last; /* while in < last, enough input available */ + unsigned char FAR* out; /* local strm->next_out */ + unsigned char FAR* beg; /* inflate()'s initial strm->next_out */ + unsigned char FAR* end; /* while out < end, enough space available */ #ifdef INFLATE_STRICT unsigned dmax; /* maximum distance from zlib header */ #endif unsigned wsize; /* window size or zero if not using window */ unsigned whave; /* valid bytes in the window */ unsigned wnext; /* window write index */ - unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ + unsigned char FAR* window; /* allocated sliding window, if wsize != 0 */ unsigned long hold; /* local strm->hold */ unsigned bits; /* local strm->bits */ - code const FAR *lcode; /* local strm->lencode */ - code const FAR *dcode; /* local strm->distcode */ + code const FAR* lcode; /* local strm->lencode */ + code const FAR* dcode; /* local strm->distcode */ unsigned lmask; /* mask for first level of length codes */ unsigned dmask; /* mask for first level of distance codes */ code here; /* retrieved table entry */ unsigned op; /* code bits, operation, extra bits, or */ - /* window position, window bytes to copy */ + /* window position, window bytes to copy */ unsigned len; /* match length, unused bytes */ unsigned dist; /* match distance */ - unsigned char FAR *from; /* where to copy match from */ + unsigned char FAR* from; /* where to copy match from */ /* copy state to local variables */ - state = (struct inflate_state FAR *)strm->state; + state = (struct inflate_state FAR*)strm->state; in = strm->next_in - OFF; last = in + (strm->avail_in - 5); out = strm->next_out - OFF; @@ -121,194 +121,287 @@ unsigned start; /* inflate()'s starting value for strm->avail_out */ /* decode literals and length/distances until end-of-block or not enough input data or output space */ - do { - if (bits < 15) { + do + { + if (bits < 15) + { hold += (unsigned long)(PUP(in)) << bits; bits += 8; hold += (unsigned long)(PUP(in)) << bits; bits += 8; } + here = lcode[hold & lmask]; - dolen: +dolen: op = (unsigned)(here.bits); hold >>= op; bits -= op; op = (unsigned)(here.op); - if (op == 0) { /* literal */ + + if (op == 0) /* literal */ + { Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? - "inflate: literal '%c'\n" : - "inflate: literal 0x%02x\n", here.val)); + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", here.val)); PUP(out) = (unsigned char)(here.val); } - else if (op & 16) { /* length base */ + else if (op & 16) /* length base */ + { len = (unsigned)(here.val); op &= 15; /* number of extra bits */ - if (op) { - if (bits < op) { + + if (op) + { + if (bits < op) + { hold += (unsigned long)(PUP(in)) << bits; bits += 8; } + len += (unsigned)hold & ((1U << op) - 1); hold >>= op; bits -= op; } + Tracevv((stderr, "inflate: length %u\n", len)); - if (bits < 15) { + + if (bits < 15) + { hold += (unsigned long)(PUP(in)) << bits; bits += 8; hold += (unsigned long)(PUP(in)) << bits; bits += 8; } + here = dcode[hold & dmask]; - dodist: +dodist: op = (unsigned)(here.bits); hold >>= op; bits -= op; op = (unsigned)(here.op); - if (op & 16) { /* distance base */ + + if (op & 16) /* distance base */ + { dist = (unsigned)(here.val); op &= 15; /* number of extra bits */ - if (bits < op) { + + if (bits < op) + { hold += (unsigned long)(PUP(in)) << bits; bits += 8; - if (bits < op) { + + if (bits < op) + { hold += (unsigned long)(PUP(in)) << bits; bits += 8; } } + dist += (unsigned)hold & ((1U << op) - 1); #ifdef INFLATE_STRICT - if (dist > dmax) { - strm->msg = (char *)"invalid distance too far back"; + + if (dist > dmax) + { + strm->msg = (char*)"invalid distance too far back"; state->mode = BAD; break; } + #endif hold >>= op; bits -= op; Tracevv((stderr, "inflate: distance %u\n", dist)); op = (unsigned)(out - beg); /* max distance in output */ - if (dist > op) { /* see if copy from window */ + + if (dist > op) /* see if copy from window */ + { op = dist - op; /* distance back in window */ - if (op > whave) { - if (state->sane) { + + if (op > whave) + { + if (state->sane) + { strm->msg = - (char *)"invalid distance too far back"; + (char*)"invalid distance too far back"; state->mode = BAD; break; } + #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR - if (len <= op - whave) { - do { + + if (len <= op - whave) + { + do + { PUP(out) = 0; - } while (--len); + } + while (--len); + continue; } + len -= op - whave; - do { + + do + { PUP(out) = 0; - } while (--op > whave); - if (op == 0) { + } + while (--op > whave); + + if (op == 0) + { from = out - dist; - do { + + do + { PUP(out) = PUP(from); - } while (--len); + } + while (--len); + continue; } + #endif } + from = window - OFF; - if (wnext == 0) { /* very common case */ + + if (wnext == 0) /* very common case */ + { from += wsize - op; - if (op < len) { /* some from window */ + + if (op < len) /* some from window */ + { len -= op; - do { + + do + { PUP(out) = PUP(from); - } while (--op); + } + while (--op); + from = out - dist; /* rest from output */ } } - else if (wnext < op) { /* wrap around window */ + else if (wnext < op) /* wrap around window */ + { from += wsize + wnext - op; op -= wnext; - if (op < len) { /* some from end of window */ + + if (op < len) /* some from end of window */ + { len -= op; - do { + + do + { PUP(out) = PUP(from); - } while (--op); + } + while (--op); + from = window - OFF; - if (wnext < len) { /* some from start of window */ + + if (wnext < len) /* some from start of window */ + { op = wnext; len -= op; - do { + + do + { PUP(out) = PUP(from); - } while (--op); + } + while (--op); + from = out - dist; /* rest from output */ } } } - else { /* contiguous in window */ + else /* contiguous in window */ + { from += wnext - op; - if (op < len) { /* some from window */ + + if (op < len) /* some from window */ + { len -= op; - do { + + do + { PUP(out) = PUP(from); - } while (--op); + } + while (--op); + from = out - dist; /* rest from output */ } } - while (len > 2) { + + while (len > 2) + { PUP(out) = PUP(from); PUP(out) = PUP(from); PUP(out) = PUP(from); len -= 3; } - if (len) { + + if (len) + { PUP(out) = PUP(from); + if (len > 1) PUP(out) = PUP(from); } } - else { + else + { from = out - dist; /* copy direct from output */ - do { /* minimum length is three */ + + do /* minimum length is three */ + { PUP(out) = PUP(from); PUP(out) = PUP(from); PUP(out) = PUP(from); len -= 3; - } while (len > 2); - if (len) { + } + while (len > 2); + + if (len) + { PUP(out) = PUP(from); + if (len > 1) PUP(out) = PUP(from); } } } - else if ((op & 64) == 0) { /* 2nd level distance code */ + else if ((op & 64) == 0) /* 2nd level distance code */ + { here = dcode[here.val + (hold & ((1U << op) - 1))]; goto dodist; } - else { - strm->msg = (char *)"invalid distance code"; + else + { + strm->msg = (char*)"invalid distance code"; state->mode = BAD; break; } } - else if ((op & 64) == 0) { /* 2nd level length code */ + else if ((op & 64) == 0) /* 2nd level length code */ + { here = lcode[here.val + (hold & ((1U << op) - 1))]; goto dolen; } - else if (op & 32) { /* end-of-block */ + else if (op & 32) /* end-of-block */ + { Tracevv((stderr, "inflate: end of block\n")); state->mode = TYPE; break; } - else { - strm->msg = (char *)"invalid literal/length code"; + else + { + strm->msg = (char*)"invalid literal/length code"; state->mode = BAD; break; } - } while (in < last && out < end); + } + while (in < last && out < end); /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ len = bits >> 3; diff --git a/extern/zlib/inffixed.h b/extern/zlib/inffixed.h index d628327..3640ce4 100644 --- a/extern/zlib/inffixed.h +++ b/extern/zlib/inffixed.h @@ -1,94 +1,96 @@ - /* inffixed.h -- table for decoding fixed codes - * Generated automatically by makefixed(). - */ +/* inffixed.h -- table for decoding fixed codes + * Generated automatically by makefixed(). + */ - /* WARNING: this file should *not* be used by applications. - It is part of the implementation of this library and is - subject to change. Applications should only use zlib.h. - */ +/* WARNING: this file should *not* be used by applications. + It is part of the implementation of this library and is + subject to change. Applications should only use zlib.h. + */ - static const code lenfix[512] = { - {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, - {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, - {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, - {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, - {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, - {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, - {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, - {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, - {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, - {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, - {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, - {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, - {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, - {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, - {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, - {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, - {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, - {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, - {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, - {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, - {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, - {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, - {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, - {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, - {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, - {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, - {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, - {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, - {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, - {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, - {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, - {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, - {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, - {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, - {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, - {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, - {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, - {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, - {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, - {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, - {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, - {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, - {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, - {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, - {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, - {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, - {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, - {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, - {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, - {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, - {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, - {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, - {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, - {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, - {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, - {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, - {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, - {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, - {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, - {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, - {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, - {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, - {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, - {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, - {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, - {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, - {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, - {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, - {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, - {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, - {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, - {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, - {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, - {0,9,255} - }; +static const code lenfix[512] = +{ + {96, 7, 0}, {0, 8, 80}, {0, 8, 16}, {20, 8, 115}, {18, 7, 31}, {0, 8, 112}, {0, 8, 48}, + {0, 9, 192}, {16, 7, 10}, {0, 8, 96}, {0, 8, 32}, {0, 9, 160}, {0, 8, 0}, {0, 8, 128}, + {0, 8, 64}, {0, 9, 224}, {16, 7, 6}, {0, 8, 88}, {0, 8, 24}, {0, 9, 144}, {19, 7, 59}, + {0, 8, 120}, {0, 8, 56}, {0, 9, 208}, {17, 7, 17}, {0, 8, 104}, {0, 8, 40}, {0, 9, 176}, + {0, 8, 8}, {0, 8, 136}, {0, 8, 72}, {0, 9, 240}, {16, 7, 4}, {0, 8, 84}, {0, 8, 20}, + {21, 8, 227}, {19, 7, 43}, {0, 8, 116}, {0, 8, 52}, {0, 9, 200}, {17, 7, 13}, {0, 8, 100}, + {0, 8, 36}, {0, 9, 168}, {0, 8, 4}, {0, 8, 132}, {0, 8, 68}, {0, 9, 232}, {16, 7, 8}, + {0, 8, 92}, {0, 8, 28}, {0, 9, 152}, {20, 7, 83}, {0, 8, 124}, {0, 8, 60}, {0, 9, 216}, + {18, 7, 23}, {0, 8, 108}, {0, 8, 44}, {0, 9, 184}, {0, 8, 12}, {0, 8, 140}, {0, 8, 76}, + {0, 9, 248}, {16, 7, 3}, {0, 8, 82}, {0, 8, 18}, {21, 8, 163}, {19, 7, 35}, {0, 8, 114}, + {0, 8, 50}, {0, 9, 196}, {17, 7, 11}, {0, 8, 98}, {0, 8, 34}, {0, 9, 164}, {0, 8, 2}, + {0, 8, 130}, {0, 8, 66}, {0, 9, 228}, {16, 7, 7}, {0, 8, 90}, {0, 8, 26}, {0, 9, 148}, + {20, 7, 67}, {0, 8, 122}, {0, 8, 58}, {0, 9, 212}, {18, 7, 19}, {0, 8, 106}, {0, 8, 42}, + {0, 9, 180}, {0, 8, 10}, {0, 8, 138}, {0, 8, 74}, {0, 9, 244}, {16, 7, 5}, {0, 8, 86}, + {0, 8, 22}, {64, 8, 0}, {19, 7, 51}, {0, 8, 118}, {0, 8, 54}, {0, 9, 204}, {17, 7, 15}, + {0, 8, 102}, {0, 8, 38}, {0, 9, 172}, {0, 8, 6}, {0, 8, 134}, {0, 8, 70}, {0, 9, 236}, + {16, 7, 9}, {0, 8, 94}, {0, 8, 30}, {0, 9, 156}, {20, 7, 99}, {0, 8, 126}, {0, 8, 62}, + {0, 9, 220}, {18, 7, 27}, {0, 8, 110}, {0, 8, 46}, {0, 9, 188}, {0, 8, 14}, {0, 8, 142}, + {0, 8, 78}, {0, 9, 252}, {96, 7, 0}, {0, 8, 81}, {0, 8, 17}, {21, 8, 131}, {18, 7, 31}, + {0, 8, 113}, {0, 8, 49}, {0, 9, 194}, {16, 7, 10}, {0, 8, 97}, {0, 8, 33}, {0, 9, 162}, + {0, 8, 1}, {0, 8, 129}, {0, 8, 65}, {0, 9, 226}, {16, 7, 6}, {0, 8, 89}, {0, 8, 25}, + {0, 9, 146}, {19, 7, 59}, {0, 8, 121}, {0, 8, 57}, {0, 9, 210}, {17, 7, 17}, {0, 8, 105}, + {0, 8, 41}, {0, 9, 178}, {0, 8, 9}, {0, 8, 137}, {0, 8, 73}, {0, 9, 242}, {16, 7, 4}, + {0, 8, 85}, {0, 8, 21}, {16, 8, 258}, {19, 7, 43}, {0, 8, 117}, {0, 8, 53}, {0, 9, 202}, + {17, 7, 13}, {0, 8, 101}, {0, 8, 37}, {0, 9, 170}, {0, 8, 5}, {0, 8, 133}, {0, 8, 69}, + {0, 9, 234}, {16, 7, 8}, {0, 8, 93}, {0, 8, 29}, {0, 9, 154}, {20, 7, 83}, {0, 8, 125}, + {0, 8, 61}, {0, 9, 218}, {18, 7, 23}, {0, 8, 109}, {0, 8, 45}, {0, 9, 186}, {0, 8, 13}, + {0, 8, 141}, {0, 8, 77}, {0, 9, 250}, {16, 7, 3}, {0, 8, 83}, {0, 8, 19}, {21, 8, 195}, + {19, 7, 35}, {0, 8, 115}, {0, 8, 51}, {0, 9, 198}, {17, 7, 11}, {0, 8, 99}, {0, 8, 35}, + {0, 9, 166}, {0, 8, 3}, {0, 8, 131}, {0, 8, 67}, {0, 9, 230}, {16, 7, 7}, {0, 8, 91}, + {0, 8, 27}, {0, 9, 150}, {20, 7, 67}, {0, 8, 123}, {0, 8, 59}, {0, 9, 214}, {18, 7, 19}, + {0, 8, 107}, {0, 8, 43}, {0, 9, 182}, {0, 8, 11}, {0, 8, 139}, {0, 8, 75}, {0, 9, 246}, + {16, 7, 5}, {0, 8, 87}, {0, 8, 23}, {64, 8, 0}, {19, 7, 51}, {0, 8, 119}, {0, 8, 55}, + {0, 9, 206}, {17, 7, 15}, {0, 8, 103}, {0, 8, 39}, {0, 9, 174}, {0, 8, 7}, {0, 8, 135}, + {0, 8, 71}, {0, 9, 238}, {16, 7, 9}, {0, 8, 95}, {0, 8, 31}, {0, 9, 158}, {20, 7, 99}, + {0, 8, 127}, {0, 8, 63}, {0, 9, 222}, {18, 7, 27}, {0, 8, 111}, {0, 8, 47}, {0, 9, 190}, + {0, 8, 15}, {0, 8, 143}, {0, 8, 79}, {0, 9, 254}, {96, 7, 0}, {0, 8, 80}, {0, 8, 16}, + {20, 8, 115}, {18, 7, 31}, {0, 8, 112}, {0, 8, 48}, {0, 9, 193}, {16, 7, 10}, {0, 8, 96}, + {0, 8, 32}, {0, 9, 161}, {0, 8, 0}, {0, 8, 128}, {0, 8, 64}, {0, 9, 225}, {16, 7, 6}, + {0, 8, 88}, {0, 8, 24}, {0, 9, 145}, {19, 7, 59}, {0, 8, 120}, {0, 8, 56}, {0, 9, 209}, + {17, 7, 17}, {0, 8, 104}, {0, 8, 40}, {0, 9, 177}, {0, 8, 8}, {0, 8, 136}, {0, 8, 72}, + {0, 9, 241}, {16, 7, 4}, {0, 8, 84}, {0, 8, 20}, {21, 8, 227}, {19, 7, 43}, {0, 8, 116}, + {0, 8, 52}, {0, 9, 201}, {17, 7, 13}, {0, 8, 100}, {0, 8, 36}, {0, 9, 169}, {0, 8, 4}, + {0, 8, 132}, {0, 8, 68}, {0, 9, 233}, {16, 7, 8}, {0, 8, 92}, {0, 8, 28}, {0, 9, 153}, + {20, 7, 83}, {0, 8, 124}, {0, 8, 60}, {0, 9, 217}, {18, 7, 23}, {0, 8, 108}, {0, 8, 44}, + {0, 9, 185}, {0, 8, 12}, {0, 8, 140}, {0, 8, 76}, {0, 9, 249}, {16, 7, 3}, {0, 8, 82}, + {0, 8, 18}, {21, 8, 163}, {19, 7, 35}, {0, 8, 114}, {0, 8, 50}, {0, 9, 197}, {17, 7, 11}, + {0, 8, 98}, {0, 8, 34}, {0, 9, 165}, {0, 8, 2}, {0, 8, 130}, {0, 8, 66}, {0, 9, 229}, + {16, 7, 7}, {0, 8, 90}, {0, 8, 26}, {0, 9, 149}, {20, 7, 67}, {0, 8, 122}, {0, 8, 58}, + {0, 9, 213}, {18, 7, 19}, {0, 8, 106}, {0, 8, 42}, {0, 9, 181}, {0, 8, 10}, {0, 8, 138}, + {0, 8, 74}, {0, 9, 245}, {16, 7, 5}, {0, 8, 86}, {0, 8, 22}, {64, 8, 0}, {19, 7, 51}, + {0, 8, 118}, {0, 8, 54}, {0, 9, 205}, {17, 7, 15}, {0, 8, 102}, {0, 8, 38}, {0, 9, 173}, + {0, 8, 6}, {0, 8, 134}, {0, 8, 70}, {0, 9, 237}, {16, 7, 9}, {0, 8, 94}, {0, 8, 30}, + {0, 9, 157}, {20, 7, 99}, {0, 8, 126}, {0, 8, 62}, {0, 9, 221}, {18, 7, 27}, {0, 8, 110}, + {0, 8, 46}, {0, 9, 189}, {0, 8, 14}, {0, 8, 142}, {0, 8, 78}, {0, 9, 253}, {96, 7, 0}, + {0, 8, 81}, {0, 8, 17}, {21, 8, 131}, {18, 7, 31}, {0, 8, 113}, {0, 8, 49}, {0, 9, 195}, + {16, 7, 10}, {0, 8, 97}, {0, 8, 33}, {0, 9, 163}, {0, 8, 1}, {0, 8, 129}, {0, 8, 65}, + {0, 9, 227}, {16, 7, 6}, {0, 8, 89}, {0, 8, 25}, {0, 9, 147}, {19, 7, 59}, {0, 8, 121}, + {0, 8, 57}, {0, 9, 211}, {17, 7, 17}, {0, 8, 105}, {0, 8, 41}, {0, 9, 179}, {0, 8, 9}, + {0, 8, 137}, {0, 8, 73}, {0, 9, 243}, {16, 7, 4}, {0, 8, 85}, {0, 8, 21}, {16, 8, 258}, + {19, 7, 43}, {0, 8, 117}, {0, 8, 53}, {0, 9, 203}, {17, 7, 13}, {0, 8, 101}, {0, 8, 37}, + {0, 9, 171}, {0, 8, 5}, {0, 8, 133}, {0, 8, 69}, {0, 9, 235}, {16, 7, 8}, {0, 8, 93}, + {0, 8, 29}, {0, 9, 155}, {20, 7, 83}, {0, 8, 125}, {0, 8, 61}, {0, 9, 219}, {18, 7, 23}, + {0, 8, 109}, {0, 8, 45}, {0, 9, 187}, {0, 8, 13}, {0, 8, 141}, {0, 8, 77}, {0, 9, 251}, + {16, 7, 3}, {0, 8, 83}, {0, 8, 19}, {21, 8, 195}, {19, 7, 35}, {0, 8, 115}, {0, 8, 51}, + {0, 9, 199}, {17, 7, 11}, {0, 8, 99}, {0, 8, 35}, {0, 9, 167}, {0, 8, 3}, {0, 8, 131}, + {0, 8, 67}, {0, 9, 231}, {16, 7, 7}, {0, 8, 91}, {0, 8, 27}, {0, 9, 151}, {20, 7, 67}, + {0, 8, 123}, {0, 8, 59}, {0, 9, 215}, {18, 7, 19}, {0, 8, 107}, {0, 8, 43}, {0, 9, 183}, + {0, 8, 11}, {0, 8, 139}, {0, 8, 75}, {0, 9, 247}, {16, 7, 5}, {0, 8, 87}, {0, 8, 23}, + {64, 8, 0}, {19, 7, 51}, {0, 8, 119}, {0, 8, 55}, {0, 9, 207}, {17, 7, 15}, {0, 8, 103}, + {0, 8, 39}, {0, 9, 175}, {0, 8, 7}, {0, 8, 135}, {0, 8, 71}, {0, 9, 239}, {16, 7, 9}, + {0, 8, 95}, {0, 8, 31}, {0, 9, 159}, {20, 7, 99}, {0, 8, 127}, {0, 8, 63}, {0, 9, 223}, + {18, 7, 27}, {0, 8, 111}, {0, 8, 47}, {0, 9, 191}, {0, 8, 15}, {0, 8, 143}, {0, 8, 79}, + {0, 9, 255} +}; - static const code distfix[32] = { - {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, - {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, - {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, - {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, - {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, - {22,5,193},{64,5,0} - }; +static const code distfix[32] = +{ + {16, 5, 1}, {23, 5, 257}, {19, 5, 17}, {27, 5, 4097}, {17, 5, 5}, {25, 5, 1025}, + {21, 5, 65}, {29, 5, 16385}, {16, 5, 3}, {24, 5, 513}, {20, 5, 33}, {28, 5, 8193}, + {18, 5, 9}, {26, 5, 2049}, {22, 5, 129}, {64, 5, 0}, {16, 5, 2}, {23, 5, 385}, + {19, 5, 25}, {27, 5, 6145}, {17, 5, 7}, {25, 5, 1537}, {21, 5, 97}, {29, 5, 24577}, + {16, 5, 4}, {24, 5, 769}, {20, 5, 49}, {28, 5, 12289}, {18, 5, 13}, {26, 5, 3073}, + {22, 5, 193}, {64, 5, 0} +}; diff --git a/extern/zlib/inflate.c b/extern/zlib/inflate.c index 0de7dee..4f16f56 100644 --- a/extern/zlib/inflate.c +++ b/extern/zlib/inflate.c @@ -109,12 +109,12 @@ while (0) \ #endif /* function prototypes */ -local void fixedtables OF((struct inflate_state FAR *state)); +local void fixedtables OF((struct inflate_state FAR* state)); local int updatewindow OF((z_streamp strm, unsigned out)); #ifdef BUILDFIXED - void makefixed OF((void)); +void makefixed OF((void)); #endif -local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, +local unsigned syncsearch OF((unsigned FAR* have, unsigned char FAR* buf, unsigned len)); #ifdef WIN32 @@ -124,14 +124,17 @@ int ZEXPORT inflateResetKeep(strm) z_streamp strm; #endif { - struct inflate_state FAR *state; + struct inflate_state FAR* state; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; + + state = (struct inflate_state FAR*)strm->state; strm->total_in = strm->total_out = state->total = 0; strm->msg = Z_NULL; + if (state->wrap) /* to support ill-conceived Java test suite */ strm->adler = state->wrap & 1; + state->mode = HEAD; state->last = 0; state->havedict = 0; @@ -153,10 +156,11 @@ int ZEXPORT inflateReset(strm) z_streamp strm; #endif { - struct inflate_state FAR *state; + struct inflate_state FAR* state; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; + + state = (struct inflate_state FAR*)strm->state; state->wsize = 0; state->whave = 0; state->wnext = 0; @@ -172,29 +176,36 @@ int windowBits; #endif { int wrap; - struct inflate_state FAR *state; + struct inflate_state FAR* state; /* get the state */ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; + + state = (struct inflate_state FAR*)strm->state; /* extract wrap request from windowBits parameter */ - if (windowBits < 0) { + if (windowBits < 0) + { wrap = 0; windowBits = -windowBits; } - else { + else + { wrap = (windowBits >> 4) + 1; #ifdef GUNZIP + if (windowBits < 48) windowBits &= 15; + #endif } /* set number of window bits, free window if different */ if (windowBits && (windowBits < 8 || windowBits > 15)) return Z_STREAM_ERROR; - if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { + + if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) + { ZFREE(strm, state->window); state->window = Z_NULL; } @@ -206,24 +217,28 @@ int windowBits; } #ifdef WIN32 -int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, const char *version, int stream_size) +int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, const char* version, int stream_size) #else int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) z_streamp strm; int windowBits; -const char *version; +const char* version; int stream_size; #endif { int ret; - struct inflate_state FAR *state; + struct inflate_state FAR* state; if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || - stream_size != (int)(sizeof(z_stream))) + stream_size != (int)(sizeof(z_stream))) return Z_VERSION_ERROR; + if (strm == Z_NULL) return Z_STREAM_ERROR; + strm->msg = Z_NULL; /* in case we return an error */ - if (strm->zalloc == (alloc_func)0) { + + if (strm->zalloc == (alloc_func)0) + { #ifdef Z_SOLO return Z_STREAM_ERROR; #else @@ -231,32 +246,39 @@ int stream_size; strm->opaque = (voidpf)0; #endif } + if (strm->zfree == (free_func)0) #ifdef Z_SOLO return Z_STREAM_ERROR; + #else strm->zfree = zcfree; #endif - state = (struct inflate_state FAR *) + state = (struct inflate_state FAR*) ZALLOC(strm, 1, sizeof(struct inflate_state)); + if (state == Z_NULL) return Z_MEM_ERROR; + Tracev((stderr, "inflate: allocated\n")); - strm->state = (struct internal_state FAR *)state; + strm->state = (struct internal_state FAR*)state; state->window = Z_NULL; ret = inflateReset2(strm, windowBits); - if (ret != Z_OK) { + + if (ret != Z_OK) + { ZFREE(strm, state); strm->state = Z_NULL; } + return ret; } #ifdef WIN32 -int ZEXPORT inflateInit_(z_streamp strm, const char *version, int stream_size) +int ZEXPORT inflateInit_(z_streamp strm, const char* version, int stream_size) #else int ZEXPORT inflateInit_(strm, version, stream_size) z_streamp strm; -const char *version; +const char* version; int stream_size; #endif { @@ -272,16 +294,21 @@ int bits; int value; #endif { - struct inflate_state FAR *state; + struct inflate_state FAR* state; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; - if (bits < 0) { + + state = (struct inflate_state FAR*)strm->state; + + if (bits < 0) + { state->hold = 0; state->bits = 0; return Z_OK; } + if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; + value &= (1L << bits) - 1; state->hold += value << state->bits; state->bits += bits; @@ -299,28 +326,34 @@ int value; may not be thread-safe. */ #ifdef WIN32 -local void fixedtables(struct inflate_state FAR *state) +local void fixedtables(struct inflate_state FAR* state) #else local void fixedtables(state) -struct inflate_state FAR *state; +struct inflate_state FAR* state; #endif { #ifdef BUILDFIXED static int virgin = 1; - static code *lenfix, *distfix; + static code* lenfix, *distfix; static code fixed[544]; /* build fixed huffman tables if first call (may not be thread safe) */ - if (virgin) { + if (virgin) + { unsigned sym, bits; - static code *next; + static code* next; /* literal/length table */ sym = 0; + while (sym < 144) state->lens[sym++] = 8; + while (sym < 256) state->lens[sym++] = 9; + while (sym < 280) state->lens[sym++] = 7; + while (sym < 288) state->lens[sym++] = 8; + next = fixed; lenfix = next; bits = 9; @@ -328,7 +361,9 @@ struct inflate_state FAR *state; /* distance table */ sym = 0; + while (sym < 32) state->lens[sym++] = 5; + distfix = next; bits = 5; inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); @@ -336,6 +371,7 @@ struct inflate_state FAR *state; /* do this just once */ virgin = 0; } + #else /* !BUILDFIXED */ # include "inffixed.h" #endif /* BUILDFIXED */ @@ -384,24 +420,36 @@ void makefixed() size = 1U << 9; printf(" static const code lenfix[%u] = {", size); low = 0; - for (;;) { + + for (;;) + { if ((low % 7) == 0) printf("\n "); + printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, state.lencode[low].bits, state.lencode[low].val); + if (++low == size) break; + putchar(','); } + puts("\n };"); size = 1U << 5; printf("\n static const code distfix[%u] = {", size); low = 0; - for (;;) { + + for (;;) + { if ((low % 6) == 0) printf("\n "); + printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, state.distcode[low].val); + if (++low == size) break; + putchar(','); } + puts("\n };"); } #endif /* MAKEFIXED */ @@ -428,21 +476,24 @@ z_streamp strm; unsigned out; #endif { - struct inflate_state FAR *state; + struct inflate_state FAR* state; unsigned copy, dist; - state = (struct inflate_state FAR *)strm->state; + state = (struct inflate_state FAR*)strm->state; /* if it hasn't been done already, allocate space for the window */ - if (state->window == Z_NULL) { - state->window = (unsigned char FAR *) + if (state->window == Z_NULL) + { + state->window = (unsigned char FAR*) ZALLOC(strm, 1U << state->wbits, sizeof(unsigned char)); + if (state->window == Z_NULL) return 1; } /* if window not in use yet, initialize */ - if (state->wsize == 0) { + if (state->wsize == 0) + { state->wsize = 1U << state->wbits; state->wnext = 0; state->whave = 0; @@ -450,27 +501,38 @@ unsigned out; /* copy state->wsize or less output bytes into the circular window */ copy = out - strm->avail_out; - if (copy >= state->wsize) { + + if (copy >= state->wsize) + { zmemcpy(state->window, strm->next_out - state->wsize, state->wsize); state->wnext = 0; state->whave = state->wsize; } - else { + else + { dist = state->wsize - state->wnext; + if (dist > copy) dist = copy; + zmemcpy(state->window + state->wnext, strm->next_out - copy, dist); copy -= dist; - if (copy) { + + if (copy) + { zmemcpy(state->window, strm->next_out - copy, copy); state->wnext = copy; state->whave = state->wsize; } - else { + else + { state->wnext += dist; + if (state->wnext == state->wsize) state->wnext = 0; + if (state->whave < state->wsize) state->whave += dist; } } + return 0; } @@ -658,15 +720,15 @@ z_streamp strm; int flush; #endif { - struct inflate_state FAR *state; - unsigned char FAR *next; /* next input */ - unsigned char FAR *put; /* next output */ + struct inflate_state FAR* state; + unsigned char FAR* next; /* next input */ + unsigned char FAR* put; /* next output */ unsigned have, left; /* available input and output */ unsigned long hold; /* bit buffer */ unsigned bits; /* bits in bit buffer */ unsigned in, out; /* save starting available input and output */ unsigned copy; /* number of stored or match bytes to copy */ - unsigned char FAR *from; /* where to copy match bytes from */ + unsigned char FAR* from; /* where to copy match bytes from */ code here; /* current decoding table entry */ code last; /* parent table entry */ unsigned len; /* length to copy for repeats, bits to drop */ @@ -675,602 +737,771 @@ int flush; unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ #endif static const unsigned short order[19] = /* permutation of code lengths */ - {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || - (strm->next_in == Z_NULL && strm->avail_in != 0)) + (strm->next_in == Z_NULL && strm->avail_in != 0)) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; + state = (struct inflate_state FAR*)strm->state; + if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ + LOAD(); in = have; out = left; ret = Z_OK; + for (;;) - switch (state->mode) { - case HEAD: - if (state->wrap == 0) { - state->mode = TYPEDO; - break; - } - NEEDBITS(16); -#ifdef GUNZIP - if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ - state->check = crc32(0L, Z_NULL, 0); - CRC2(state->check, hold); - INITBITS(); - state->mode = FLAGS; - break; - } - state->flags = 0; /* expect zlib header */ - if (state->head != Z_NULL) - state->head->done = -1; - if (!(state->wrap & 1) || /* check if zlib header allowed */ -#else - if ( -#endif - ((BITS(8) << 8) + (hold >> 8)) % 31) { - strm->msg = (char *)"incorrect header check"; - state->mode = BAD; - break; - } - if (BITS(4) != Z_DEFLATED) { - strm->msg = (char *)"unknown compression method"; - state->mode = BAD; - break; - } - DROPBITS(4); - len = BITS(4) + 8; - if (state->wbits == 0) - state->wbits = len; - else if (len > state->wbits) { - strm->msg = (char *)"invalid window size"; - state->mode = BAD; - break; - } - state->dmax = 1U << len; - Tracev((stderr, "inflate: zlib header ok\n")); - strm->adler = state->check = adler32(0L, Z_NULL, 0); - state->mode = hold & 0x200 ? DICTID : TYPE; - INITBITS(); - break; -#ifdef GUNZIP - case FLAGS: - NEEDBITS(16); - state->flags = (int)(hold); - if ((state->flags & 0xff) != Z_DEFLATED) { - strm->msg = (char *)"unknown compression method"; - state->mode = BAD; - break; - } - if (state->flags & 0xe000) { - strm->msg = (char *)"unknown header flags set"; - state->mode = BAD; - break; - } - if (state->head != Z_NULL) - state->head->text = (int)((hold >> 8) & 1); - if (state->flags & 0x0200) CRC2(state->check, hold); - INITBITS(); - state->mode = TIME; - case TIME: - NEEDBITS(32); - if (state->head != Z_NULL) - state->head->time = hold; - if (state->flags & 0x0200) CRC4(state->check, hold); - INITBITS(); - state->mode = OS; - case OS: - NEEDBITS(16); - if (state->head != Z_NULL) { - state->head->xflags = (int)(hold & 0xff); - state->head->os = (int)(hold >> 8); - } - if (state->flags & 0x0200) CRC2(state->check, hold); - INITBITS(); - state->mode = EXLEN; - case EXLEN: - if (state->flags & 0x0400) { - NEEDBITS(16); - state->length = (unsigned)(hold); - if (state->head != Z_NULL) - state->head->extra_len = (unsigned)hold; - if (state->flags & 0x0200) CRC2(state->check, hold); - INITBITS(); - } - else if (state->head != Z_NULL) - state->head->extra = Z_NULL; - state->mode = EXTRA; - case EXTRA: - if (state->flags & 0x0400) { - copy = state->length; - if (copy > have) copy = have; - if (copy) { - if (state->head != Z_NULL && - state->head->extra != Z_NULL) { - len = state->head->extra_len - state->length; - zmemcpy(state->head->extra + len, next, - len + copy > state->head->extra_max ? - state->head->extra_max - len : copy); - } - if (state->flags & 0x0200) - state->check = crc32(state->check, next, copy); - have -= copy; - next += copy; - state->length -= copy; + switch (state->mode) + { + case HEAD: + if (state->wrap == 0) + { + state->mode = TYPEDO; + break; } - if (state->length) goto inf_leave; - } - state->length = 0; - state->mode = NAME; - case NAME: - if (state->flags & 0x0800) { - if (have == 0) goto inf_leave; - copy = 0; - do { - len = (unsigned)(next[copy++]); - if (state->head != Z_NULL && - state->head->name != Z_NULL && - state->length < state->head->name_max) - state->head->name[state->length++] = (Bytef)(len & 0xFF); - } while (len && copy < have); - if (state->flags & 0x0200) - state->check = crc32(state->check, next, copy); - have -= copy; - next += copy; - if (len) goto inf_leave; - } - else if (state->head != Z_NULL) - state->head->name = Z_NULL; - state->length = 0; - state->mode = COMMENT; - case COMMENT: - if (state->flags & 0x1000) { - if (have == 0) goto inf_leave; - copy = 0; - do { - len = (unsigned)(next[copy++]); - if (state->head != Z_NULL && - state->head->comment != Z_NULL && - state->length < state->head->comm_max) - state->head->comment[state->length++] = (Bytef)(len & 0xFF); - } while (len && copy < have); - if (state->flags & 0x0200) - state->check = crc32(state->check, next, copy); - have -= copy; - next += copy; - if (len) goto inf_leave; - } - else if (state->head != Z_NULL) - state->head->comment = Z_NULL; - state->mode = HCRC; - case HCRC: - if (state->flags & 0x0200) { + NEEDBITS(16); - if (hold != (state->check & 0xffff)) { - strm->msg = (char *)"header crc mismatch"; +#ifdef GUNZIP + + if ((state->wrap & 2) && hold == 0x8b1f) /* gzip header */ + { + state->check = crc32(0L, Z_NULL, 0); + CRC2(state->check, hold); + INITBITS(); + state->mode = FLAGS; + break; + } + + state->flags = 0; /* expect zlib header */ + + if (state->head != Z_NULL) + state->head->done = -1; + + if (!(state->wrap & 1) || /* check if zlib header allowed */ +#else + if ( +#endif + ((BITS(8) << 8) + (hold >> 8)) % 31) + { + strm->msg = (char*)"incorrect header check"; state->mode = BAD; break; } + if (BITS(4) != Z_DEFLATED) + { + strm->msg = (char*)"unknown compression method"; + state->mode = BAD; + break; + } + DROPBITS(4); + len = BITS(4) + 8; + + if (state->wbits == 0) + state->wbits = len; + else if (len > state->wbits) + { + strm->msg = (char*)"invalid window size"; + state->mode = BAD; + break; + } + state->dmax = 1U << len; + Tracev((stderr, "inflate: zlib header ok\n")); + strm->adler = state->check = adler32(0L, Z_NULL, 0); + state->mode = hold & 0x200 ? DICTID : TYPE; INITBITS(); - } - if (state->head != Z_NULL) { - state->head->hcrc = (int)((state->flags >> 9) & 1); - state->head->done = 1; - } - strm->adler = state->check = crc32(0L, Z_NULL, 0); - state->mode = TYPE; - break; -#endif - case DICTID: - NEEDBITS(32); - strm->adler = state->check = ZSWAP32(hold); - INITBITS(); - state->mode = DICT; - case DICT: - if (state->havedict == 0) { - RESTORE(); - return Z_NEED_DICT; - } - strm->adler = state->check = adler32(0L, Z_NULL, 0); - state->mode = TYPE; - case TYPE: - if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; - case TYPEDO: - if (state->last) { - BYTEBITS(); - state->mode = CHECK; break; - } - NEEDBITS(3); - state->last = BITS(1); - DROPBITS(1); - switch (BITS(2)) { - case 0: /* stored block */ - Tracev((stderr, "inflate: stored block%s\n", - state->last ? " (last)" : "")); - state->mode = STORED; - break; - case 1: /* fixed block */ - fixedtables(state); - Tracev((stderr, "inflate: fixed codes block%s\n", - state->last ? " (last)" : "")); - state->mode = LEN_; /* decode codes */ - if (flush == Z_TREES) { - DROPBITS(2); - goto inf_leave; +#ifdef GUNZIP + + case FLAGS: + NEEDBITS(16); + state->flags = (int)(hold); + if ((state->flags & 0xff) != Z_DEFLATED) + { + strm->msg = (char*)"unknown compression method"; + state->mode = BAD; + break; } + if (state->flags & 0xe000) + { + strm->msg = (char*)"unknown header flags set"; + state->mode = BAD; + break; + } + if (state->head != Z_NULL) + state->head->text = (int)((hold >> 8) & 1); + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + state->mode = TIME; + case TIME: + NEEDBITS(32); + if (state->head != Z_NULL) + state->head->time = hold; + if (state->flags & 0x0200) CRC4(state->check, hold); + INITBITS(); + state->mode = OS; + case OS: + NEEDBITS(16); + if (state->head != Z_NULL) + { + state->head->xflags = (int)(hold & 0xff); + state->head->os = (int)(hold >> 8); + } + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + state->mode = EXLEN; + case EXLEN: + if (state->flags & 0x0400) + { + NEEDBITS(16); + state->length = (unsigned)(hold); + + if (state->head != Z_NULL) + state->head->extra_len = (unsigned)hold; + + if (state->flags & 0x0200) CRC2(state->check, hold); + + INITBITS(); + } + else if (state->head != Z_NULL) + state->head->extra = Z_NULL; + state->mode = EXTRA; + case EXTRA: + if (state->flags & 0x0400) + { + copy = state->length; + + if (copy > have) copy = have; + + if (copy) + { + if (state->head != Z_NULL && + state->head->extra != Z_NULL) + { + len = state->head->extra_len - state->length; + zmemcpy(state->head->extra + len, next, + len + copy > state->head->extra_max ? + state->head->extra_max - len : copy); + } + + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + + have -= copy; + next += copy; + state->length -= copy; + } + + if (state->length) goto inf_leave; + } + state->length = 0; + state->mode = NAME; + + case NAME: + if (state->flags & 0x0800) + { + if (have == 0) goto inf_leave; + + copy = 0; + + do + { + len = (unsigned)(next[copy++]); + + if (state->head != Z_NULL && + state->head->name != Z_NULL && + state->length < state->head->name_max) + state->head->name[state->length++] = (Bytef)(len & 0xFF); + } + while (len && copy < have); + + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + + have -= copy; + next += copy; + + if (len) goto inf_leave; + } + else if (state->head != Z_NULL) + state->head->name = Z_NULL; + state->length = 0; + state->mode = COMMENT; + case COMMENT: + if (state->flags & 0x1000) + { + if (have == 0) goto inf_leave; + + copy = 0; + + do + { + len = (unsigned)(next[copy++]); + + if (state->head != Z_NULL && + state->head->comment != Z_NULL && + state->length < state->head->comm_max) + state->head->comment[state->length++] = (Bytef)(len & 0xFF); + } + while (len && copy < have); + + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + + have -= copy; + next += copy; + + if (len) goto inf_leave; + } + else if (state->head != Z_NULL) + state->head->comment = Z_NULL; + state->mode = HCRC; + case HCRC: + if (state->flags & 0x0200) + { + NEEDBITS(16); + + if (hold != (state->check & 0xffff)) + { + strm->msg = (char*)"header crc mismatch"; + state->mode = BAD; + break; + } + + INITBITS(); + } + if (state->head != Z_NULL) + { + state->head->hcrc = (int)((state->flags >> 9) & 1); + state->head->done = 1; + } + strm->adler = state->check = crc32(0L, Z_NULL, 0); + state->mode = TYPE; break; - case 2: /* dynamic block */ - Tracev((stderr, "inflate: dynamic codes block%s\n", - state->last ? " (last)" : "")); - state->mode = TABLE; - break; - case 3: - strm->msg = (char *)"invalid block type"; - state->mode = BAD; - } - DROPBITS(2); - break; - case STORED: - BYTEBITS(); /* go to byte boundary */ - NEEDBITS(32); - if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { - strm->msg = (char *)"invalid stored block lengths"; - state->mode = BAD; - break; - } - state->length = (unsigned)hold & 0xffff; - Tracev((stderr, "inflate: stored length %u\n", - state->length)); - INITBITS(); - state->mode = COPY_; - if (flush == Z_TREES) goto inf_leave; - case COPY_: - state->mode = COPY; - case COPY: - copy = state->length; - if (copy) { - if (copy > have) copy = have; - if (copy > left) copy = left; - if (copy == 0) goto inf_leave; - zmemcpy(put, next, copy); - have -= copy; - next += copy; - left -= copy; - put += copy; - state->length -= copy; - break; - } - Tracev((stderr, "inflate: stored end\n")); - state->mode = TYPE; - break; - case TABLE: - NEEDBITS(14); - state->nlen = BITS(5) + 257; - DROPBITS(5); - state->ndist = BITS(5) + 1; - DROPBITS(5); - state->ncode = BITS(4) + 4; - DROPBITS(4); -#ifndef PKZIP_BUG_WORKAROUND - if (state->nlen > 286 || state->ndist > 30) { - strm->msg = (char *)"too many length or distance symbols"; - state->mode = BAD; - break; - } #endif - Tracev((stderr, "inflate: table sizes ok\n")); - state->have = 0; - state->mode = LENLENS; - case LENLENS: - while (state->have < state->ncode) { + + case DICTID: + NEEDBITS(32); + strm->adler = state->check = ZSWAP32(hold); + INITBITS(); + state->mode = DICT; + case DICT: + if (state->havedict == 0) + { + RESTORE(); + return Z_NEED_DICT; + } + strm->adler = state->check = adler32(0L, Z_NULL, 0); + state->mode = TYPE; + + case TYPE: + if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; + case TYPEDO: + if (state->last) + { + BYTEBITS(); + state->mode = CHECK; + break; + } NEEDBITS(3); - state->lens[order[state->have++]] = (unsigned short)BITS(3); - DROPBITS(3); - } - while (state->have < 19) - state->lens[order[state->have++]] = 0; - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 7; - ret = inflate_table(CODES, state->lens, 19, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid code lengths set"; - state->mode = BAD; + state->last = BITS(1); + DROPBITS(1); + + switch (BITS(2)) + { + case 0: /* stored block */ + Tracev((stderr, "inflate: stored block%s\n", + state->last ? " (last)" : "")); + state->mode = STORED; + break; + + case 1: /* fixed block */ + fixedtables(state); + Tracev((stderr, "inflate: fixed codes block%s\n", + state->last ? " (last)" : "")); + state->mode = LEN_; /* decode codes */ + + if (flush == Z_TREES) + { + DROPBITS(2); + goto inf_leave; + } + + break; + + case 2: /* dynamic block */ + Tracev((stderr, "inflate: dynamic codes block%s\n", + state->last ? " (last)" : "")); + state->mode = TABLE; + break; + + case 3: + strm->msg = (char*)"invalid block type"; + state->mode = BAD; + } + DROPBITS(2); break; - } - Tracev((stderr, "inflate: code lengths ok\n")); - state->have = 0; - state->mode = CODELENS; - case CODELENS: - while (state->have < state->nlen + state->ndist) { - for (;;) { - here = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); + + case STORED: + BYTEBITS(); /* go to byte boundary */ + NEEDBITS(32); + if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) + { + strm->msg = (char*)"invalid stored block lengths"; + state->mode = BAD; + break; } - if (here.val < 16) { - DROPBITS(here.bits); - state->lens[state->have++] = here.val; + state->length = (unsigned)hold & 0xffff; + Tracev((stderr, "inflate: stored length %u\n", + state->length)); + INITBITS(); + state->mode = COPY_; + + if (flush == Z_TREES) goto inf_leave; + case COPY_: + state->mode = COPY; + case COPY: + copy = state->length; + if (copy) + { + if (copy > have) copy = have; + + if (copy > left) copy = left; + + if (copy == 0) goto inf_leave; + + zmemcpy(put, next, copy); + have -= copy; + next += copy; + left -= copy; + put += copy; + state->length -= copy; + break; } - else { - if (here.val == 16) { - NEEDBITS(here.bits + 2); + Tracev((stderr, "inflate: stored end\n")); + state->mode = TYPE; + break; + + case TABLE: + NEEDBITS(14); + state->nlen = BITS(5) + 257; + DROPBITS(5); + state->ndist = BITS(5) + 1; + DROPBITS(5); + state->ncode = BITS(4) + 4; + DROPBITS(4); +#ifndef PKZIP_BUG_WORKAROUND + if (state->nlen > 286 || state->ndist > 30) + { + strm->msg = (char*)"too many length or distance symbols"; + state->mode = BAD; + break; + } +#endif + Tracev((stderr, "inflate: table sizes ok\n")); + state->have = 0; + state->mode = LENLENS; + + case LENLENS: + while (state->have < state->ncode) + { + NEEDBITS(3); + state->lens[order[state->have++]] = (unsigned short)BITS(3); + DROPBITS(3); + } + while (state->have < 19) + state->lens[order[state->have++]] = 0; + state->next = state->codes; + state->lencode = (code const FAR*)(state->next); + state->lenbits = 7; + ret = inflate_table(CODES, state->lens, 19, &(state->next), + &(state->lenbits), state->work); + if (ret) + { + strm->msg = (char*)"invalid code lengths set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: code lengths ok\n")); + state->have = 0; + state->mode = CODELENS; + + case CODELENS: + while (state->have < state->nlen + state->ndist) + { + for (;;) + { + here = state->lencode[BITS(state->lenbits)]; + + if ((unsigned)(here.bits) <= bits) break; + + PULLBYTE(); + } + + if (here.val < 16) + { DROPBITS(here.bits); - if (state->have == 0) { - strm->msg = (char *)"invalid bit length repeat"; + state->lens[state->have++] = here.val; + } + else + { + if (here.val == 16) + { + NEEDBITS(here.bits + 2); + DROPBITS(here.bits); + + if (state->have == 0) + { + strm->msg = (char*)"invalid bit length repeat"; + state->mode = BAD; + break; + } + + len = state->lens[state->have - 1]; + copy = 3 + BITS(2); + DROPBITS(2); + } + else if (here.val == 17) + { + NEEDBITS(here.bits + 3); + DROPBITS(here.bits); + len = 0; + copy = 3 + BITS(3); + DROPBITS(3); + } + else + { + NEEDBITS(here.bits + 7); + DROPBITS(here.bits); + len = 0; + copy = 11 + BITS(7); + DROPBITS(7); + } + + if (state->have + copy > state->nlen + state->ndist) + { + strm->msg = (char*)"invalid bit length repeat"; state->mode = BAD; break; } - len = state->lens[state->have - 1]; - copy = 3 + BITS(2); - DROPBITS(2); + + while (copy--) + state->lens[state->have++] = (unsigned short)len; } - else if (here.val == 17) { - NEEDBITS(here.bits + 3); - DROPBITS(here.bits); - len = 0; - copy = 3 + BITS(3); - DROPBITS(3); - } - else { - NEEDBITS(here.bits + 7); - DROPBITS(here.bits); - len = 0; - copy = 11 + BITS(7); - DROPBITS(7); - } - if (state->have + copy > state->nlen + state->ndist) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; - break; - } - while (copy--) - state->lens[state->have++] = (unsigned short)len; } - } - /* handle error breaks in while */ - if (state->mode == BAD) break; + /* handle error breaks in while */ + if (state->mode == BAD) break; - /* check for end-of-block code (better have one) */ - if (state->lens[256] == 0) { - strm->msg = (char *)"invalid code -- missing end-of-block"; - state->mode = BAD; - break; - } + /* check for end-of-block code (better have one) */ + if (state->lens[256] == 0) + { + strm->msg = (char*)"invalid code -- missing end-of-block"; + state->mode = BAD; + break; + } - /* build code tables -- note: do not change the lenbits or distbits - values here (9 and 6) without reading the comments in inftrees.h - concerning the ENOUGH constants, which depend on those values */ - state->next = state->codes; - state->lencode = (code const FAR *)(state->next); - state->lenbits = 9; - ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), - &(state->lenbits), state->work); - if (ret) { - strm->msg = (char *)"invalid literal/lengths set"; - state->mode = BAD; - break; - } - state->distcode = (code const FAR *)(state->next); - state->distbits = 6; - ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, - &(state->next), &(state->distbits), state->work); - if (ret) { - strm->msg = (char *)"invalid distances set"; - state->mode = BAD; - break; - } - Tracev((stderr, "inflate: codes ok\n")); - state->mode = LEN_; - if (flush == Z_TREES) goto inf_leave; - case LEN_: - state->mode = LEN; - case LEN: - if (have >= 6 && left >= 258) { - RESTORE(); - inflate_fast(strm, out); - LOAD(); - if (state->mode == TYPE) + /* build code tables -- note: do not change the lenbits or distbits + values here (9 and 6) without reading the comments in inftrees.h + concerning the ENOUGH constants, which depend on those values */ + state->next = state->codes; + state->lencode = (code const FAR*)(state->next); + state->lenbits = 9; + ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), + &(state->lenbits), state->work); + + if (ret) + { + strm->msg = (char*)"invalid literal/lengths set"; + state->mode = BAD; + break; + } + state->distcode = (code const FAR*)(state->next); + state->distbits = 6; + ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, + &(state->next), &(state->distbits), state->work); + + if (ret) + { + strm->msg = (char*)"invalid distances set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: codes ok\n")); + state->mode = LEN_; + + if (flush == Z_TREES) goto inf_leave; + case LEN_: + state->mode = LEN; + case LEN: + if (have >= 6 && left >= 258) + { + RESTORE(); + inflate_fast(strm, out); + LOAD(); + + if (state->mode == TYPE) + state->back = -1; + + break; + } + state->back = 0; + + for (;;) + { + here = state->lencode[BITS(state->lenbits)]; + + if ((unsigned)(here.bits) <= bits) break; + + PULLBYTE(); + } + if (here.op && (here.op & 0xf0) == 0) + { + last = here; + + for (;;) + { + here = state->lencode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + + if ((unsigned)(last.bits + here.bits) <= bits) break; + + PULLBYTE(); + } + + DROPBITS(last.bits); + state->back += last.bits; + } + DROPBITS(here.bits); + state->back += here.bits; + state->length = (unsigned)here.val; + + if ((int)(here.op) == 0) + { + Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", here.val)); + state->mode = LIT; + break; + } + if (here.op & 32) + { + Tracevv((stderr, "inflate: end of block\n")); state->back = -1; - break; - } - state->back = 0; - for (;;) { - here = state->lencode[BITS(state->lenbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); - } - if (here.op && (here.op & 0xf0) == 0) { - last = here; - for (;;) { - here = state->lencode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + here.bits) <= bits) break; + state->mode = TYPE; + break; + } + if (here.op & 64) + { + strm->msg = (char*)"invalid literal/length code"; + state->mode = BAD; + break; + } + state->extra = (unsigned)(here.op) & 15; + state->mode = LENEXT; + + case LENEXT: + if (state->extra) + { + NEEDBITS(state->extra); + state->length += BITS(state->extra); + DROPBITS(state->extra); + state->back += state->extra; + } + Tracevv((stderr, "inflate: length %u\n", state->length)); + state->was = state->length; + state->mode = DIST; + + case DIST: + for (;;) + { + here = state->distcode[BITS(state->distbits)]; + + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); } - DROPBITS(last.bits); - state->back += last.bits; - } - DROPBITS(here.bits); - state->back += here.bits; - state->length = (unsigned)here.val; - if ((int)(here.op) == 0) { - Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? - "inflate: literal '%c'\n" : - "inflate: literal 0x%02x\n", here.val)); - state->mode = LIT; - break; - } - if (here.op & 32) { - Tracevv((stderr, "inflate: end of block\n")); - state->back = -1; - state->mode = TYPE; - break; - } - if (here.op & 64) { - strm->msg = (char *)"invalid literal/length code"; - state->mode = BAD; - break; - } - state->extra = (unsigned)(here.op) & 15; - state->mode = LENEXT; - case LENEXT: - if (state->extra) { - NEEDBITS(state->extra); - state->length += BITS(state->extra); - DROPBITS(state->extra); - state->back += state->extra; - } - Tracevv((stderr, "inflate: length %u\n", state->length)); - state->was = state->length; - state->mode = DIST; - case DIST: - for (;;) { - here = state->distcode[BITS(state->distbits)]; - if ((unsigned)(here.bits) <= bits) break; - PULLBYTE(); - } - if ((here.op & 0xf0) == 0) { - last = here; - for (;;) { - here = state->distcode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; - if ((unsigned)(last.bits + here.bits) <= bits) break; - PULLBYTE(); + if ((here.op & 0xf0) == 0) + { + last = here; + + for (;;) + { + here = state->distcode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + + if ((unsigned)(last.bits + here.bits) <= bits) break; + + PULLBYTE(); + } + + DROPBITS(last.bits); + state->back += last.bits; + } + DROPBITS(here.bits); + state->back += here.bits; + + if (here.op & 64) + { + strm->msg = (char*)"invalid distance code"; + state->mode = BAD; + break; + } + state->offset = (unsigned)here.val; + state->extra = (unsigned)(here.op) & 15; + state->mode = DISTEXT; + + case DISTEXT: + if (state->extra) + { + NEEDBITS(state->extra); + state->offset += BITS(state->extra); + DROPBITS(state->extra); + state->back += state->extra; } - DROPBITS(last.bits); - state->back += last.bits; - } - DROPBITS(here.bits); - state->back += here.bits; - if (here.op & 64) { - strm->msg = (char *)"invalid distance code"; - state->mode = BAD; - break; - } - state->offset = (unsigned)here.val; - state->extra = (unsigned)(here.op) & 15; - state->mode = DISTEXT; - case DISTEXT: - if (state->extra) { - NEEDBITS(state->extra); - state->offset += BITS(state->extra); - DROPBITS(state->extra); - state->back += state->extra; - } #ifdef INFLATE_STRICT - if (state->offset > state->dmax) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; - break; - } + + if (state->offset > state->dmax) + { + strm->msg = (char*)"invalid distance too far back"; + state->mode = BAD; + break; + } #endif - Tracevv((stderr, "inflate: distance %u\n", state->offset)); - state->mode = MATCH; - case MATCH: - if (left == 0) goto inf_leave; - copy = out - left; - if (state->offset > copy) { /* copy from window */ - copy = state->offset - copy; - if (copy > state->whave) { - if (state->sane) { - strm->msg = (char *)"invalid distance too far back"; + Tracevv((stderr, "inflate: distance %u\n", state->offset)); + state->mode = MATCH; + + case MATCH: + if (left == 0) goto inf_leave; + copy = out - left; + if (state->offset > copy) /* copy from window */ + { + copy = state->offset - copy; + + if (copy > state->whave) + { + if (state->sane) + { + strm->msg = (char*)"invalid distance too far back"; + state->mode = BAD; + break; + } + +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + Trace((stderr, "inflate.c too far\n")); + copy -= state->whave; + + if (copy > state->length) copy = state->length; + + if (copy > left) copy = left; + + left -= copy; + state->length -= copy; + + do + { + *put++ = 0; + } + while (--copy); + + if (state->length == 0) state->mode = LEN; + + break; +#endif + } + + if (copy > state->wnext) + { + copy -= state->wnext; + from = state->window + (state->wsize - copy); + } + else + from = state->window + (state->wnext - copy); + + if (copy > state->length) copy = state->length; + } + else /* copy from output */ + { + from = put - state->offset; + copy = state->length; + } + if (copy > left) copy = left; + left -= copy; + state->length -= copy; + do + { + *put++ = *from++; + } + while (--copy); + if (state->length == 0) state->mode = LEN; + break; + case LIT: + if (left == 0) goto inf_leave; + *put++ = (unsigned char)(state->length); + left--; + state->mode = LEN; + break; + case CHECK: + if (state->wrap) + { + NEEDBITS(32); + out -= left; + strm->total_out += out; + state->total += out; + + if (out) + strm->adler = state->check = + UPDATE(state->check, put - out, out); + + out = left; + + if (( +#ifdef GUNZIP + state->flags ? hold : +#endif + ZSWAP32(hold)) != state->check) + { + strm->msg = (char*)"incorrect data check"; state->mode = BAD; break; } -#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR - Trace((stderr, "inflate.c too far\n")); - copy -= state->whave; - if (copy > state->length) copy = state->length; - if (copy > left) copy = left; - left -= copy; - state->length -= copy; - do { - *put++ = 0; - } while (--copy); - if (state->length == 0) state->mode = LEN; - break; -#endif + + INITBITS(); + Tracev((stderr, "inflate: check matches trailer\n")); } - if (copy > state->wnext) { - copy -= state->wnext; - from = state->window + (state->wsize - copy); - } - else - from = state->window + (state->wnext - copy); - if (copy > state->length) copy = state->length; - } - else { /* copy from output */ - from = put - state->offset; - copy = state->length; - } - if (copy > left) copy = left; - left -= copy; - state->length -= copy; - do { - *put++ = *from++; - } while (--copy); - if (state->length == 0) state->mode = LEN; - break; - case LIT: - if (left == 0) goto inf_leave; - *put++ = (unsigned char)(state->length); - left--; - state->mode = LEN; - break; - case CHECK: - if (state->wrap) { - NEEDBITS(32); - out -= left; - strm->total_out += out; - state->total += out; - if (out) - strm->adler = state->check = - UPDATE(state->check, put - out, out); - out = left; - if (( #ifdef GUNZIP - state->flags ? hold : -#endif - ZSWAP32(hold)) != state->check) { - strm->msg = (char *)"incorrect data check"; - state->mode = BAD; - break; + state->mode = LENGTH; + + case LENGTH: + if (state->wrap && state->flags) + { + NEEDBITS(32); + + if (hold != (state->total & 0xffffffffUL)) + { + strm->msg = (char*)"incorrect length check"; + state->mode = BAD; + break; + } + + INITBITS(); + Tracev((stderr, "inflate: length matches trailer\n")); } - INITBITS(); - Tracev((stderr, "inflate: check matches trailer\n")); - } -#ifdef GUNZIP - state->mode = LENGTH; - case LENGTH: - if (state->wrap && state->flags) { - NEEDBITS(32); - if (hold != (state->total & 0xffffffffUL)) { - strm->msg = (char *)"incorrect length check"; - state->mode = BAD; - break; - } - INITBITS(); - Tracev((stderr, "inflate: length matches trailer\n")); - } #endif - state->mode = DONE; - case DONE: - ret = Z_STREAM_END; - goto inf_leave; - case BAD: - ret = Z_DATA_ERROR; - goto inf_leave; - case MEM: - return Z_MEM_ERROR; - case SYNC: - default: - return Z_STREAM_ERROR; + state->mode = DONE; + + case DONE: + ret = Z_STREAM_END; + goto inf_leave; + case BAD: + ret = Z_DATA_ERROR; + goto inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + default: + return Z_STREAM_ERROR; } /* @@ -1279,27 +1510,34 @@ int flush; error. Call updatewindow() to create and/or update the window state. Note: a memory error from inflate() is non-recoverable. */ - inf_leave: +inf_leave: RESTORE(); + if (state->wsize || (out != strm->avail_out && state->mode < BAD && - (state->mode < CHECK || flush != Z_FINISH))) - if (updatewindow(strm, out)) { + (state->mode < CHECK || flush != Z_FINISH))) + if (updatewindow(strm, out)) + { state->mode = MEM; return Z_MEM_ERROR; } + in -= strm->avail_in; out -= strm->avail_out; strm->total_in += in; strm->total_out += out; state->total += out; + if (state->wrap && out) strm->adler = state->check = - UPDATE(state->check, strm->next_out - out, out); + UPDATE(state->check, strm->next_out - out, out); + strm->data_type = state->bits + (state->last ? 64 : 0) + (state->mode == TYPE ? 128 : 0) + (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); + if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) ret = Z_BUF_ERROR; + return ret; } @@ -1310,11 +1548,15 @@ int ZEXPORT inflateEnd(strm) z_streamp strm; #endif { - struct inflate_state FAR *state; + struct inflate_state FAR* state; + if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; + + state = (struct inflate_state FAR*)strm->state; + if (state->window != Z_NULL) ZFREE(strm, state->window); + ZFREE(strm, strm->state); strm->state = Z_NULL; Tracev((stderr, "inflate: end\n")); @@ -1322,30 +1564,34 @@ z_streamp strm; } #ifdef WIN32 -int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength) +int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef* dictionary, uInt dictLength) #else int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) z_streamp strm; -const Bytef *dictionary; +const Bytef* dictionary; uInt dictLength; #endif { - struct inflate_state FAR *state; + struct inflate_state FAR* state; unsigned long dictid; - unsigned char *next; + unsigned char* next; unsigned avail; int ret; /* check state */ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; + + state = (struct inflate_state FAR*)strm->state; + if (state->wrap != 0 && state->mode != DICT) return Z_STREAM_ERROR; /* check for correct dictionary identifier */ - if (state->mode == DICT) { + if (state->mode == DICT) + { dictid = adler32(0L, Z_NULL, 0); dictid = adler32(dictid, dictionary, dictLength); + if (dictid != state->check) return Z_DATA_ERROR; } @@ -1354,15 +1600,18 @@ uInt dictLength; existing dictionary if appropriate */ next = strm->next_out; avail = strm->avail_out; - strm->next_out = (Bytef *)dictionary + dictLength; + strm->next_out = (Bytef*)dictionary + dictLength; strm->avail_out = 0; ret = updatewindow(strm, dictLength); strm->avail_out = avail; strm->next_out = next; - if (ret) { + + if (ret) + { state->mode = MEM; return Z_MEM_ERROR; } + state->havedict = 1; Tracev((stderr, "inflate: dictionary set\n")); return Z_OK; @@ -1376,11 +1625,13 @@ z_streamp strm; gz_headerp head; #endif { - struct inflate_state FAR *state; + struct inflate_state FAR* state; /* check state */ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; + + state = (struct inflate_state FAR*)strm->state; + if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; /* save header structure */ @@ -1401,11 +1652,11 @@ gz_headerp head; zero for the first call. */ #ifdef WIN32 -local unsigned syncsearch(unsigned FAR *have, unsigned char FAR *buf, unsigned len) +local unsigned syncsearch(unsigned FAR* have, unsigned char FAR* buf, unsigned len) #else local unsigned syncsearch(have, buf, len) -unsigned FAR *have; -unsigned char FAR *buf; +unsigned FAR* have; +unsigned char FAR* buf; unsigned len; #endif { @@ -1414,15 +1665,19 @@ unsigned len; got = *have; next = 0; - while (next < len && got < 4) { + + while (next < len && got < 4) + { if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) got++; else if (buf[next]) got = 0; else got = 4 - got; + next++; } + *have = got; return next; } @@ -1437,24 +1692,30 @@ z_streamp strm; unsigned len; /* number of bytes to look at or looked at */ unsigned long in, out; /* temporary to save total_in and total_out */ unsigned char buf[4]; /* to restore bit buffer to byte string */ - struct inflate_state FAR *state; + struct inflate_state FAR* state; /* check parameters */ if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; + + state = (struct inflate_state FAR*)strm->state; + if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; /* if first time, start search in bit buffer */ - if (state->mode != SYNC) { + if (state->mode != SYNC) + { state->mode = SYNC; state->hold <<= state->bits & 7; state->bits -= state->bits & 7; len = 0; - while (state->bits >= 8) { + + while (state->bits >= 8) + { buf[len++] = (unsigned char)(state->hold); state->hold >>= 8; state->bits -= 8; } + state->have = 0; syncsearch(&(state->have), buf, len); } @@ -1467,9 +1728,12 @@ z_streamp strm; /* return no joy or set up to restart inflate() on a new block */ if (state->have != 4) return Z_DATA_ERROR; - in = strm->total_in; out = strm->total_out; + + in = strm->total_in; + out = strm->total_out; inflateReset(strm); - strm->total_in = in; strm->total_out = out; + strm->total_in = in; + strm->total_out = out; state->mode = TYPE; return Z_OK; } @@ -1489,10 +1753,11 @@ int ZEXPORT inflateSyncPoint(strm) z_streamp strm; #endif { - struct inflate_state FAR *state; + struct inflate_state FAR* state; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; + + state = (struct inflate_state FAR*)strm->state; return state->mode == STORED && state->bits == 0; } @@ -1504,26 +1769,33 @@ z_streamp dest; z_streamp source; #endif { - struct inflate_state FAR *state; - struct inflate_state FAR *copy; - unsigned char FAR *window; + struct inflate_state FAR* state; + struct inflate_state FAR* copy; + unsigned char FAR* window; unsigned wsize; /* check input */ if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || - source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) + source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)source->state; + + state = (struct inflate_state FAR*)source->state; /* allocate space */ - copy = (struct inflate_state FAR *) + copy = (struct inflate_state FAR*) ZALLOC(source, 1, sizeof(struct inflate_state)); + if (copy == Z_NULL) return Z_MEM_ERROR; + window = Z_NULL; - if (state->window != Z_NULL) { - window = (unsigned char FAR *) + + if (state->window != Z_NULL) + { + window = (unsigned char FAR*) ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); - if (window == Z_NULL) { + + if (window == Z_NULL) + { ZFREE(source, copy); return Z_MEM_ERROR; } @@ -1532,18 +1804,24 @@ z_streamp source; /* copy state */ zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state)); + if (state->lencode >= state->codes && - state->lencode <= state->codes + ENOUGH - 1) { + state->lencode <= state->codes + ENOUGH - 1) + { copy->lencode = copy->codes + (state->lencode - state->codes); copy->distcode = copy->codes + (state->distcode - state->codes); } + copy->next = copy->codes + (state->next - state->codes); - if (window != Z_NULL) { + + if (window != Z_NULL) + { wsize = 1U << state->wbits; zmemcpy(window, state->window, wsize); } + copy->window = window; - dest->state = (struct internal_state FAR *)copy; + dest->state = (struct internal_state FAR*)copy; return Z_OK; } @@ -1555,10 +1833,11 @@ z_streamp strm; int subvert; #endif { - struct inflate_state FAR *state; + struct inflate_state FAR* state; if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; - state = (struct inflate_state FAR *)strm->state; + + state = (struct inflate_state FAR*)strm->state; state->sane = !subvert; #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR return Z_OK; @@ -1575,11 +1854,12 @@ long ZEXPORT inflateMark(strm) z_streamp strm; #endif { - struct inflate_state FAR *state; + struct inflate_state FAR* state; if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16; - state = (struct inflate_state FAR *)strm->state; + + state = (struct inflate_state FAR*)strm->state; return ((long)(state->back) << 16) + - (state->mode == COPY ? state->length : + (state->mode == COPY ? state->length : (state->mode == MATCH ? state->was - state->length : 0)); } diff --git a/extern/zlib/inflate.h b/extern/zlib/inflate.h index 95f4986..a495014 100644 --- a/extern/zlib/inflate.h +++ b/extern/zlib/inflate.h @@ -17,7 +17,8 @@ #endif /* Possible inflate modes between inflate() calls */ -typedef enum { +typedef enum +{ HEAD, /* i: waiting for magic header */ FLAGS, /* i: waiting for method and flags (gzip) */ TIME, /* i: waiting for modification time (gzip) */ @@ -29,21 +30,21 @@ typedef enum { HCRC, /* i: waiting for header crc (gzip) */ DICTID, /* i: waiting for dictionary check value */ DICT, /* waiting for inflateSetDictionary() call */ - TYPE, /* i: waiting for type bits, including last-flag bit */ - TYPEDO, /* i: same, but skip check to exit inflate on new block */ - STORED, /* i: waiting for stored size (length and complement) */ - COPY_, /* i/o: same as COPY below, but only first time in */ - COPY, /* i/o: waiting for input or output to copy stored block */ - TABLE, /* i: waiting for dynamic block table lengths */ - LENLENS, /* i: waiting for code length code lengths */ - CODELENS, /* i: waiting for length/lit and distance code lengths */ - LEN_, /* i: same as LEN below, but only first time in */ - LEN, /* i: waiting for length/lit/eob code */ - LENEXT, /* i: waiting for length extra bits */ - DIST, /* i: waiting for distance code */ - DISTEXT, /* i: waiting for distance extra bits */ - MATCH, /* o: waiting for output space to copy string */ - LIT, /* o: waiting for output space to write literal */ + TYPE, /* i: waiting for type bits, including last-flag bit */ + TYPEDO, /* i: same, but skip check to exit inflate on new block */ + STORED, /* i: waiting for stored size (length and complement) */ + COPY_, /* i/o: same as COPY below, but only first time in */ + COPY, /* i/o: waiting for input or output to copy stored block */ + TABLE, /* i: waiting for dynamic block table lengths */ + LENLENS, /* i: waiting for code length code lengths */ + CODELENS, /* i: waiting for length/lit and distance code lengths */ + LEN_, /* i: same as LEN below, but only first time in */ + LEN, /* i: waiting for length/lit/eob code */ + LENEXT, /* i: waiting for length extra bits */ + DIST, /* i: waiting for distance code */ + DISTEXT, /* i: waiting for distance extra bits */ + MATCH, /* o: waiting for output space to copy string */ + LIT, /* o: waiting for output space to write literal */ CHECK, /* i: waiting for 32-bit check value */ LENGTH, /* i: waiting for 32-bit length (gzip) */ DONE, /* finished check, done -- remain here until reset */ @@ -78,7 +79,8 @@ typedef enum { */ /* state maintained between inflate() calls. Approximately 10K bytes. */ -struct inflate_state { +struct inflate_state +{ inflate_mode mode; /* current inflate mode */ int last; /* true if processing last block */ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ @@ -88,31 +90,31 @@ struct inflate_state { unsigned long check; /* protected copy of check value */ unsigned long total; /* protected copy of output count */ gz_headerp head; /* where to save gzip header information */ - /* sliding window */ + /* sliding window */ unsigned wbits; /* log base 2 of requested window size */ unsigned wsize; /* window size or zero if not using window */ unsigned whave; /* valid bytes in the window */ unsigned wnext; /* window write index */ - unsigned char FAR *window; /* allocated sliding window, if needed */ - /* bit accumulator */ + unsigned char FAR* window; /* allocated sliding window, if needed */ + /* bit accumulator */ unsigned long hold; /* input bit accumulator */ unsigned bits; /* number of bits in "in" */ - /* for string and stored block copying */ + /* for string and stored block copying */ unsigned length; /* literal or length of data to copy */ unsigned offset; /* distance back to copy string from */ - /* for table and code decoding */ + /* for table and code decoding */ unsigned extra; /* extra bits needed */ - /* fixed and dynamic code tables */ - code const FAR *lencode; /* starting table for length/literal codes */ - code const FAR *distcode; /* starting table for distance codes */ + /* fixed and dynamic code tables */ + code const FAR* lencode; /* starting table for length/literal codes */ + code const FAR* distcode; /* starting table for distance codes */ unsigned lenbits; /* index bits for lencode */ unsigned distbits; /* index bits for distcode */ - /* dynamic table building */ + /* dynamic table building */ unsigned ncode; /* number of code length code lengths */ unsigned nlen; /* number of length code lengths */ unsigned ndist; /* number of distance code lengths */ unsigned have; /* number of code lengths in lens[] */ - code FAR *next; /* next available space in codes[] */ + code FAR* next; /* next available space in codes[] */ unsigned short lens[320]; /* temporary storage for code lengths */ unsigned short work[288]; /* work area for code table building */ code codes[ENOUGH]; /* space for code tables */ diff --git a/extern/zlib/inftrees.c b/extern/zlib/inftrees.c index fd1ff6b..201e391 100644 --- a/extern/zlib/inftrees.c +++ b/extern/zlib/inftrees.c @@ -9,8 +9,8 @@ #define MAXBITS 15 const char inflate_copyright[] = -// " inflate 1.2.7 Copyright 1995-2012 Mark Adler "; - " inflate 1.2.7.f-hanba-win64 Copyright (C) 2012-14 Jonathan Hanba"; + // " inflate 1.2.7 Copyright 1995-2012 Mark Adler "; + " inflate 1.2.7.f-hanba-win64 Copyright (C) 2012-14 Jonathan Hanba"; /* If you use the zlib library in a product, an acknowledgment is welcome in the documentation of your product. If for some reason you cannot @@ -43,15 +43,15 @@ const char inflate_copyright[] = longest code or if it is less than the shortest code. */ #ifdef WIN32 -int ZLIB_INTERNAL inflate_table(codetype type, unsigned short FAR *lens, unsigned int codes, code FAR * FAR *table, unsigned FAR *bits, unsigned short FAR *work) +int ZLIB_INTERNAL inflate_table(codetype type, unsigned short FAR* lens, unsigned int codes, code FAR* FAR* table, unsigned FAR* bits, unsigned short FAR* work) #else int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work) codetype type; -unsigned short FAR *lens; +unsigned short FAR* lens; unsigned codes; -code FAR * FAR *table; -unsigned FAR *bits; -unsigned short FAR *work; +code FAR* FAR* table; +unsigned FAR* bits; +unsigned short FAR* work; #endif { unsigned len; /* a code's length in bits */ @@ -68,26 +68,34 @@ unsigned short FAR *work; unsigned low; /* low bits for current root entry */ unsigned mask; /* mask for low root bits */ code here; /* table entry for duplication */ - code FAR *next; /* next available space in table */ - const unsigned short FAR *base; /* base value table to use */ - const unsigned short FAR *extra; /* extra bits table to use */ + code FAR* next; /* next available space in table */ + const unsigned short FAR* base; /* base value table to use */ + const unsigned short FAR* extra; /* extra bits table to use */ int end; /* use base and extra for symbol > end */ - unsigned short count[MAXBITS+1]; /* number of codes of each length */ - unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ - static const unsigned short lbase[31] = { /* Length codes 257..285 base */ + unsigned short count[MAXBITS + 1]; /* number of codes of each length */ + unsigned short offs[MAXBITS + 1]; /* offsets in table for each length */ + static const unsigned short lbase[31] = /* Length codes 257..285 base */ + { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, - 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; - static const unsigned short lext[31] = { /* Length codes 257..285 extra */ + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 + }; + static const unsigned short lext[31] = /* Length codes 257..285 extra */ + { 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, - 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 78, 68}; - static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ + 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 78, 68 + }; + static const unsigned short dbase[32] = /* Distance codes 0..29 base */ + { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, - 8193, 12289, 16385, 24577, 0, 0}; - static const unsigned short dext[32] = { /* Distance codes 0..29 extra */ + 8193, 12289, 16385, 24577, 0, 0 + }; + static const unsigned short dext[32] = /* Distance codes 0..29 extra */ + { 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, - 28, 28, 29, 29, 64, 64}; + 28, 28, 29, 29, 64, 64 + }; /* Process a set of code lengths to create a canonical Huffman code. The @@ -123,15 +131,20 @@ unsigned short FAR *work; /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ for (len = 0; len <= MAXBITS; len++) count[len] = 0; + for (sym = 0; sym < codes; sym++) count[lens[sym]]++; /* bound code lengths, force root to be within code lengths */ root = *bits; + for (max = MAXBITS; max >= 1; max--) if (count[max] != 0) break; + if (root > max) root = max; - if (max == 0) { /* no symbols to code at all */ + + if (max == 0) /* no symbols to code at all */ + { here.op = (unsigned char)64; /* invalid code marker */ here.bits = (unsigned char)1; here.val = (unsigned short)0; @@ -140,22 +153,29 @@ unsigned short FAR *work; *bits = 1; return 0; /* no symbols, but wait for decoding to report error */ } + for (min = 1; min < max; min++) if (count[min] != 0) break; + if (root < min) root = min; /* check for an over-subscribed or incomplete set of lengths */ left = 1; - for (len = 1; len <= MAXBITS; len++) { + + for (len = 1; len <= MAXBITS; len++) + { left <<= 1; left -= count[len]; + if (left < 0) return -1; /* over-subscribed */ } + if (left > 0 && (type == CODES || max != 1)) return -1; /* incomplete set */ /* generate offsets into symbol table for each length for sorting */ offs[1] = 0; + for (len = 1; len < MAXBITS; len++) offs[len + 1] = offs[len] + count[len]; @@ -195,22 +215,25 @@ unsigned short FAR *work; */ /* set up for code type */ - switch (type) { - case CODES: - base = extra = work; /* dummy value--not used */ - end = 19; - break; - case LENS: - base = lbase; - base -= 257; - extra = lext; - extra -= 257; - end = 256; - break; - default: /* DISTS */ - base = dbase; - extra = dext; - end = -1; + switch (type) + { + case CODES: + base = extra = work; /* dummy value--not used */ + end = 19; + break; + + case LENS: + base = lbase; + base -= 257; + extra = lext; + extra -= 257; + end = 256; + break; + + default: /* DISTS */ + base = dbase; + extra = dext; + end = -1; } /* initialize state for loop */ @@ -226,22 +249,27 @@ unsigned short FAR *work; /* check available table space */ if ((type == LENS && used >= ENOUGH_LENS) || - (type == DISTS && used >= ENOUGH_DISTS)) + (type == DISTS && used >= ENOUGH_DISTS)) return 1; /* process all codes and make table entries */ - for (;;) { + for (;;) + { /* create table entry */ here.bits = (unsigned char)(len - drop); - if ((int)(work[sym]) < end) { + + if ((int)(work[sym]) < end) + { here.op = (unsigned char)0; here.val = work[sym]; } - else if ((int)(work[sym]) > end) { + else if ((int)(work[sym]) > end) + { here.op = (unsigned char)(extra[work[sym]]); here.val = base[work[sym]]; } - else { + else + { here.op = (unsigned char)(32 + 64); /* end of block */ here.val = 0; } @@ -250,16 +278,22 @@ unsigned short FAR *work; incr = 1U << (len - drop); fill = 1U << curr; min = fill; /* save offset to next table */ - do { + + do + { fill -= incr; next[(huff >> drop) + fill] = here; - } while (fill != 0); + } + while (fill != 0); /* backwards increment the len-bit code huff */ incr = 1U << (len - 1); + while (huff & incr) incr >>= 1; - if (incr != 0) { + + if (incr != 0) + { huff &= incr - 1; huff += incr; } @@ -268,13 +302,17 @@ unsigned short FAR *work; /* go to next symbol, update count, len */ sym++; - if (--(count[len]) == 0) { + + if (--(count[len]) == 0) + { if (len == max) break; + len = lens[work[sym]]; } /* create new sub-table if needed */ - if (len > root && (huff & mask) != low) { + if (len > root && (huff & mask) != low) + { /* if first time, transition to sub-tables */ if (drop == 0) drop = root; @@ -285,17 +323,22 @@ unsigned short FAR *work; /* determine length of next table */ curr = len - drop; left = (int)(1 << curr); - while (curr + drop < max) { + + while (curr + drop < max) + { left -= count[curr + drop]; + if (left <= 0) break; + curr++; left <<= 1; } /* check for enough space */ used += 1U << curr; + if ((type == LENS && used >= ENOUGH_LENS) || - (type == DISTS && used >= ENOUGH_DISTS)) + (type == DISTS && used >= ENOUGH_DISTS)) return 1; /* point entry in root table to sub-table */ @@ -309,7 +352,8 @@ unsigned short FAR *work; /* fill in remaining table entry if code is incomplete (guaranteed to have at most one remaining entry, since if the code is incomplete, the maximum code length that was allowed to get this far is one bit) */ - if (huff != 0) { + if (huff != 0) + { here.op = (unsigned char)64; /* invalid code marker */ here.bits = (unsigned char)(len - drop); here.val = (unsigned short)0; diff --git a/extern/zlib/inftrees.h b/extern/zlib/inftrees.h index baa53a0..edcc87d 100644 --- a/extern/zlib/inftrees.h +++ b/extern/zlib/inftrees.h @@ -21,7 +21,8 @@ of the bit buffer. val is the actual byte to output in the case of a literal, the base length or distance, or the offset from the current table to the next table. Each entry is four bytes. */ -typedef struct { +typedef struct +{ unsigned char op; /* operation, extra bits, table bits */ unsigned char bits; /* bits in this part of the code */ unsigned short val; /* offset in table or code value */ @@ -51,12 +52,13 @@ typedef struct { #define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS) /* Type of code to build for inflate_table() */ -typedef enum { +typedef enum +{ CODES, LENS, DISTS } codetype; -int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, - unsigned codes, code FAR * FAR *table, - unsigned FAR *bits, unsigned short FAR *work)); +int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR* lens, + unsigned codes, code FAR* FAR* table, + unsigned FAR* bits, unsigned short FAR* work)); diff --git a/extern/zlib/test/example.c b/extern/zlib/test/example.c index f515a48..8b33133 100644 --- a/extern/zlib/test/example.c +++ b/extern/zlib/test/example.c @@ -34,36 +34,36 @@ const char hello[] = "hello, hello!"; const char dictionary[] = "hello"; uLong dictId; /* Adler32 value of the dictionary */ -void test_deflate OF((Byte *compr, uLong comprLen)); -void test_inflate OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -void test_large_deflate OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -void test_large_inflate OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -void test_flush OF((Byte *compr, uLong *comprLen)); -void test_sync OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -void test_dict_deflate OF((Byte *compr, uLong comprLen)); -void test_dict_inflate OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -int main OF((int argc, char *argv[])); +void test_deflate OF((Byte* compr, uLong comprLen)); +void test_inflate OF((Byte* compr, uLong comprLen, + Byte* uncompr, uLong uncomprLen)); +void test_large_deflate OF((Byte* compr, uLong comprLen, + Byte* uncompr, uLong uncomprLen)); +void test_large_inflate OF((Byte* compr, uLong comprLen, + Byte* uncompr, uLong uncomprLen)); +void test_flush OF((Byte* compr, uLong* comprLen)); +void test_sync OF((Byte* compr, uLong comprLen, + Byte* uncompr, uLong uncomprLen)); +void test_dict_deflate OF((Byte* compr, uLong comprLen)); +void test_dict_inflate OF((Byte* compr, uLong comprLen, + Byte* uncompr, uLong uncomprLen)); +int main OF((int argc, char* argv[])); #ifdef Z_SOLO -void *myalloc OF((void *, unsigned, unsigned)); -void myfree OF((void *, void *)); +void* myalloc OF((void*, unsigned, unsigned)); +void myfree OF((void*, void*)); -void *myalloc(q, n, m) - void *q; - unsigned n, m; +void* myalloc(q, n, m) +void* q; +unsigned n, m; { q = Z_NULL; return calloc(n, m); } -void myfree(void *q, void *p) +void myfree(void* q, void* p) { q = Z_NULL; free(p); @@ -77,20 +77,20 @@ static free_func zfree = myfree; static alloc_func zalloc = (alloc_func)0; static free_func zfree = (free_func)0; -void test_compress OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -void test_gzio OF((const char *fname, - Byte *uncompr, uLong uncomprLen)); +void test_compress OF((Byte* compr, uLong comprLen, + Byte* uncompr, uLong uncomprLen)); +void test_gzio OF((const char* fname, + Byte* uncompr, uLong uncomprLen)); /* =========================================================================== * Test compress() and uncompress() */ void test_compress(compr, comprLen, uncompr, uncomprLen) - Byte *compr, *uncompr; - uLong comprLen, uncomprLen; +Byte* compr, *uncompr; +uLong comprLen, uncomprLen; { int err; - uLong len = (uLong)strlen(hello)+1; + uLong len = (uLong)strlen(hello) + 1; err = compress(compr, &comprLen, (const Bytef*)hello, len); CHECK_ERR(err, "compress"); @@ -100,11 +100,14 @@ void test_compress(compr, comprLen, uncompr, uncomprLen) err = uncompress(uncompr, &uncomprLen, compr, comprLen); CHECK_ERR(err, "uncompress"); - if (strcmp((char*)uncompr, hello)) { + if (strcmp((char*)uncompr, hello)) + { fprintf(stderr, "bad uncompress\n"); exit(1); - } else { - printf("uncompress(): %s\n", (char *)uncompr); + } + else + { + printf("uncompress(): %s\n", (char*)uncompr); } } @@ -112,79 +115,105 @@ void test_compress(compr, comprLen, uncompr, uncomprLen) * Test read/write of .gz files */ void test_gzio(fname, uncompr, uncomprLen) - const char *fname; /* compressed file name */ - Byte *uncompr; - uLong uncomprLen; +const char* fname; /* compressed file name */ +Byte* uncompr; +uLong uncomprLen; { #ifdef NO_GZCOMPRESS fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n"); #else int err; - int len = (int)strlen(hello)+1; + int len = (int)strlen(hello) + 1; gzFile file; z_off_t pos; file = gzopen(fname, "wb"); - if (file == NULL) { + + if (file == NULL) + { fprintf(stderr, "gzopen error\n"); exit(1); } + gzputc(file, 'h'); - if (gzputs(file, "ello") != 4) { + + if (gzputs(file, "ello") != 4) + { fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err)); exit(1); } - if (gzprintf(file, ", %s!", "hello") != 8) { + + if (gzprintf(file, ", %s!", "hello") != 8) + { fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err)); exit(1); } + gzseek(file, 1L, SEEK_CUR); /* add one zero byte */ gzclose(file); file = gzopen(fname, "rb"); - if (file == NULL) { + + if (file == NULL) + { fprintf(stderr, "gzopen error\n"); exit(1); } + strcpy((char*)uncompr, "garbage"); - if (gzread(file, uncompr, (unsigned)uncomprLen) != len) { + if (gzread(file, uncompr, (unsigned)uncomprLen) != len) + { fprintf(stderr, "gzread err: %s\n", gzerror(file, &err)); exit(1); } - if (strcmp((char*)uncompr, hello)) { + + if (strcmp((char*)uncompr, hello)) + { fprintf(stderr, "bad gzread: %s\n", (char*)uncompr); exit(1); - } else { + } + else + { printf("gzread(): %s\n", (char*)uncompr); } pos = gzseek(file, -8L, SEEK_CUR); - if (pos != 6 || gztell(file) != pos) { + + if (pos != 6 || gztell(file) != pos) + { fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n", (long)pos, (long)gztell(file)); exit(1); } - if (gzgetc(file) != ' ') { + if (gzgetc(file) != ' ') + { fprintf(stderr, "gzgetc error\n"); exit(1); } - if (gzungetc(' ', file) != ' ') { + if (gzungetc(' ', file) != ' ') + { fprintf(stderr, "gzungetc error\n"); exit(1); } gzgets(file, (char*)uncompr, (int)uncomprLen); - if (strlen((char*)uncompr) != 7) { /* " hello!" */ + + if (strlen((char*)uncompr) != 7) /* " hello!" */ + { fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err)); exit(1); } - if (strcmp((char*)uncompr, hello + 6)) { + + if (strcmp((char*)uncompr, hello + 6)) + { fprintf(stderr, "bad gzgets after gzseek\n"); exit(1); - } else { + } + else + { printf("gzgets() after gzseek: %s\n", (char*)uncompr); } @@ -198,12 +227,12 @@ void test_gzio(fname, uncompr, uncomprLen) * Test deflate() with small buffers */ void test_deflate(compr, comprLen) - Byte *compr; - uLong comprLen; +Byte* compr; +uLong comprLen; { z_stream c_stream; /* compression stream */ int err; - uLong len = (uLong)strlen(hello)+1; + uLong len = (uLong)strlen(hello) + 1; c_stream.zalloc = zalloc; c_stream.zfree = zfree; @@ -215,16 +244,21 @@ void test_deflate(compr, comprLen) c_stream.next_in = (Bytef*)hello; c_stream.next_out = compr; - while (c_stream.total_in != len && c_stream.total_out < comprLen) { + while (c_stream.total_in != len && c_stream.total_out < comprLen) + { c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ err = deflate(&c_stream, Z_NO_FLUSH); CHECK_ERR(err, "deflate"); } + /* Finish the stream, still forcing small buffers: */ - for (;;) { + for (;;) + { c_stream.avail_out = 1; err = deflate(&c_stream, Z_FINISH); + if (err == Z_STREAM_END) break; + CHECK_ERR(err, "deflate"); } @@ -236,8 +270,8 @@ void test_deflate(compr, comprLen) * Test inflate() with small buffers */ void test_inflate(compr, comprLen, uncompr, uncomprLen) - Byte *compr, *uncompr; - uLong comprLen, uncomprLen; +Byte* compr, *uncompr; +uLong comprLen, uncomprLen; { int err; z_stream d_stream; /* decompression stream */ @@ -255,21 +289,27 @@ void test_inflate(compr, comprLen, uncompr, uncomprLen) err = inflateInit(&d_stream); CHECK_ERR(err, "inflateInit"); - while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) { + while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) + { d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */ err = inflate(&d_stream, Z_NO_FLUSH); + if (err == Z_STREAM_END) break; + CHECK_ERR(err, "inflate"); } err = inflateEnd(&d_stream); CHECK_ERR(err, "inflateEnd"); - if (strcmp((char*)uncompr, hello)) { + if (strcmp((char*)uncompr, hello)) + { fprintf(stderr, "bad inflate\n"); exit(1); - } else { - printf("inflate(): %s\n", (char *)uncompr); + } + else + { + printf("inflate(): %s\n", (char*)uncompr); } } @@ -277,8 +317,8 @@ void test_inflate(compr, comprLen, uncompr, uncomprLen) * Test deflate() with large buffers and dynamic change of compression level */ void test_large_deflate(compr, comprLen, uncompr, uncomprLen) - Byte *compr, *uncompr; - uLong comprLen, uncomprLen; +Byte* compr, *uncompr; +uLong comprLen, uncomprLen; { z_stream c_stream; /* compression stream */ int err; @@ -300,7 +340,9 @@ void test_large_deflate(compr, comprLen, uncompr, uncomprLen) c_stream.avail_in = (uInt)uncomprLen; err = deflate(&c_stream, Z_NO_FLUSH); CHECK_ERR(err, "deflate"); - if (c_stream.avail_in != 0) { + + if (c_stream.avail_in != 0) + { fprintf(stderr, "deflate not greedy\n"); exit(1); } @@ -308,7 +350,7 @@ void test_large_deflate(compr, comprLen, uncompr, uncomprLen) /* Feed in already compressed data and switch to no compression: */ deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY); c_stream.next_in = compr; - c_stream.avail_in = (uInt)comprLen/2; + c_stream.avail_in = (uInt)comprLen / 2; err = deflate(&c_stream, Z_NO_FLUSH); CHECK_ERR(err, "deflate"); @@ -320,10 +362,13 @@ void test_large_deflate(compr, comprLen, uncompr, uncomprLen) CHECK_ERR(err, "deflate"); err = deflate(&c_stream, Z_FINISH); - if (err != Z_STREAM_END) { + + if (err != Z_STREAM_END) + { fprintf(stderr, "deflate should report Z_STREAM_END\n"); exit(1); } + err = deflateEnd(&c_stream); CHECK_ERR(err, "deflateEnd"); } @@ -332,8 +377,8 @@ void test_large_deflate(compr, comprLen, uncompr, uncomprLen) * Test inflate() with large buffers */ void test_large_inflate(compr, comprLen, uncompr, uncomprLen) - Byte *compr, *uncompr; - uLong comprLen, uncomprLen; +Byte* compr, *uncompr; +uLong comprLen, uncomprLen; { int err; z_stream d_stream; /* decompression stream */ @@ -350,21 +395,27 @@ void test_large_inflate(compr, comprLen, uncompr, uncomprLen) err = inflateInit(&d_stream); CHECK_ERR(err, "inflateInit"); - for (;;) { + for (;;) + { d_stream.next_out = uncompr; /* discard the output */ d_stream.avail_out = (uInt)uncomprLen; err = inflate(&d_stream, Z_NO_FLUSH); + if (err == Z_STREAM_END) break; + CHECK_ERR(err, "large inflate"); } err = inflateEnd(&d_stream); CHECK_ERR(err, "inflateEnd"); - if (d_stream.total_out != 2*uncomprLen + comprLen/2) { + if (d_stream.total_out != 2 * uncomprLen + comprLen / 2) + { fprintf(stderr, "bad large inflate: %ld\n", d_stream.total_out); exit(1); - } else { + } + else + { printf("large_inflate(): OK\n"); } } @@ -373,12 +424,12 @@ void test_large_inflate(compr, comprLen, uncompr, uncomprLen) * Test deflate() with full flush */ void test_flush(compr, comprLen) - Byte *compr; - uLong *comprLen; +Byte* compr; +uLong* comprLen; { z_stream c_stream; /* compression stream */ int err; - uInt len = (uInt)strlen(hello)+1; + uInt len = (uInt)strlen(hello) + 1; c_stream.zalloc = zalloc; c_stream.zfree = zfree; @@ -390,7 +441,7 @@ void test_flush(compr, comprLen) c_stream.next_in = (Bytef*)hello; c_stream.next_out = compr; c_stream.avail_in = 3; - c_stream.avail_out = (uInt)*comprLen; + c_stream.avail_out = (uInt) * comprLen; err = deflate(&c_stream, Z_FULL_FLUSH); CHECK_ERR(err, "deflate"); @@ -398,9 +449,12 @@ void test_flush(compr, comprLen) c_stream.avail_in = len - 3; err = deflate(&c_stream, Z_FINISH); - if (err != Z_STREAM_END) { + + if (err != Z_STREAM_END) + { CHECK_ERR(err, "deflate"); } + err = deflateEnd(&c_stream); CHECK_ERR(err, "deflateEnd"); @@ -411,8 +465,8 @@ void test_flush(compr, comprLen) * Test inflateSync() */ void test_sync(compr, comprLen, uncompr, uncomprLen) - Byte *compr, *uncompr; - uLong comprLen, uncomprLen; +Byte* compr, *uncompr; +uLong comprLen, uncomprLen; { int err; z_stream d_stream; /* decompression stream */ @@ -435,28 +489,31 @@ void test_sync(compr, comprLen, uncompr, uncomprLen) inflate(&d_stream, Z_NO_FLUSH); CHECK_ERR(err, "inflate"); - d_stream.avail_in = (uInt)comprLen-2; /* read all compressed data */ + d_stream.avail_in = (uInt)comprLen - 2; /* read all compressed data */ err = inflateSync(&d_stream); /* but skip the damaged part */ CHECK_ERR(err, "inflateSync"); err = inflate(&d_stream, Z_FINISH); - if (err != Z_DATA_ERROR) { + + if (err != Z_DATA_ERROR) + { fprintf(stderr, "inflate should report DATA_ERROR\n"); /* Because of incorrect adler32 */ exit(1); } + err = inflateEnd(&d_stream); CHECK_ERR(err, "inflateEnd"); - printf("after inflateSync(): hel%s\n", (char *)uncompr); + printf("after inflateSync(): hel%s\n", (char*)uncompr); } /* =========================================================================== * Test deflate() with preset dictionary */ void test_dict_deflate(compr, comprLen) - Byte *compr; - uLong comprLen; +Byte* compr; +uLong comprLen; { z_stream c_stream; /* compression stream */ int err; @@ -469,7 +526,7 @@ void test_dict_deflate(compr, comprLen) CHECK_ERR(err, "deflateInit"); err = deflateSetDictionary(&c_stream, - (const Bytef*)dictionary, (int)sizeof(dictionary)); + (const Bytef*)dictionary, (int)sizeof(dictionary)); CHECK_ERR(err, "deflateSetDictionary"); dictId = c_stream.adler; @@ -477,13 +534,16 @@ void test_dict_deflate(compr, comprLen) c_stream.avail_out = (uInt)comprLen; c_stream.next_in = (Bytef*)hello; - c_stream.avail_in = (uInt)strlen(hello)+1; + c_stream.avail_in = (uInt)strlen(hello) + 1; err = deflate(&c_stream, Z_FINISH); - if (err != Z_STREAM_END) { + + if (err != Z_STREAM_END) + { fprintf(stderr, "deflate should report Z_STREAM_END\n"); exit(1); } + err = deflateEnd(&c_stream); CHECK_ERR(err, "deflateEnd"); } @@ -492,8 +552,8 @@ void test_dict_deflate(compr, comprLen) * Test inflate() with a preset dictionary */ void test_dict_inflate(compr, comprLen, uncompr, uncomprLen) - Byte *compr, *uncompr; - uLong comprLen, uncomprLen; +Byte* compr, *uncompr; +uLong comprLen, uncomprLen; { int err; z_stream d_stream; /* decompression stream */ @@ -513,28 +573,38 @@ void test_dict_inflate(compr, comprLen, uncompr, uncomprLen) d_stream.next_out = uncompr; d_stream.avail_out = (uInt)uncomprLen; - for (;;) { + for (;;) + { err = inflate(&d_stream, Z_NO_FLUSH); + if (err == Z_STREAM_END) break; - if (err == Z_NEED_DICT) { - if (d_stream.adler != dictId) { + + if (err == Z_NEED_DICT) + { + if (d_stream.adler != dictId) + { fprintf(stderr, "unexpected dictionary"); exit(1); } + err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary, (int)sizeof(dictionary)); } + CHECK_ERR(err, "inflate with dict"); } err = inflateEnd(&d_stream); CHECK_ERR(err, "inflateEnd"); - if (strcmp((char*)uncompr, hello)) { + if (strcmp((char*)uncompr, hello)) + { fprintf(stderr, "bad inflate with dict\n"); exit(1); - } else { - printf("inflate with dictionary: %s\n", (char *)uncompr); + } + else + { + printf("inflate with dictionary: %s\n", (char*)uncompr); } } @@ -543,31 +613,36 @@ void test_dict_inflate(compr, comprLen, uncompr, uncomprLen) */ int main(argc, argv) - int argc; - char *argv[]; +int argc; +char* argv[]; { - Byte *compr, *uncompr; - uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */ + Byte* compr, *uncompr; + uLong comprLen = 10000 * sizeof(int); /* don't overflow on MSDOS */ uLong uncomprLen = comprLen; static const char* myVersion = ZLIB_VERSION; - if (zlibVersion()[0] != myVersion[0]) { + if (zlibVersion()[0] != myVersion[0]) + { fprintf(stderr, "incompatible zlib version\n"); exit(1); - } else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) { + } + else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) + { fprintf(stderr, "warning: different zlib version\n"); } printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n", - ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags()); + ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags()); compr = (Byte*)calloc((uInt)comprLen, 1); uncompr = (Byte*)calloc((uInt)uncomprLen, 1); + /* compr and uncompr are cleared to avoid reading uninitialized * data and to ensure that uncompr compresses well. */ - if (compr == Z_NULL || uncompr == Z_NULL) { + if (compr == Z_NULL || uncompr == Z_NULL) + { printf("out of memory\n"); exit(1); } diff --git a/extern/zlib/test/infcover.c b/extern/zlib/test/infcover.c index fe3d920..2d2dc1c 100644 --- a/extern/zlib/test/infcover.c +++ b/extern/zlib/test/infcover.c @@ -53,26 +53,28 @@ */ /* these items are strung together in a linked list, one for each allocation */ -struct mem_item { - void *ptr; /* pointer to allocated memory */ +struct mem_item +{ + void* ptr; /* pointer to allocated memory */ size_t size; /* requested size of allocation */ - struct mem_item *next; /* pointer to next item in list, or NULL */ + struct mem_item* next; /* pointer to next item in list, or NULL */ }; /* this structure is at the root of the linked list, and tracks statistics */ -struct mem_zone { - struct mem_item *first; /* pointer to first item in list, or NULL */ +struct mem_zone +{ + struct mem_item* first; /* pointer to first item in list, or NULL */ size_t total, highwater; /* total allocations, and largest total */ size_t limit; /* memory allocation limit, or 0 if no limit */ int notlifo, rogue; /* counts of non-LIFO frees and rogue frees */ }; /* memory allocation routine to pass to zlib */ -local void *mem_alloc(void *mem, unsigned count, unsigned size) +local void* mem_alloc(void* mem, unsigned count, unsigned size) { - void *ptr; - struct mem_item *item; - struct mem_zone *zone = mem; + void* ptr; + struct mem_item* item; + struct mem_zone* zone = mem; size_t len = count * (size_t)size; /* induced allocation failure */ @@ -82,16 +84,21 @@ local void *mem_alloc(void *mem, unsigned count, unsigned size) /* perform allocation using the standard library, fill memory with a non-zero value to make sure that the code isn't depending on zeros */ ptr = malloc(len); + if (ptr == NULL) return NULL; + memset(ptr, 0xa5, len); /* create a new item for the list */ item = malloc(sizeof(struct mem_item)); - if (item == NULL) { + + if (item == NULL) + { free(ptr); return NULL; } + item->ptr = ptr; item->size = len; @@ -101,6 +108,7 @@ local void *mem_alloc(void *mem, unsigned count, unsigned size) /* update the statistics */ zone->total += item->size; + if (zone->total > zone->highwater) zone->highwater = zone->total; @@ -109,13 +117,14 @@ local void *mem_alloc(void *mem, unsigned count, unsigned size) } /* memory free routine to pass to zlib */ -local void mem_free(void *mem, void *ptr) +local void mem_free(void* mem, void* ptr) { - struct mem_item *item, *next; - struct mem_zone *zone = mem; + struct mem_item* item, *next; + struct mem_zone* zone = mem; /* if no zone, just do a free */ - if (zone == NULL) { + if (zone == NULL) + { free(ptr); return; } @@ -123,15 +132,22 @@ local void mem_free(void *mem, void *ptr) /* point next to the item that matches ptr, or NULL if not found -- remove the item from the linked list if found */ next = zone->first; - if (next) { + + if (next) + { if (next->ptr == ptr) zone->first = next->next; /* first one is it, remove from list */ - else { - do { /* search the linked list */ + else + { + do /* search the linked list */ + { item = next; next = item->next; - } while (next != NULL && next->ptr != ptr); - if (next) { /* if found, remove from linked list */ + } + while (next != NULL && next->ptr != ptr); + + if (next) /* if found, remove from linked list */ + { item->next = next->next; zone->notlifo++; /* not a LIFO free */ } @@ -140,7 +156,8 @@ local void mem_free(void *mem, void *ptr) } /* if found, update the statistics and free the item */ - if (next) { + if (next) + { zone->total -= next->size; free(next); } @@ -155,9 +172,9 @@ local void mem_free(void *mem, void *ptr) /* set up a controlled memory allocation space for monitoring, set the stream parameters to the controlled routines, with opaque pointing to the space */ -local void mem_setup(z_stream *strm) +local void mem_setup(z_stream* strm) { - struct mem_zone *zone; + struct mem_zone* zone; zone = malloc(sizeof(struct mem_zone)); assert(zone != NULL); @@ -173,42 +190,44 @@ local void mem_setup(z_stream *strm) } /* set a limit on the total memory allocation, or 0 to remove the limit */ -local void mem_limit(z_stream *strm, size_t limit) +local void mem_limit(z_stream* strm, size_t limit) { - struct mem_zone *zone = strm->opaque; + struct mem_zone* zone = strm->opaque; zone->limit = limit; } /* show the current total requested allocations in bytes */ -local void mem_used(z_stream *strm, char *prefix) +local void mem_used(z_stream* strm, char* prefix) { - struct mem_zone *zone = strm->opaque; + struct mem_zone* zone = strm->opaque; fprintf(stderr, "%s: %lu allocated\n", prefix, zone->total); } /* show the high water allocation in bytes */ -local void mem_high(z_stream *strm, char *prefix) +local void mem_high(z_stream* strm, char* prefix) { - struct mem_zone *zone = strm->opaque; + struct mem_zone* zone = strm->opaque; fprintf(stderr, "%s: %lu high water mark\n", prefix, zone->highwater); } /* release the memory allocation zone -- if there are any surprises, notify */ -local void mem_done(z_stream *strm, char *prefix) +local void mem_done(z_stream* strm, char* prefix) { int count = 0; - struct mem_item *item, *next; - struct mem_zone *zone = strm->opaque; + struct mem_item* item, *next; + struct mem_zone* zone = strm->opaque; /* show high water mark */ mem_high(strm, prefix); /* free leftover allocations and item structures, if any */ item = zone->first; - while (item != NULL) { + + while (item != NULL) + { free(item->ptr); next = item->next; free(item); @@ -220,8 +239,10 @@ local void mem_done(z_stream *strm, char *prefix) if (count || zone->total) fprintf(stderr, "** %s: %lu bytes in %d blocks not freed\n", prefix, zone->total, count); + if (zone->notlifo) fprintf(stderr, "** %s: %d frees not LIFO\n", prefix, zone->notlifo); + if (zone->rogue) fprintf(stderr, "** %s: %d frees not recognized\n", prefix, zone->rogue); @@ -242,17 +263,21 @@ local void mem_done(z_stream *strm, char *prefix) delimiter in which case that single digit writes a byte. The returned data is allocated and must eventually be freed. NULL is returned if out of memory. If the length is not needed, then len can be NULL. */ -local unsigned char *h2b(const char *hex, unsigned *len) +local unsigned char* h2b(const char* hex, unsigned* len) { - unsigned char *in; + unsigned char* in; unsigned next, val; in = malloc((strlen(hex) + 1) >> 1); + if (in == NULL) return NULL; + next = 0; val = 1; - do { + + do + { if (*hex >= '0' && *hex <= '9') val = (val << 4) + *hex - '0'; else if (*hex >= 'A' && *hex <= 'F') @@ -261,13 +286,18 @@ local unsigned char *h2b(const char *hex, unsigned *len) val = (val << 4) + *hex - 'a' + 10; else if (val != 1 && val < 32) /* one digit followed by delimiter */ val += 240; /* make it look like two digits */ - if (val > 255) { /* have two digits */ + + if (val > 255) /* have two digits */ + { in[next++] = val & 0xff; /* save the decoded byte */ val = 1; /* start over */ } - } while (*hex++); /* go through the loop with the terminating null */ + } + while (*hex++); /* go through the loop with the terminating null */ + if (len != NULL) *len = next; + in = reallocf(in, next); return in; } @@ -281,12 +311,12 @@ local unsigned char *h2b(const char *hex, unsigned *len) header information is collected with inflateGetHeader(). If a zlib stream is looking for a dictionary, then an empty dictionary is provided. inflate() is run until all of the input data is consumed. */ -local void inf(char *hex, char *what, unsigned step, int win, unsigned len, +local void inf(char* hex, char* what, unsigned step, int win, unsigned len, int err) { int ret; unsigned have; - unsigned char *in, *out; + unsigned char* in, *out; z_stream strm, copy; gz_header head; @@ -294,55 +324,80 @@ local void inf(char *hex, char *what, unsigned step, int win, unsigned len, strm.avail_in = 0; strm.next_in = Z_NULL; ret = inflateInit2(&strm, win); - if (ret != Z_OK) { + + if (ret != Z_OK) + { mem_done(&strm, what); return; } - out = malloc(len); assert(out != NULL); - if (win == 47) { + + out = malloc(len); + assert(out != NULL); + + if (win == 47) + { head.extra = out; head.extra_max = len; head.name = out; head.name_max = len; head.comment = out; head.comm_max = len; - ret = inflateGetHeader(&strm, &head); assert(ret == Z_OK); + ret = inflateGetHeader(&strm, &head); + assert(ret == Z_OK); } - in = h2b(hex, &have); assert(in != NULL); + + in = h2b(hex, &have); + assert(in != NULL); + if (step == 0 || step > have) step = have; + strm.avail_in = step; have -= step; strm.next_in = in; - do { + + do + { strm.avail_out = len; strm.next_out = out; - ret = inflate(&strm, Z_NO_FLUSH); assert(err == 9 || ret == err); + ret = inflate(&strm, Z_NO_FLUSH); + assert(err == 9 || ret == err); + if (ret != Z_OK && ret != Z_BUF_ERROR && ret != Z_NEED_DICT) break; - if (ret == Z_NEED_DICT) { + + if (ret == Z_NEED_DICT) + { ret = inflateSetDictionary(&strm, in, 1); - assert(ret == Z_DATA_ERROR); + assert(ret == Z_DATA_ERROR); mem_limit(&strm, 1); ret = inflateSetDictionary(&strm, out, 0); - assert(ret == Z_MEM_ERROR); + assert(ret == Z_MEM_ERROR); mem_limit(&strm, 0); - ((struct inflate_state *)strm.state)->mode = DICT; + ((struct inflate_state*)strm.state)->mode = DICT; ret = inflateSetDictionary(&strm, out, 0); - assert(ret == Z_OK); - ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_BUF_ERROR); + assert(ret == Z_OK); + ret = inflate(&strm, Z_NO_FLUSH); + assert(ret == Z_BUF_ERROR); } - ret = inflateCopy(©, &strm); assert(ret == Z_OK); - ret = inflateEnd(©); assert(ret == Z_OK); + + ret = inflateCopy(©, &strm); + assert(ret == Z_OK); + ret = inflateEnd(©); + assert(ret == Z_OK); err = 9; /* don't care next time around */ have += strm.avail_in; strm.avail_in = step > have ? have : step; have -= strm.avail_in; - } while (strm.avail_in); + } + while (strm.avail_in); + free(in); free(out); - ret = inflateReset2(&strm, -8); assert(ret == Z_OK); - ret = inflateEnd(&strm); assert(ret == Z_OK); + ret = inflateReset2(&strm, -8); + assert(ret == Z_OK); + ret = inflateEnd(&strm); + assert(ret == Z_OK); mem_done(&strm, what); } @@ -355,13 +410,17 @@ local void cover_support(void) mem_setup(&strm); strm.avail_in = 0; strm.next_in = Z_NULL; - ret = inflateInit(&strm); assert(ret == Z_OK); + ret = inflateInit(&strm); + assert(ret == Z_OK); mem_used(&strm, "inflate init"); - ret = inflatePrime(&strm, 5, 31); assert(ret == Z_OK); - ret = inflatePrime(&strm, -1, 0); assert(ret == Z_OK); + ret = inflatePrime(&strm, 5, 31); + assert(ret == Z_OK); + ret = inflatePrime(&strm, -1, 0); + assert(ret == Z_OK); ret = inflateSetDictionary(&strm, Z_NULL, 0); - assert(ret == Z_STREAM_ERROR); - ret = inflateEnd(&strm); assert(ret == Z_OK); + assert(ret == Z_STREAM_ERROR); + ret = inflateEnd(&strm); + assert(ret == Z_OK); mem_done(&strm, "prime"); inf("63 0", "force window allocation", 0, -15, 1, Z_OK); @@ -374,13 +433,15 @@ local void cover_support(void) strm.avail_in = 0; strm.next_in = Z_NULL; ret = inflateInit_(&strm, ZLIB_VERSION - 1, (int)sizeof(z_stream)); - assert(ret == Z_VERSION_ERROR); + assert(ret == Z_VERSION_ERROR); mem_done(&strm, "wrong version"); strm.avail_in = 0; strm.next_in = Z_NULL; - ret = inflateInit(&strm); assert(ret == Z_OK); - ret = inflateEnd(&strm); assert(ret == Z_OK); + ret = inflateInit(&strm); + assert(ret == Z_OK); + ret = inflateEnd(&strm); + assert(ret == Z_OK); fputs("inflate built-in memory routines\n", stderr); } @@ -391,9 +452,12 @@ local void cover_wrap(void) z_stream strm, copy; unsigned char dict[257]; - ret = inflate(Z_NULL, 0); assert(ret == Z_STREAM_ERROR); - ret = inflateEnd(Z_NULL); assert(ret == Z_STREAM_ERROR); - ret = inflateCopy(Z_NULL, Z_NULL); assert(ret == Z_STREAM_ERROR); + ret = inflate(Z_NULL, 0); + assert(ret == Z_STREAM_ERROR); + ret = inflateEnd(Z_NULL); + assert(ret == Z_STREAM_ERROR); + ret = inflateCopy(Z_NULL, Z_NULL); + assert(ret == Z_STREAM_ERROR); fputs("inflate bad parameters\n", stderr); inf("1f 8b 0 0", "bad gzip method", 0, 31, 0, Z_DATA_ERROR); @@ -415,52 +479,65 @@ local void cover_wrap(void) strm.next_in = Z_NULL; ret = inflateInit2(&strm, -8); strm.avail_in = 2; - strm.next_in = (void *)"\x63"; + strm.next_in = (void*)"\x63"; strm.avail_out = 1; - strm.next_out = (void *)&ret; + strm.next_out = (void*)&ret; mem_limit(&strm, 1); - ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_MEM_ERROR); - ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_MEM_ERROR); + ret = inflate(&strm, Z_NO_FLUSH); + assert(ret == Z_MEM_ERROR); + ret = inflate(&strm, Z_NO_FLUSH); + assert(ret == Z_MEM_ERROR); mem_limit(&strm, 0); memset(dict, 0, 257); ret = inflateSetDictionary(&strm, dict, 257); - assert(ret == Z_OK); + assert(ret == Z_OK); mem_limit(&strm, (sizeof(struct inflate_state) << 1) + 256); - ret = inflatePrime(&strm, 16, 0); assert(ret == Z_OK); + ret = inflatePrime(&strm, 16, 0); + assert(ret == Z_OK); strm.avail_in = 2; - strm.next_in = (void *)"\x80"; - ret = inflateSync(&strm); assert(ret == Z_DATA_ERROR); - ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_STREAM_ERROR); + strm.next_in = (void*)"\x80"; + ret = inflateSync(&strm); + assert(ret == Z_DATA_ERROR); + ret = inflate(&strm, Z_NO_FLUSH); + assert(ret == Z_STREAM_ERROR); strm.avail_in = 4; - strm.next_in = (void *)"\0\0\xff\xff"; - ret = inflateSync(&strm); assert(ret == Z_OK); + strm.next_in = (void*)"\0\0\xff\xff"; + ret = inflateSync(&strm); + assert(ret == Z_OK); (void)inflateSyncPoint(&strm); - ret = inflateCopy(©, &strm); assert(ret == Z_MEM_ERROR); + ret = inflateCopy(©, &strm); + assert(ret == Z_MEM_ERROR); mem_limit(&strm, 0); - ret = inflateUndermine(&strm, 1); assert(ret == Z_DATA_ERROR); + ret = inflateUndermine(&strm, 1); + assert(ret == Z_DATA_ERROR); (void)inflateMark(&strm); - ret = inflateEnd(&strm); assert(ret == Z_OK); + ret = inflateEnd(&strm); + assert(ret == Z_OK); mem_done(&strm, "miscellaneous, force memory errors"); } /* input and output functions for inflateBack() */ -local unsigned pull(void *desc, unsigned char **buf) +local unsigned pull(void* desc, unsigned char** buf) { static unsigned int next = 0; static unsigned char dat[] = {0x63, 0, 2, 0}; - struct inflate_state *state; + struct inflate_state* state; - if (desc == Z_NULL) { + if (desc == Z_NULL) + { next = 0; return 0; /* no input (already provided at next_in) */ } - state = (void *)((z_stream *)desc)->state; + + state = (void*)((z_stream*)desc)->state; + if (state != Z_NULL) state->mode = SYNC; /* force an otherwise impossible situation */ + return next < sizeof(dat) ? (*buf = dat + next++, 1) : 0; } -local int push(void *desc, unsigned char *buf, unsigned len) +local int push(void* desc, unsigned char* buf, unsigned len) { buf += len; return desc != Z_NULL; /* force error if desc not null */ @@ -474,42 +551,49 @@ local void cover_back(void) unsigned char win[32768]; ret = inflateBackInit_(Z_NULL, 0, win, 0, 0); - assert(ret == Z_VERSION_ERROR); - ret = inflateBackInit(Z_NULL, 0, win); assert(ret == Z_STREAM_ERROR); + assert(ret == Z_VERSION_ERROR); + ret = inflateBackInit(Z_NULL, 0, win); + assert(ret == Z_STREAM_ERROR); ret = inflateBack(Z_NULL, Z_NULL, Z_NULL, Z_NULL, Z_NULL); - assert(ret == Z_STREAM_ERROR); - ret = inflateBackEnd(Z_NULL); assert(ret == Z_STREAM_ERROR); + assert(ret == Z_STREAM_ERROR); + ret = inflateBackEnd(Z_NULL); + assert(ret == Z_STREAM_ERROR); fputs("inflateBack bad parameters\n", stderr); mem_setup(&strm); - ret = inflateBackInit(&strm, 15, win); assert(ret == Z_OK); + ret = inflateBackInit(&strm, 15, win); + assert(ret == Z_OK); strm.avail_in = 2; - strm.next_in = (void *)"\x03"; + strm.next_in = (void*)"\x03"; ret = inflateBack(&strm, pull, Z_NULL, push, Z_NULL); - assert(ret == Z_STREAM_END); - /* force output error */ + assert(ret == Z_STREAM_END); + /* force output error */ strm.avail_in = 3; - strm.next_in = (void *)"\x63\x00"; + strm.next_in = (void*)"\x63\x00"; ret = inflateBack(&strm, pull, Z_NULL, push, &strm); - assert(ret == Z_BUF_ERROR); - /* force mode error by mucking with state */ + assert(ret == Z_BUF_ERROR); + /* force mode error by mucking with state */ ret = inflateBack(&strm, pull, &strm, push, Z_NULL); - assert(ret == Z_STREAM_ERROR); - ret = inflateBackEnd(&strm); assert(ret == Z_OK); + assert(ret == Z_STREAM_ERROR); + ret = inflateBackEnd(&strm); + assert(ret == Z_OK); mem_done(&strm, "inflateBack bad state"); - ret = inflateBackInit(&strm, 15, win); assert(ret == Z_OK); - ret = inflateBackEnd(&strm); assert(ret == Z_OK); + ret = inflateBackInit(&strm, 15, win); + assert(ret == Z_OK); + ret = inflateBackEnd(&strm); + assert(ret == Z_OK); fputs("inflateBack built-in memory routines\n", stderr); } /* do a raw inflate of data in hexadecimal with both inflate and inflateBack */ -local int try(char *hex, char *id, int err) + +local int try(char* hex, char* id, int err) { int ret; unsigned len, size; - unsigned char *in, *out, *win; - char *prefix; + unsigned char* in, *out, *win; + char* prefix; z_stream strm; /* convert to hex */ @@ -535,23 +619,31 @@ local int try(char *hex, char *id, int err) assert(ret == Z_OK); strm.avail_in = len; strm.next_in = in; - do { + + do + { strm.avail_out = size; strm.next_out = out; ret = inflate(&strm, Z_TREES); assert(ret != Z_STREAM_ERROR && ret != Z_MEM_ERROR); + if (ret == Z_DATA_ERROR || ret == Z_NEED_DICT) break; - } while (strm.avail_in || strm.avail_out == 0); - if (err) { + } + while (strm.avail_in || strm.avail_out == 0); + + if (err) + { assert(ret == Z_DATA_ERROR); assert(strcmp(id, strm.msg) == 0); } + inflateEnd(&strm); mem_done(&strm, prefix); /* then with inflateBack */ - if (err >= 0) { + if (err >= 0) + { strcpy(prefix, id); strcat(prefix, "-back"); mem_setup(&strm); @@ -561,10 +653,13 @@ local int try(char *hex, char *id, int err) strm.next_in = in; ret = inflateBack(&strm, pull, Z_NULL, push, Z_NULL); assert(ret != Z_STREAM_ERROR); - if (err) { + + if (err) + { assert(ret == Z_DATA_ERROR); assert(strcmp(id, strm.msg) == 0); } + inflateBackEnd(&strm); mem_done(&strm, prefix); } @@ -581,33 +676,53 @@ local int try(char *hex, char *id, int err) local void cover_inflate(void) { try("0 0 0 0 0", "invalid stored block lengths", 1); + try("3 0", "fixed", 0); + try("6", "invalid block type", 1); + try("1 1 0 fe ff 0", "stored", 0); + try("fc 0 0", "too many length or distance symbols", 1); + try("4 0 fe ff", "invalid code lengths set", 1); + try("4 0 24 49 0", "invalid bit length repeat", 1); + try("4 0 24 e9 ff ff", "invalid bit length repeat", 1); + try("4 0 24 e9 ff 6d", "invalid code -- missing end-of-block", 1); + try("4 80 49 92 24 49 92 24 71 ff ff 93 11 0", - "invalid literal/lengths set", 1); + "invalid literal/lengths set", 1); + try("4 80 49 92 24 49 92 24 f b4 ff ff c3 84", "invalid distances set", 1); + try("4 c0 81 8 0 0 0 0 20 7f eb b 0 0", "invalid literal/length code", 1); + try("2 7e ff ff", "invalid distance code", 1); + try("c c0 81 0 0 0 0 0 90 ff 6b 4 0", "invalid distance too far back", 1); /* also trailer mismatch just in inflate() */ try("1f 8b 8 0 0 0 0 0 0 0 3 0 0 0 0 1", "incorrect data check", -1); + try("1f 8b 8 0 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 1", - "incorrect length check", -1); + "incorrect length check", -1); + try("5 c0 21 d 0 0 0 80 b0 fe 6d 2f 91 6c", "pull 17", 0); + try("5 e0 81 91 24 cb b2 2c 49 e2 f 2e 8b 9a 47 56 9f fb fe ec d2 ff 1f", - "long code", 0); + "long code", 0); + try("ed c0 1 1 0 0 0 40 20 ff 57 1b 42 2c 4f", "length extra", 0); + try("ed cf c1 b1 2c 47 10 c4 30 fa 6f 35 1d 1 82 59 3d fb be 2e 2a fc f c", - "long distance and extra", 0); + "long distance and extra", 0); + try("ed c0 81 0 0 0 0 80 a0 fd a9 17 a9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 " - "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6", "window end", 0); + "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6", "window end", 0); + inf("2 8 20 80 0 3 0", "inflate_fast TYPE return", 0, -15, 258, Z_STREAM_END); inf("63 18 5 40 c 0", "window wrap", 3, -8, 300, Z_OK); @@ -619,21 +734,22 @@ local void cover_trees(void) int ret; unsigned bits; unsigned short lens[16], work[16]; - code *next, table[ENOUGH_DISTS]; + code* next, table[ENOUGH_DISTS]; /* we need to call inflate_table() directly in order to manifest not- enough errors, since zlib insures that enough is always enough */ for (bits = 0; bits < 15; bits++) lens[bits] = (unsigned short)(bits + 1); + lens[15] = 15; next = table; bits = 15; ret = inflate_table(DISTS, lens, 16, &next, &bits, work); - assert(ret == 1); + assert(ret == 1); next = table; bits = 1; ret = inflate_table(DISTS, lens, 16, &next, &bits, work); - assert(ret == 1); + assert(ret == 1); fputs("inflate_table not enough errors\n", stderr); } diff --git a/extern/zlib/test/minigzip.c b/extern/zlib/test/minigzip.c index aa7ac7a..378de98 100644 --- a/extern/zlib/test/minigzip.c +++ b/extern/zlib/test/minigzip.c @@ -55,7 +55,7 @@ #if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE) #ifndef WIN32 /* unlink already in stdio.h for WIN32 */ - extern int unlink OF((const char *)); +extern int unlink OF((const char*)); #endif #endif @@ -73,38 +73,43 @@ The strwinerror function does not change the current setting of GetLastError. */ -static char *strwinerror (error) - DWORD error; +static char* strwinerror(error) +DWORD error; { static char buf[1024]; - wchar_t *msgbuf; + wchar_t* msgbuf; DWORD lasterr = GetLastError(); DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM - | FORMAT_MESSAGE_ALLOCATE_BUFFER, - NULL, - error, - 0, /* Default language */ - (LPVOID)&msgbuf, - 0, - NULL); - if (chars != 0) { + | FORMAT_MESSAGE_ALLOCATE_BUFFER, + NULL, + error, + 0, /* Default language */ + (LPVOID)&msgbuf, + 0, + NULL); + + if (chars != 0) + { /* If there is an \r\n appended, zap it. */ if (chars >= 2 - && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') { + && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') + { chars -= 2; msgbuf[chars] = 0; } - if (chars > sizeof (buf) - 1) { - chars = sizeof (buf) - 1; + if (chars > sizeof(buf) - 1) + { + chars = sizeof(buf) - 1; msgbuf[chars] = 0; } wcstombs(buf, msgbuf, chars + 1); LocalFree(msgbuf); } - else { + else + { sprintf(buf, "unknown win32 error (%ld)", error); } @@ -112,13 +117,13 @@ static char *strwinerror (error) return buf; } -static void pwinerror (s) - const char *s; +static void pwinerror(s) +const char* s; { if (s && *s) - fprintf(stderr, "%s: %s\n", s, strwinerror(GetLastError ())); + fprintf(stderr, "%s: %s\n", s, strwinerror(GetLastError())); else - fprintf(stderr, "%s\n", strwinerror(GetLastError ())); + fprintf(stderr, "%s\n", strwinerror(GetLastError())); } #endif /* UNDER_CE */ @@ -133,7 +138,7 @@ static void pwinerror (s) #ifdef MAXSEG_64K # define local static - /* Needed for systems with limitation on stack size. */ +/* Needed for systems with limitation on stack size. */ #else # define local #endif @@ -145,183 +150,218 @@ static void pwinerror (s) # include /* for unlink() */ #endif -void *myalloc OF((void *, unsigned, unsigned)); -void myfree OF((void *, void *)); +void* myalloc OF((void*, unsigned, unsigned)); +void myfree OF((void*, void*)); -void *myalloc(q, n, m) - void *q; - unsigned n, m; +void* myalloc(q, n, m) +void* q; +unsigned n, m; { q = Z_NULL; return calloc(n, m); } void myfree(q, p) - void *q, *p; +void* q, *p; { q = Z_NULL; free(p); } -typedef struct gzFile_s { - FILE *file; +typedef struct gzFile_s +{ + FILE* file; int write; int err; - char *msg; + char* msg; z_stream strm; -} *gzFile; +}* gzFile; -gzFile gzopen OF((const char *, const char *)); -gzFile gzdopen OF((int, const char *)); -gzFile gz_open OF((const char *, int, const char *)); +gzFile gzopen OF((const char*, const char*)); +gzFile gzdopen OF((int, const char*)); +gzFile gz_open OF((const char*, int, const char*)); gzFile gzopen(path, mode) -const char *path; -const char *mode; +const char* path; +const char* mode; { return gz_open(path, -1, mode); } gzFile gzdopen(fd, mode) int fd; -const char *mode; +const char* mode; { return gz_open(NULL, fd, mode); } gzFile gz_open(path, fd, mode) - const char *path; - int fd; - const char *mode; +const char* path; +int fd; +const char* mode; { gzFile gz; int ret; gz = malloc(sizeof(struct gzFile_s)); + if (gz == NULL) return NULL; + gz->write = strchr(mode, 'w') != NULL; gz->strm.zalloc = myalloc; gz->strm.zfree = myfree; gz->strm.opaque = Z_NULL; + if (gz->write) ret = deflateInit2(&(gz->strm), -1, 8, 15 + 16, 8, 0); - else { + else + { gz->strm.next_in = 0; gz->strm.avail_in = Z_NULL; ret = inflateInit2(&(gz->strm), 15 + 16); } - if (ret != Z_OK) { + + if (ret != Z_OK) + { free(gz); return NULL; } + gz->file = path == NULL ? fdopen(fd, gz->write ? "wb" : "rb") : - fopen(path, gz->write ? "wb" : "rb"); - if (gz->file == NULL) { + fopen(path, gz->write ? "wb" : "rb"); + + if (gz->file == NULL) + { gz->write ? deflateEnd(&(gz->strm)) : inflateEnd(&(gz->strm)); free(gz); return NULL; } + gz->err = 0; gz->msg = ""; return gz; } -int gzwrite OF((gzFile, const void *, unsigned)); +int gzwrite OF((gzFile, const void*, unsigned)); int gzwrite(gz, buf, len) - gzFile gz; - const void *buf; - unsigned len; +gzFile gz; +const void* buf; +unsigned len; { - z_stream *strm; + z_stream* strm; unsigned char out[BUFLEN]; if (gz == NULL || !gz->write) return 0; + strm = &(gz->strm); - strm->next_in = (void *)buf; + strm->next_in = (void*)buf; strm->avail_in = len; - do { + + do + { strm->next_out = out; strm->avail_out = BUFLEN; (void)deflate(strm, Z_NO_FLUSH); fwrite(out, 1, BUFLEN - strm->avail_out, gz->file); - } while (strm->avail_out == 0); + } + while (strm->avail_out == 0); + return len; } -int gzread OF((gzFile, void *, unsigned)); +int gzread OF((gzFile, void*, unsigned)); int gzread(gz, buf, len) - gzFile gz; - void *buf; - unsigned len; +gzFile gz; +void* buf; +unsigned len; { int ret; unsigned got; unsigned char in[1]; - z_stream *strm; + z_stream* strm; if (gz == NULL || gz->write) return 0; + if (gz->err) return 0; + strm = &(gz->strm); - strm->next_out = (void *)buf; + strm->next_out = (void*)buf; strm->avail_out = len; - do { + + do + { got = fread(in, 1, 1, gz->file); + if (got == 0) break; + strm->next_in = in; strm->avail_in = 1; ret = inflate(strm, Z_NO_FLUSH); - if (ret == Z_DATA_ERROR) { + + if (ret == Z_DATA_ERROR) + { gz->err = Z_DATA_ERROR; gz->msg = strm->msg; return 0; } + if (ret == Z_STREAM_END) inflateReset(strm); - } while (strm->avail_out); + } + while (strm->avail_out); + return len - strm->avail_out; } int gzclose OF((gzFile)); int gzclose(gz) - gzFile gz; +gzFile gz; { - z_stream *strm; + z_stream* strm; unsigned char out[BUFLEN]; if (gz == NULL) return Z_STREAM_ERROR; + strm = &(gz->strm); - if (gz->write) { + + if (gz->write) + { strm->next_in = Z_NULL; strm->avail_in = 0; - do { + + do + { strm->next_out = out; strm->avail_out = BUFLEN; (void)deflate(strm, Z_FINISH); fwrite(out, 1, BUFLEN - strm->avail_out, gz->file); - } while (strm->avail_out == 0); + } + while (strm->avail_out == 0); + deflateEnd(strm); } else inflateEnd(strm); + fclose(gz->file); free(gz); return Z_OK; } -const char *gzerror OF((gzFile, int *)); +const char* gzerror OF((gzFile, int*)); -const char *gzerror(gz, err) - gzFile gz; - int *err; +const char* gzerror(gz, err) +gzFile gz; +int* err; { *err = gz->err; return gz->msg; @@ -329,23 +369,23 @@ const char *gzerror(gz, err) #endif -char *prog; +char* prog; -void error OF((const char *msg)); -void gz_compress OF((FILE *in, gzFile out)); +void error OF((const char* msg)); +void gz_compress OF((FILE* in, gzFile out)); #ifdef USE_MMAP -int gz_compress_mmap OF((FILE *in, gzFile out)); +int gz_compress_mmap OF((FILE* in, gzFile out)); #endif -void gz_uncompress OF((gzFile in, FILE *out)); -void file_compress OF((char *file, char *mode)); -void file_uncompress OF((char *file)); -int main OF((int argc, char *argv[])); +void gz_uncompress OF((gzFile in, FILE* out)); +void file_compress OF((char* file, char* mode)); +void file_uncompress OF((char* file)); +int main OF((int argc, char* argv[])); /* =========================================================================== * Display error message and exit */ void error(msg) - const char *msg; +const char* msg; { fprintf(stderr, "%s: %s\n", prog, msg); exit(1); @@ -356,30 +396,39 @@ void error(msg) */ void gz_compress(in, out) - FILE *in; - gzFile out; +FILE* in; +gzFile out; { local char buf[BUFLEN]; int len; int err; #ifdef USE_MMAP + /* Try first compressing with mmap. If mmap fails (minigzip used in a * pipe), use the normal fread loop. */ if (gz_compress_mmap(in, out) == Z_OK) return; + #endif - for (;;) { + + for (;;) + { len = (int)fread(buf, 1, sizeof(buf), in); - if (ferror(in)) { + + if (ferror(in)) + { perror("fread"); exit(1); } + if (len == 0) break; if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err)); } + fclose(in); + if (gzclose(out) != Z_OK) error("failed gzclose"); } @@ -389,8 +438,8 @@ void gz_compress(in, out) * if success, Z_ERRNO otherwise. */ int gz_compress_mmap(in, out) - FILE *in; - gzFile out; +FILE* in; +gzFile out; { int len; int err; @@ -401,21 +450,26 @@ int gz_compress_mmap(in, out) /* Determine the size of the file, needed for mmap: */ if (fstat(ifd, &sb) < 0) return Z_ERRNO; + buf_len = sb.st_size; + if (buf_len <= 0) return Z_ERRNO; /* Now do the actual mmap: */ buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0); + if (buf == (caddr_t)(-1)) return Z_ERRNO; /* Compress the whole file at once: */ - len = gzwrite(out, (char *)buf, (unsigned)buf_len); + len = gzwrite(out, (char*)buf, (unsigned)buf_len); if (len != (int)buf_len) error(gzerror(out, &err)); munmap(buf, buf_len); fclose(in); + if (gzclose(out) != Z_OK) error("failed gzclose"); + return Z_OK; } #endif /* USE_MMAP */ @@ -424,22 +478,27 @@ int gz_compress_mmap(in, out) * Uncompress input to output then close both files. */ void gz_uncompress(in, out) - gzFile in; - FILE *out; +gzFile in; +FILE* out; { local char buf[BUFLEN]; int len; int err; - for (;;) { + for (;;) + { len = gzread(in, buf, sizeof(buf)); - if (len < 0) error (gzerror(in, &err)); + + if (len < 0) error(gzerror(in, &err)); + if (len == 0) break; - if ((int)fwrite(buf, 1, (unsigned)len, out) != len) { + if ((int)fwrite(buf, 1, (unsigned)len, out) != len) + { error("failed fwrite"); } } + if (fclose(out)) error("failed fclose"); if (gzclose(in) != Z_OK) error("failed gzclose"); @@ -451,14 +510,15 @@ void gz_uncompress(in, out) * original. */ void file_compress(file, mode) - char *file; - char *mode; +char* file; +char* mode; { local char outfile[MAX_NAME_LEN]; - FILE *in; + FILE* in; gzFile out; - if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) { + if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) + { fprintf(stderr, "%s: filename too long\n", prog); exit(1); } @@ -467,15 +527,21 @@ void file_compress(file, mode) strcat(outfile, GZ_SUFFIX); in = fopen(file, "rb"); - if (in == NULL) { + + if (in == NULL) + { perror(file); exit(1); } + out = gzopen(outfile, mode); - if (out == NULL) { + + if (out == NULL) + { fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile); exit(1); } + gz_compress(in, out); unlink(file); @@ -486,37 +552,47 @@ void file_compress(file, mode) * Uncompress the given file and remove the original. */ void file_uncompress(file) - char *file; +char* file; { local char buf[MAX_NAME_LEN]; - char *infile, *outfile; - FILE *out; + char* infile, *outfile; + FILE* out; gzFile in; size_t len = strlen(file); - if (len + strlen(GZ_SUFFIX) >= sizeof(buf)) { + if (len + strlen(GZ_SUFFIX) >= sizeof(buf)) + { fprintf(stderr, "%s: filename too long\n", prog); exit(1); } strcpy(buf, file); - if (len > SUFFIX_LEN && strcmp(file+len-SUFFIX_LEN, GZ_SUFFIX) == 0) { + if (len > SUFFIX_LEN && strcmp(file + len - SUFFIX_LEN, GZ_SUFFIX) == 0) + { infile = file; outfile = buf; - outfile[len-3] = '\0'; - } else { + outfile[len - 3] = '\0'; + } + else + { outfile = file; infile = buf; strcat(infile, GZ_SUFFIX); } + in = gzopen(infile, "rb"); - if (in == NULL) { + + if (in == NULL) + { fprintf(stderr, "%s: can't gzopen %s\n", prog, infile); exit(1); } + out = fopen(outfile, "wb"); - if (out == NULL) { + + if (out == NULL) + { perror(file); exit(1); } @@ -538,94 +614,130 @@ void file_uncompress(file) */ int main(argc, argv) - int argc; - char *argv[]; +int argc; +char* argv[]; { int copyout = 0; int uncompr = 0; gzFile file; - char *bname, outmode[20]; + char* bname, outmode[20]; strcpy(outmode, "wb6 "); prog = argv[0]; bname = strrchr(argv[0], '/'); + if (bname) - bname++; + bname++; else - bname = argv[0]; + bname = argv[0]; + argc--, argv++; if (!strcmp(bname, "gunzip")) - uncompr = 1; - else if (!strcmp(bname, "zcat")) - copyout = uncompr = 1; - - while (argc > 0) { - if (strcmp(*argv, "-c") == 0) - copyout = 1; - else if (strcmp(*argv, "-d") == 0) uncompr = 1; - else if (strcmp(*argv, "-f") == 0) - outmode[3] = 'f'; - else if (strcmp(*argv, "-h") == 0) - outmode[3] = 'h'; - else if (strcmp(*argv, "-r") == 0) - outmode[3] = 'R'; - else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' && - (*argv)[2] == 0) - outmode[2] = (*argv)[1]; - else - break; - argc--, argv++; + else if (!strcmp(bname, "zcat")) + copyout = uncompr = 1; + + while (argc > 0) + { + if (strcmp(*argv, "-c") == 0) + copyout = 1; + else if (strcmp(*argv, "-d") == 0) + uncompr = 1; + else if (strcmp(*argv, "-f") == 0) + outmode[3] = 'f'; + else if (strcmp(*argv, "-h") == 0) + outmode[3] = 'h'; + else if (strcmp(*argv, "-r") == 0) + outmode[3] = 'R'; + else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' && + (*argv)[2] == 0) + outmode[2] = (*argv)[1]; + else + break; + + argc--, argv++; } + if (outmode[3] == ' ') outmode[3] = 0; - if (argc == 0) { + + if (argc == 0) + { SET_BINARY_MODE(stdin); SET_BINARY_MODE(stdout); - if (uncompr) { + + if (uncompr) + { file = gzdopen(fileno(stdin), "rb"); + if (file == NULL) error("can't gzdopen stdin"); + gz_uncompress(file, stdout); - } else { + } + else + { file = gzdopen(fileno(stdout), outmode); + if (file == NULL) error("can't gzdopen stdout"); + gz_compress(stdin, file); } - } else { - if (copyout) { + } + else + { + if (copyout) + { SET_BINARY_MODE(stdout); } - do { - if (uncompr) { - if (copyout) { + + do + { + if (uncompr) + { + if (copyout) + { file = gzopen(*argv, "rb"); + if (file == NULL) fprintf(stderr, "%s: can't gzopen %s\n", prog, *argv); else gz_uncompress(file, stdout); - } else { + } + else + { file_uncompress(*argv); } - } else { - if (copyout) { - FILE * in = fopen(*argv, "rb"); + } + else + { + if (copyout) + { + FILE* in = fopen(*argv, "rb"); - if (in == NULL) { + if (in == NULL) + { perror(*argv); - } else { + } + else + { file = gzdopen(fileno(stdout), outmode); + if (file == NULL) error("can't gzdopen stdout"); gz_compress(in, file); } - } else { + } + else + { file_compress(*argv, outmode); } } - } while (argv++, --argc); + } + while (argv++, --argc); } + return 0; } diff --git a/extern/zlib/trees.c b/extern/zlib/trees.c index a7d4ea6..20dc5ad 100644 --- a/extern/zlib/trees.c +++ b/extern/zlib/trees.c @@ -60,16 +60,16 @@ /* repeat a zero length 11-138 times (7 bits of repeat count) */ local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ - = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; + = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0}; local const int extra_dbits[D_CODES] /* extra bits for each distance code */ - = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + = {0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13}; local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */ - = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; + = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7}; local const uch bl_order[BL_CODES] - = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; + = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; /* The lengths of the bit length codes are sent in order of decreasing * probability, to avoid transmitting the lengths for unused bit length codes. */ @@ -83,7 +83,7 @@ local const uch bl_order[BL_CODES] #if defined(GEN_TREES_H) || !defined(STDC) /* non ANSI compilers may not accept trees.h */ -local ct_data static_ltree[L_CODES+2]; +local ct_data static_ltree[L_CODES + 2]; /* The static literal tree. Since the bit lengths are imposed, there is no * need for the L_CODES extra codes used during heap construction. However * The codes 286 and 287 are needed to build a canonical tree (see _tr_init @@ -101,7 +101,7 @@ uch _dist_code[DIST_CODE_LEN]; * the 15 bit distances. */ -uch _length_code[MAX_MATCH-MIN_MATCH+1]; +uch _length_code[MAX_MATCH - MIN_MATCH + 1]; /* length code for each normalized match length (0 == MIN_MATCH) */ local int base_length[LENGTH_CODES]; @@ -114,45 +114,46 @@ local int base_dist[D_CODES]; # include "trees.h" #endif /* GEN_TREES_H */ -struct static_tree_desc_s { - const ct_data *static_tree; /* static tree or NULL */ - const intf *extra_bits; /* extra bits for each code or NULL */ +struct static_tree_desc_s +{ + const ct_data* static_tree; /* static tree or NULL */ + const intf* extra_bits; /* extra bits for each code or NULL */ int extra_base; /* base index for extra_bits */ int elems; /* max number of elements in the tree */ int max_length; /* max bit length for the codes */ }; local static_tree_desc static_l_desc = -{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; +{static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS}; local static_tree_desc static_d_desc = {static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; local static_tree_desc static_bl_desc = -{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; +{(const ct_data*)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; /* =========================================================================== * Local (static) routines in this file. */ local void tr_static_init OF((void)); -local void init_block OF((deflate_state *s)); -local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); -local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); -local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); -local void build_tree OF((deflate_state *s, tree_desc *desc)); -local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); -local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); -local int build_bl_tree OF((deflate_state *s)); -local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, +local void init_block OF((deflate_state* s)); +local void pqdownheap OF((deflate_state* s, ct_data* tree, int k)); +local void gen_bitlen OF((deflate_state* s, tree_desc* desc)); +local void gen_codes OF((ct_data* tree, int max_code, ushf* bl_count)); +local void build_tree OF((deflate_state* s, tree_desc* desc)); +local void scan_tree OF((deflate_state* s, ct_data* tree, int max_code)); +local void send_tree OF((deflate_state* s, ct_data* tree, int max_code)); +local int build_bl_tree OF((deflate_state* s)); +local void send_all_trees OF((deflate_state* s, int lcodes, int dcodes, int blcodes)); -local void compress_block OF((deflate_state *s, ct_data *ltree, - ct_data *dtree)); -local int detect_data_type OF((deflate_state *s)); +local void compress_block OF((deflate_state* s, ct_data* ltree, + ct_data* dtree)); +local int detect_data_type OF((deflate_state* s)); local unsigned bi_reverse OF((unsigned value, int length)); -local void bi_windup OF((deflate_state *s)); -local void bi_flush OF((deflate_state *s)); -local void copy_block OF((deflate_state *s, charf *buf, unsigned len, +local void bi_windup OF((deflate_state* s)); +local void bi_flush OF((deflate_state* s)); +local void copy_block OF((deflate_state* s, charf* buf, unsigned len, int header)); #ifdef GEN_TREES_H @@ -161,7 +162,7 @@ local void gen_trees_header OF((void)); #ifndef DEBUG # define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) - /* Send a code of the given tree. c and tree must not have side effects */ +/* Send a code of the given tree. c and tree must not have side effects */ #else /* DEBUG */ # define send_code(s, c, tree) \ @@ -183,14 +184,14 @@ local void gen_trees_header OF((void)); * IN assertion: length <= 16 and value fits in length bits. */ #ifdef DEBUG -local void send_bits OF((deflate_state *s, int value, int length)); +local void send_bits OF((deflate_state* s, int value, int length)); local void send_bits(s, value, length) - deflate_state *s; - int value; /* value to send */ - int length; /* number of bits */ +deflate_state* s; +int value; /* value to send */ +int length; /* number of bits */ { - Tracevv((stderr," l %2d v %4x ", length, value)); + Tracevv((stderr, " l %2d v %4x ", length, value)); Assert(length > 0 && length <= 15, "invalid length"); s->bits_sent += (ulg)length; @@ -198,12 +199,15 @@ local void send_bits(s, value, length) * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) * unused bits in value. */ - if (s->bi_valid > (int)Buf_size - length) { + if (s->bi_valid > (int)Buf_size - length) + { s->bi_buf |= (ush)value << s->bi_valid; put_short(s, s->bi_buf); s->bi_buf = (ush)value >> (Buf_size - s->bi_valid); s->bi_valid += length - Buf_size; - } else { + } + else + { s->bi_buf |= (ush)value << s->bi_valid; s->bi_valid += length; } @@ -240,7 +244,7 @@ local void tr_static_init() int length; /* length value */ int code; /* code value */ int dist; /* distance index */ - ush bl_count[MAX_BITS+1]; + ush bl_count[MAX_BITS + 1]; /* number of codes at each bit length for an optimal tree */ if (static_init_done) return; @@ -256,55 +260,78 @@ local void tr_static_init() /* Initialize the mapping length (0..255) -> length code (0..28) */ length = 0; - for (code = 0; code < LENGTH_CODES-1; code++) { + + for (code = 0; code < LENGTH_CODES - 1; code++) + { base_length[code] = length; - for (n = 0; n < (1< dist code (0..29) */ dist = 0; - for (code = 0 ; code < 16; code++) { + + for (code = 0 ; code < 16; code++) + { base_dist[code] = dist; - for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ - for ( ; code < D_CODES; code++) { + + for (; code < D_CODES; code++) + { base_dist[code] = dist << 7; - for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { + + for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) + { _dist_code[256 + dist++] = (uch)code; } } - Assert (dist == 256, "tr_static_init: 256+dist != 512"); + + Assert(dist == 256, "tr_static_init: 256+dist != 512"); /* Construct the codes of the static literal tree */ for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; + n = 0; + while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; + while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; + while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; + while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; + /* Codes 286 and 287 do not exist, but we must include them in the * tree construction to get a canonical Huffman tree (longest code * all ones) */ - gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); + gen_codes((ct_data*)static_ltree, L_CODES + 1, bl_count); /* The static distance tree is trivial: */ - for (n = 0; n < D_CODES; n++) { + for (n = 0; n < D_CODES; n++) + { static_dtree[n].Len = 5; static_dtree[n].Code = bi_reverse((unsigned)n, 5); } + static_init_done = 1; # ifdef GEN_TREES_H @@ -327,48 +354,60 @@ local void tr_static_init() void gen_trees_header() { - FILE *header = fopen("trees.h", "w"); + FILE* header = fopen("trees.h", "w"); int i; - Assert (header != NULL, "Can't open trees.h"); + Assert(header != NULL, "Can't open trees.h"); fprintf(header, "/* header created automatically with -DGEN_TREES_H */\n\n"); fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n"); - for (i = 0; i < L_CODES+2; i++) { + + for (i = 0; i < L_CODES + 2; i++) + { fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, - static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); + static_ltree[i].Len, SEPARATOR(i, L_CODES + 1, 5)); } fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n"); - for (i = 0; i < D_CODES; i++) { + + for (i = 0; i < D_CODES; i++) + { fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, - static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); + static_dtree[i].Len, SEPARATOR(i, D_CODES - 1, 5)); } fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n"); - for (i = 0; i < DIST_CODE_LEN; i++) { + + for (i = 0; i < DIST_CODE_LEN; i++) + { fprintf(header, "%2u%s", _dist_code[i], - SEPARATOR(i, DIST_CODE_LEN-1, 20)); + SEPARATOR(i, DIST_CODE_LEN - 1, 20)); } fprintf(header, - "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); - for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { + "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); + + for (i = 0; i < MAX_MATCH - MIN_MATCH + 1; i++) + { fprintf(header, "%2u%s", _length_code[i], - SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); + SEPARATOR(i, MAX_MATCH - MIN_MATCH, 20)); } fprintf(header, "local const int base_length[LENGTH_CODES] = {\n"); - for (i = 0; i < LENGTH_CODES; i++) { + + for (i = 0; i < LENGTH_CODES; i++) + { fprintf(header, "%1u%s", base_length[i], - SEPARATOR(i, LENGTH_CODES-1, 20)); + SEPARATOR(i, LENGTH_CODES - 1, 20)); } fprintf(header, "local const int base_dist[D_CODES] = {\n"); - for (i = 0; i < D_CODES; i++) { + + for (i = 0; i < D_CODES; i++) + { fprintf(header, "%5u%s", base_dist[i], - SEPARATOR(i, D_CODES-1, 10)); + SEPARATOR(i, D_CODES - 1, 10)); } fclose(header); @@ -379,10 +418,10 @@ void gen_trees_header() * Initialize the tree data structures for a new zlib stream. */ #ifdef WIN32 -void ZLIB_INTERNAL _tr_init(deflate_state *s) +void ZLIB_INTERNAL _tr_init(deflate_state* s) #else void ZLIB_INTERNAL _tr_init(s) - deflate_state *s; +deflate_state* s; #endif { tr_static_init(); @@ -411,17 +450,19 @@ void ZLIB_INTERNAL _tr_init(s) * Initialize a new block. */ #ifdef WIN32 -local void init_block(deflate_state *s) +local void init_block(deflate_state* s) #else local void init_block(s) - deflate_state *s; +deflate_state* s; #endif { int n; /* iterates over tree elements */ /* Initialize the trees. */ for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; + for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; + for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; s->dyn_ltree[END_BLOCK].Freq = 1; @@ -459,31 +500,37 @@ local void init_block(s) * two sons). */ #ifdef WIN32 -local void pqdownheap(deflate_state *s, ct_data *tree, int k) +local void pqdownheap(deflate_state* s, ct_data* tree, int k) #else local void pqdownheap(s, tree, k) - deflate_state *s; - ct_data *tree; /* the tree to restore */ - int k; /* node to move down */ +deflate_state* s; +ct_data* tree; /* the tree to restore */ +int k; /* node to move down */ #endif { int v = s->heap[k]; int j = k << 1; /* left son of k */ - while (j <= s->heap_len) { + + while (j <= s->heap_len) + { /* Set j to the smallest of the two sons: */ if (j < s->heap_len && - smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { + smaller(tree, s->heap[j + 1], s->heap[j], s->depth)) + { j++; } + /* Exit if v is smaller than both sons */ if (smaller(tree, v, s->heap[j], s->depth)) break; /* Exchange v with the smallest son */ - s->heap[k] = s->heap[j]; k = j; + s->heap[k] = s->heap[j]; + k = j; /* And continue down the tree, setting j to the left son of k */ j <<= 1; } + s->heap[k] = v; } @@ -498,17 +545,17 @@ local void pqdownheap(s, tree, k) * not null. */ #ifdef WIN32 -local void gen_bitlen(deflate_state *s, tree_desc *desc) +local void gen_bitlen(deflate_state* s, tree_desc* desc) #else local void gen_bitlen(s, desc) - deflate_state *s; - tree_desc *desc; /* the tree descriptor */ +deflate_state* s; +tree_desc* desc; /* the tree descriptor */ #endif { - ct_data *tree = desc->dyn_tree; + ct_data* tree = desc->dyn_tree; int max_code = desc->max_code; - const ct_data *stree = desc->stat_desc->static_tree; - const intf *extra = desc->stat_desc->extra_bits; + const ct_data* stree = desc->stat_desc->static_tree; + const intf* extra = desc->stat_desc->extra_bits; int base = desc->stat_desc->extra_base; int max_length = desc->stat_desc->max_length; int h; /* heap index */ @@ -525,10 +572,13 @@ local void gen_bitlen(s, desc) */ tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ - for (h = s->heap_max+1; h < HEAP_SIZE; h++) { + for (h = s->heap_max + 1; h < HEAP_SIZE; h++) + { n = s->heap[h]; bits = tree[tree[n].Dad].Len + 1; + if (bits > max_length) bits = max_length, overflow++; + tree[n].Len = (ush)bits; /* We overwrite tree[n].Dad which is no longer needed */ @@ -536,45 +586,60 @@ local void gen_bitlen(s, desc) s->bl_count[bits]++; xbits = 0; - if (n >= base) xbits = extra[n-base]; + + if (n >= base) xbits = extra[n - base]; + f = tree[n].Freq; s->opt_len += (ulg)f * (bits + xbits); + if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); } + if (overflow == 0) return; - Trace((stderr,"\nbit length overflow\n")); + Trace((stderr, "\nbit length overflow\n")); /* This happens for example on obj2 and pic of the Calgary corpus */ /* Find the first bit length which could increase: */ - do { - bits = max_length-1; + do + { + bits = max_length - 1; + while (s->bl_count[bits] == 0) bits--; + s->bl_count[bits]--; /* move one leaf down the tree */ - s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ + s->bl_count[bits + 1] += 2; /* move one overflow item as its brother */ s->bl_count[max_length]--; /* The brother of the overflow item also moves one step up, * but this does not affect bl_count[max_length] */ overflow -= 2; - } while (overflow > 0); + } + while (overflow > 0); /* Now recompute all bit lengths, scanning in increasing frequency. * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all * lengths instead of fixing only the wrong ones. This idea is taken * from 'ar' written by Haruhiko Okumura.) */ - for (bits = max_length; bits != 0; bits--) { + for (bits = max_length; bits != 0; bits--) + { n = s->bl_count[bits]; - while (n != 0) { + + while (n != 0) + { m = s->heap[--h]; + if (m > max_code) continue; - if ((unsigned) tree[m].Len != (unsigned) bits) { - Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); + + if ((unsigned) tree[m].Len != (unsigned) bits) + { + Trace((stderr, "code %d bits %d->%d\n", m, tree[m].Len, bits)); s->opt_len += ((long)bits - (long)tree[m].Len) - *(long)tree[m].Freq; + * (long)tree[m].Freq; tree[m].Len = (ush)bits; } + n--; } } @@ -589,15 +654,15 @@ local void gen_bitlen(s, desc) * zero code length. */ #ifdef WIN32 -local void gen_codes (ct_data *tree, int max_code, ushf *bl_count) +local void gen_codes(ct_data* tree, int max_code, ushf* bl_count) #else -local void gen_codes (tree, max_code, bl_count) - ct_data *tree; /* the tree to decorate */ - int max_code; /* largest code with non zero frequency */ - ushf *bl_count; /* number of codes at each bit length */ +local void gen_codes(tree, max_code, bl_count) +ct_data* tree; /* the tree to decorate */ +int max_code; /* largest code with non zero frequency */ +ushf* bl_count; /* number of codes at each bit length */ #endif { - ush next_code[MAX_BITS+1]; /* next code value for each bit length */ + ush next_code[MAX_BITS + 1]; /* next code value for each bit length */ ush code = 0; /* running code value */ int bits; /* bit index */ int n; /* code index */ @@ -605,23 +670,28 @@ local void gen_codes (tree, max_code, bl_count) /* The distribution counts are first used to generate the code values * without bit reversal. */ - for (bits = 1; bits <= MAX_BITS; bits++) { - next_code[bits] = code = (code + bl_count[bits-1]) << 1; + for (bits = 1; bits <= MAX_BITS; bits++) + { + next_code[bits] = code = (code + bl_count[bits - 1]) << 1; } + /* Check that the bit counts in bl_count are consistent. The last code * must be all ones. */ - Assert (code + bl_count[MAX_BITS]-1 == (1<dyn_tree; - const ct_data *stree = desc->stat_desc->static_tree; + ct_data* tree = desc->dyn_tree; + const ct_data* stree = desc->stat_desc->static_tree; int elems = desc->stat_desc->elems; int n, m; /* iterate over heap elements */ int max_code = -1; /* largest code with non zero frequency */ @@ -663,11 +733,15 @@ local void build_tree(s, desc) */ s->heap_len = 0, s->heap_max = HEAP_SIZE; - for (n = 0; n < elems; n++) { - if (tree[n].Freq != 0) { + for (n = 0; n < elems; n++) + { + if (tree[n].Freq != 0) + { s->heap[++(s->heap_len)] = max_code = n; s->depth[n] = 0; - } else { + } + else + { tree[n].Len = 0; } } @@ -677,25 +751,32 @@ local void build_tree(s, desc) * possible code. So to avoid special checks later on we force at least * two codes of non zero frequency. */ - while (s->heap_len < 2) { + while (s->heap_len < 2) + { node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); tree[node].Freq = 1; s->depth[node] = 0; - s->opt_len--; if (stree) s->static_len -= stree[node].Len; + s->opt_len--; + + if (stree) s->static_len -= stree[node].Len; + /* node is 0 or 1 so it does not have extra bits */ } + desc->max_code = max_code; /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, * establish sub-heaps of increasing lengths: */ - for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); + for (n = s->heap_len / 2; n >= 1; n--) pqdownheap(s, tree, n); /* Construct the Huffman tree by repeatedly combining the least two * frequent nodes. */ node = elems; /* next internal node of the tree */ - do { + + do + { pqremove(s, tree, n); /* n = node of least frequency */ m = s->heap[SMALLEST]; /* m = node of next least frequency */ @@ -708,26 +789,30 @@ local void build_tree(s, desc) s->depth[n] : s->depth[m]) + 1); tree[n].Dad = tree[m].Dad = (ush)node; #ifdef DUMP_BL_TREE - if (tree == s->bl_tree) { - fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)", + + if (tree == s->bl_tree) + { + fprintf(stderr, "\nnode %d(%d), sons %d(%d) %d(%d)", node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); } + #endif /* and insert the new node in the heap */ s->heap[SMALLEST] = node++; pqdownheap(s, tree, SMALLEST); - } while (s->heap_len >= 2); + } + while (s->heap_len >= 2); s->heap[--(s->heap_max)] = s->heap[SMALLEST]; /* At this point, the fields freq and dad are set. We can now * generate the bit lengths. */ - gen_bitlen(s, (tree_desc *)desc); + gen_bitlen(s, (tree_desc*)desc); /* The field len is now set, we can generate the bit codes */ - gen_codes ((ct_data *)tree, max_code, s->bl_count); + gen_codes((ct_data*)tree, max_code, s->bl_count); } /* =========================================================================== @@ -735,12 +820,12 @@ local void build_tree(s, desc) * in the bit length tree. */ #ifdef WIN32 -local void scan_tree (deflate_state *s, ct_data *tree, int max_code) +local void scan_tree(deflate_state* s, ct_data* tree, int max_code) #else -local void scan_tree (s, tree, max_code) - deflate_state *s; - ct_data *tree; /* the tree to be scanned */ - int max_code; /* and its largest code of non zero frequency */ +local void scan_tree(s, tree, max_code) +deflate_state* s; +ct_data* tree; /* the tree to be scanned */ +int max_code; /* and its largest code of non zero frequency */ #endif { int n; /* iterates over all tree elements */ @@ -759,28 +844,50 @@ local void scan_tree (s, tree, max_code) #endif if (nextlen == 0) max_count = 138, min_count = 3; - tree[max_code+1].Len = (ush)0xffff; /* guard */ - for (n = 0; n <= max_code; n++) { - curlen = nextlen; nextlen = tree[n+1].Len; - if (++count < max_count && curlen == nextlen) { + tree[max_code + 1].Len = (ush)0xffff; /* guard */ + + for (n = 0; n <= max_code; n++) + { + curlen = nextlen; + nextlen = tree[n + 1].Len; + + if (++count < max_count && curlen == nextlen) + { continue; - } else if (count < min_count) { + } + else if (count < min_count) + { s->bl_tree[curlen].Freq += count; - } else if (curlen != 0) { + } + else if (curlen != 0) + { if (curlen != prevlen) s->bl_tree[curlen].Freq++; + s->bl_tree[REP_3_6].Freq++; - } else if (count <= 10) { + } + else if (count <= 10) + { s->bl_tree[REPZ_3_10].Freq++; - } else { + } + else + { s->bl_tree[REPZ_11_138].Freq++; } - count = 0; prevlen = curlen; - if (nextlen == 0) { + + count = 0; + prevlen = curlen; + + if (nextlen == 0) + { max_count = 138, min_count = 3; - } else if (curlen == nextlen) { + } + else if (curlen == nextlen) + { max_count = 6, min_count = 3; - } else { + } + else + { max_count = 7, min_count = 4; } } @@ -791,12 +898,12 @@ local void scan_tree (s, tree, max_code) * bl_tree. */ #ifdef WIN32 -local void send_tree (deflate_state *s, ct_data *tree, int max_code) +local void send_tree(deflate_state* s, ct_data* tree, int max_code) #else -local void send_tree (s, tree, max_code) - deflate_state *s; - ct_data *tree; /* the tree to be scanned */ - int max_code; /* and its largest code of non zero frequency */ +local void send_tree(s, tree, max_code) +deflate_state* s; +ct_data* tree; /* the tree to be scanned */ +int max_code; /* and its largest code of non zero frequency */ #endif { int n; /* iterates over all tree elements */ @@ -810,32 +917,59 @@ local void send_tree (s, tree, max_code) /* tree[max_code+1].Len = -1; */ /* guard already set */ if (nextlen == 0) max_count = 138, min_count = 3; - for (n = 0; n <= max_code; n++) { - curlen = nextlen; nextlen = tree[n+1].Len; - if (++count < max_count && curlen == nextlen) { + for (n = 0; n <= max_code; n++) + { + curlen = nextlen; + nextlen = tree[n + 1].Len; + + if (++count < max_count && curlen == nextlen) + { continue; - } else if (count < min_count) { - do { send_code(s, curlen, s->bl_tree); } while (--count != 0); - - } else if (curlen != 0) { - if (curlen != prevlen) { - send_code(s, curlen, s->bl_tree); count--; - } - Assert(count >= 3 && count <= 6, " 3_6?"); - send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); - - } else if (count <= 10) { - send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); - - } else { - send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); } - count = 0; prevlen = curlen; - if (nextlen == 0) { + else if (count < min_count) + { + do { send_code(s, curlen, s->bl_tree); } + while (--count != 0); + + } + else if (curlen != 0) + { + if (curlen != prevlen) + { + send_code(s, curlen, s->bl_tree); + count--; + } + + Assert(count >= 3 && count <= 6, " 3_6?"); + send_code(s, REP_3_6, s->bl_tree); + send_bits(s, count - 3, 2); + + } + else if (count <= 10) + { + send_code(s, REPZ_3_10, s->bl_tree); + send_bits(s, count - 3, 3); + + } + else + { + send_code(s, REPZ_11_138, s->bl_tree); + send_bits(s, count - 11, 7); + } + + count = 0; + prevlen = curlen; + + if (nextlen == 0) + { max_count = 138, min_count = 3; - } else if (curlen == nextlen) { + } + else if (curlen == nextlen) + { max_count = 6, min_count = 3; - } else { + } + else + { max_count = 7, min_count = 4; } } @@ -846,20 +980,20 @@ local void send_tree (s, tree, max_code) * bl_order of the last bit length code to send. */ #ifdef WIN32 -local int build_bl_tree(deflate_state *s) +local int build_bl_tree(deflate_state* s) #else local int build_bl_tree(s) - deflate_state *s; +deflate_state* s; #endif { int max_blindex; /* index of last bit length code of non zero freq */ /* Determine the bit length frequencies for literal and distance trees */ - scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code); - scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code); + scan_tree(s, (ct_data*)s->dyn_ltree, s->l_desc.max_code); + scan_tree(s, (ct_data*)s->dyn_dtree, s->d_desc.max_code); /* Build the bit length tree: */ - build_tree(s, (tree_desc *)(&(s->bl_desc))); + build_tree(s, (tree_desc*)(&(s->bl_desc))); /* opt_len now includes the length of the tree representations, except * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. */ @@ -868,11 +1002,13 @@ local int build_bl_tree(s) * requires that at least 4 bit length codes be sent. (appnote.txt says * 3 but the actual value used is 4.) */ - for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { + for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) + { if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; } + /* Update opt_len to include the bit length tree and counts */ - s->opt_len += 3*(max_blindex+1) + 5+5+4; + s->opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", s->opt_len, s->static_len)); @@ -885,32 +1021,35 @@ local int build_bl_tree(s) * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. */ #ifdef WIN32 -local void send_all_trees(deflate_state *s, int lcodes, int dcodes, int blcodes) +local void send_all_trees(deflate_state* s, int lcodes, int dcodes, int blcodes) #else local void send_all_trees(s, lcodes, dcodes, blcodes) - deflate_state *s; - int lcodes, dcodes, blcodes; /* number of codes for each tree */ +deflate_state* s; +int lcodes, dcodes, blcodes; /* number of codes for each tree */ #endif { int rank; /* index in bl_order */ - Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); - Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, - "too many codes"); + Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); + Assert(lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, + "too many codes"); Tracev((stderr, "\nbl counts: ")); - send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ - send_bits(s, dcodes-1, 5); - send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ - for (rank = 0; rank < blcodes; rank++) { + send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */ + send_bits(s, dcodes - 1, 5); + send_bits(s, blcodes - 4, 4); /* not -3 as stated in appnote.txt */ + + for (rank = 0; rank < blcodes; rank++) + { Tracev((stderr, "\nbl code %2d ", bl_order[rank])); send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); } + Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); - send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ + send_tree(s, (ct_data*)s->dyn_ltree, lcodes - 1); /* literal tree */ Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); - send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ + send_tree(s, (ct_data*)s->dyn_dtree, dcodes - 1); /* distance tree */ Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); } @@ -918,16 +1057,16 @@ local void send_all_trees(s, lcodes, dcodes, blcodes) * Send a stored block */ #ifdef WIN32 -void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf, ulg stored_len, int last) +void ZLIB_INTERNAL _tr_stored_block(deflate_state* s, charf* buf, ulg stored_len, int last) #else void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) - deflate_state *s; - charf *buf; /* input block */ - ulg stored_len; /* length of input block */ - int last; /* one if this is the last block for a file */ +deflate_state* s; +charf* buf; /* input block */ +ulg stored_len; /* length of input block */ +int last; /* one if this is the last block for a file */ #endif { - send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */ + send_bits(s, (STORED_BLOCK << 1) + last, 3); /* send block type */ #ifdef DEBUG s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; s->compressed_len += (stored_len + 4) << 3; @@ -939,10 +1078,10 @@ void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) * Flush the bits in the bit buffer to pending output (leaves at most 7 bits) */ #ifdef WIN32 -void ZLIB_INTERNAL _tr_flush_bits(deflate_state *s) +void ZLIB_INTERNAL _tr_flush_bits(deflate_state* s) #else void ZLIB_INTERNAL _tr_flush_bits(s) - deflate_state *s; +deflate_state* s; #endif { bi_flush(s); @@ -953,13 +1092,13 @@ void ZLIB_INTERNAL _tr_flush_bits(s) * This takes 10 bits, of which 7 may remain in the bit buffer. */ #ifdef WIN32 -void ZLIB_INTERNAL _tr_align(deflate_state *s) +void ZLIB_INTERNAL _tr_align(deflate_state* s) #else void ZLIB_INTERNAL _tr_align(s) - deflate_state *s; +deflate_state* s; #endif { - send_bits(s, STATIC_TREES<<1, 3); + send_bits(s, STATIC_TREES << 1, 3); send_code(s, END_BLOCK, static_ltree); #ifdef DEBUG s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ @@ -972,31 +1111,32 @@ void ZLIB_INTERNAL _tr_align(s) * trees or store, and output the encoded block to the zip file. */ #ifdef WIN32 -void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, charf *buf, ulg stored_len, int last) +void ZLIB_INTERNAL _tr_flush_block(deflate_state* s, charf* buf, ulg stored_len, int last) #else void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) - deflate_state *s; - charf *buf; /* input block, or NULL if too old */ - ulg stored_len; /* length of input block */ - int last; /* one if this is the last block for a file */ +deflate_state* s; +charf* buf; /* input block, or NULL if too old */ +ulg stored_len; /* length of input block */ +int last; /* one if this is the last block for a file */ #endif { ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ int max_blindex = 0; /* index of last bit length code of non zero freq */ /* Build the Huffman trees unless a stored block is forced */ - if (s->level > 0) { + if (s->level > 0) + { /* Check if the file is binary or text */ if (s->strm->data_type == Z_UNKNOWN) s->strm->data_type = detect_data_type(s); /* Construct the literal and distance trees */ - build_tree(s, (tree_desc *)(&(s->l_desc))); + build_tree(s, (tree_desc*)(&(s->l_desc))); Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, s->static_len)); - build_tree(s, (tree_desc *)(&(s->d_desc))); + build_tree(s, (tree_desc*)(&(s->d_desc))); Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, s->static_len)); /* At this point, opt_len and static_len are the total bit lengths of @@ -1009,8 +1149,8 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) max_blindex = build_bl_tree(s); /* Determine the best encoding. Compute the block lengths in bytes. */ - opt_lenb = (s->opt_len+3+7)>>3; - static_lenb = (s->static_len+3+7)>>3; + opt_lenb = (s->opt_len + 3 + 7) >> 3; + static_lenb = (s->static_len + 3 + 7) >> 3; Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, @@ -1018,16 +1158,22 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) if (static_lenb <= opt_lenb) opt_lenb = static_lenb; - } else { + } + else + { Assert(buf != (char*)0, "lost buf"); opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ } #ifdef FORCE_STORED - if (buf != (char*)0) { /* force stored block */ + + if (buf != (char*)0) /* force stored block */ + { #else - if (stored_len+4 <= opt_lenb && buf != (char*)0) { - /* 4: two words for the lengths */ + + if (stored_len + 4 <= opt_lenb && buf != (char*)0) + { + /* 4: two words for the lengths */ #endif /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. * Otherwise we can't have processed more than WSIZE input bytes since @@ -1038,38 +1184,47 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) _tr_stored_block(s, buf, stored_len, last); #ifdef FORCE_STATIC - } else if (static_lenb >= 0) { /* force static trees */ + } + else if (static_lenb >= 0) /* force static trees */ + { #else - } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { + } + else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) + { #endif - send_bits(s, (STATIC_TREES<<1)+last, 3); - compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); + send_bits(s, (STATIC_TREES << 1) + last, 3); + compress_block(s, (ct_data*)static_ltree, (ct_data*)static_dtree); #ifdef DEBUG s->compressed_len += 3 + s->static_len; #endif - } else { - send_bits(s, (DYN_TREES<<1)+last, 3); - send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, - max_blindex+1); - compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); + } + else + { + send_bits(s, (DYN_TREES << 1) + last, 3); + send_all_trees(s, s->l_desc.max_code + 1, s->d_desc.max_code + 1, + max_blindex + 1); + compress_block(s, (ct_data*)s->dyn_ltree, (ct_data*)s->dyn_dtree); #ifdef DEBUG s->compressed_len += 3 + s->opt_len; #endif } - Assert (s->compressed_len == s->bits_sent, "bad compressed size"); + + Assert(s->compressed_len == s->bits_sent, "bad compressed size"); /* The above check is made mod 2^32, for files larger than 512 MB * and uLong implemented on 32 bits. */ init_block(s); - if (last) { + if (last) + { bi_windup(s); #ifdef DEBUG s->compressed_len += 7; /* align on byte boundary */ #endif } - Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, - s->compressed_len-7*last)); + + Tracev((stderr, "\ncomprlen %lu(%lu) ", s->compressed_len >> 3, + s->compressed_len - 7 * last)); } /* =========================================================================== @@ -1077,50 +1232,61 @@ void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) * the current block must be flushed. */ #ifdef WIN32 -int ZLIB_INTERNAL _tr_tally (deflate_state *s, unsigned dist, unsigned lc) +int ZLIB_INTERNAL _tr_tally(deflate_state* s, unsigned dist, unsigned lc) #else -int ZLIB_INTERNAL _tr_tally (s, dist, lc) - deflate_state *s; - unsigned dist; /* distance of matched string */ - unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +int ZLIB_INTERNAL _tr_tally(s, dist, lc) +deflate_state* s; +unsigned dist; /* distance of matched string */ +unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ #endif { s->d_buf[s->last_lit] = (ush)dist; s->l_buf[s->last_lit++] = (uch)lc; - if (dist == 0) { + + if (dist == 0) + { /* lc is the unmatched char */ s->dyn_ltree[lc].Freq++; - } else { + } + else + { s->matches++; /* Here, lc is the match length - MIN_MATCH */ dist--; /* dist = match distance - 1 */ Assert((ush)dist < (ush)MAX_DIST(s) && - (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && + (ush)lc <= (ush)(MAX_MATCH - MIN_MATCH) && (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); - s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; + s->dyn_ltree[_length_code[lc] + LITERALS + 1].Freq++; s->dyn_dtree[d_code(dist)].Freq++; } #ifdef TRUNCATE_BLOCK + /* Try to guess if it is profitable to stop the current block here */ - if ((s->last_lit & 0x1fff) == 0 && s->level > 2) { + if ((s->last_lit & 0x1fff) == 0 && s->level > 2) + { /* Compute an upper bound for the compressed length */ - ulg out_length = (ulg)s->last_lit*8L; + ulg out_length = (ulg)s->last_lit * 8L; ulg in_length = (ulg)((long)s->strstart - s->block_start); int dcode; - for (dcode = 0; dcode < D_CODES; dcode++) { + + for (dcode = 0; dcode < D_CODES; dcode++) + { out_length += (ulg)s->dyn_dtree[dcode].Freq * - (5L+extra_dbits[dcode]); + (5L + extra_dbits[dcode]); } + out_length >>= 3; - Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", - s->last_lit, in_length, out_length, - 100L - out_length*100L/in_length)); - if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1; + Tracev((stderr, "\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", + s->last_lit, in_length, out_length, + 100L - out_length * 100L / in_length)); + + if (s->matches < s->last_lit / 2 && out_length < in_length / 2) return 1; } + #endif - return (s->last_lit == s->lit_bufsize-1); + return (s->last_lit == s->lit_bufsize - 1); /* We avoid equality with lit_bufsize because of wraparound at 64K * on 16 bit machines and because stored blocks are restricted to * 64K-1 bytes. @@ -1131,12 +1297,12 @@ int ZLIB_INTERNAL _tr_tally (s, dist, lc) * Send the block data compressed using the given Huffman trees */ #ifdef WIN32 -local void compress_block(deflate_state *s, ct_data *ltree, ct_data *dtree) +local void compress_block(deflate_state* s, ct_data* ltree, ct_data* dtree) #else local void compress_block(s, ltree, dtree) - deflate_state *s; - ct_data *ltree; /* literal tree */ - ct_data *dtree; /* distance tree */ +deflate_state* s; +ct_data* ltree; /* literal tree */ +ct_data* dtree; /* distance tree */ #endif { unsigned dist; /* distance of matched string */ @@ -1145,38 +1311,49 @@ local void compress_block(s, ltree, dtree) unsigned code; /* the code to send */ int extra; /* number of extra bits to send */ - if (s->last_lit != 0) do { - dist = s->d_buf[lx]; - lc = s->l_buf[lx++]; - if (dist == 0) { - send_code(s, lc, ltree); /* send a literal byte */ - Tracecv(isgraph(lc), (stderr," '%c' ", lc)); - } else { - /* Here, lc is the match length - MIN_MATCH */ - code = _length_code[lc]; - send_code(s, code+LITERALS+1, ltree); /* send the length code */ - extra = extra_lbits[code]; - if (extra != 0) { - lc -= base_length[code]; - send_bits(s, lc, extra); /* send the extra length bits */ + if (s->last_lit != 0) do + { + dist = s->d_buf[lx]; + lc = s->l_buf[lx++]; + + if (dist == 0) + { + send_code(s, lc, ltree); /* send a literal byte */ + Tracecv(isgraph(lc), (stderr, " '%c' ", lc)); } - dist--; /* dist is now the match distance - 1 */ - code = d_code(dist); - Assert (code < D_CODES, "bad d_code"); + else + { + /* Here, lc is the match length - MIN_MATCH */ + code = _length_code[lc]; + send_code(s, code + LITERALS + 1, ltree); /* send the length code */ + extra = extra_lbits[code]; - send_code(s, code, dtree); /* send the distance code */ - extra = extra_dbits[code]; - if (extra != 0) { - dist -= base_dist[code]; - send_bits(s, dist, extra); /* send the extra distance bits */ - } - } /* literal or match pair ? */ + if (extra != 0) + { + lc -= base_length[code]; + send_bits(s, lc, extra); /* send the extra length bits */ + } - /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ - Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, - "pendingBuf overflow"); + dist--; /* dist is now the match distance - 1 */ + code = d_code(dist); + Assert(code < D_CODES, "bad d_code"); - } while (lx < s->last_lit); + send_code(s, code, dtree); /* send the distance code */ + extra = extra_dbits[code]; + + if (extra != 0) + { + dist -= base_dist[code]; + send_bits(s, dist, extra); /* send the extra distance bits */ + } + } /* literal or match pair ? */ + + /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ + Assert((uInt)(s->pending) < s->lit_bufsize + 2 * lx, + "pendingBuf overflow"); + + } + while (lx < s->last_lit); send_code(s, END_BLOCK, ltree); } @@ -1195,10 +1372,10 @@ local void compress_block(s, ltree, dtree) * IN assertion: the fields Freq of dyn_ltree are set. */ #ifdef WIN32 -local int detect_data_type(deflate_state *s) +local int detect_data_type(deflate_state* s) #else local int detect_data_type(s) - deflate_state *s; +deflate_state* s; #endif { /* black_mask is the bit mask of black-listed bytes @@ -1217,6 +1394,7 @@ local int detect_data_type(s) if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0 || s->dyn_ltree[13].Freq != 0) return Z_TEXT; + for (n = 32; n < LITERALS; n++) if (s->dyn_ltree[n].Freq != 0) return Z_TEXT; @@ -1236,15 +1414,19 @@ local int detect_data_type(s) local unsigned bi_reverse(unsigned code, int len) #else local unsigned bi_reverse(code, len) - unsigned code; /* the value to invert */ - int len; /* its bit length */ +unsigned code; /* the value to invert */ +int len; /* its bit length */ #endif { register unsigned res = 0; - do { + + do + { res |= code & 1; code >>= 1, res <<= 1; - } while (--len > 0); + } + while (--len > 0); + return res >> 1; } @@ -1252,17 +1434,20 @@ local unsigned bi_reverse(code, len) * Flush the bit buffer, keeping at most 7 bits in it. */ #ifdef WIN32 -local void bi_flush(deflate_state *s) +local void bi_flush(deflate_state* s) #else local void bi_flush(s) - deflate_state *s; +deflate_state* s; #endif { - if (s->bi_valid == 16) { + if (s->bi_valid == 16) + { put_short(s, s->bi_buf); s->bi_buf = 0; s->bi_valid = 0; - } else if (s->bi_valid >= 8) { + } + else if (s->bi_valid >= 8) + { put_byte(s, (Byte)s->bi_buf); s->bi_buf >>= 8; s->bi_valid -= 8; @@ -1273,21 +1458,25 @@ local void bi_flush(s) * Flush the bit buffer and align the output on a byte boundary */ #ifdef WIN32 -local void bi_windup(deflate_state *s) +local void bi_windup(deflate_state* s) #else local void bi_windup(s) - deflate_state *s; +deflate_state* s; #endif { - if (s->bi_valid > 8) { + if (s->bi_valid > 8) + { put_short(s, s->bi_buf); - } else if (s->bi_valid > 0) { + } + else if (s->bi_valid > 0) + { put_byte(s, (Byte)s->bi_buf); } + s->bi_buf = 0; s->bi_valid = 0; #ifdef DEBUG - s->bits_sent = (s->bits_sent+7) & ~7; + s->bits_sent = (s->bits_sent + 7) & ~7; #endif } @@ -1296,28 +1485,32 @@ local void bi_windup(s) * one's complement if requested. */ #ifdef WIN32 -local void copy_block(deflate_state *s, charf *buf, unsigned len, int header) +local void copy_block(deflate_state* s, charf* buf, unsigned len, int header) #else local void copy_block(s, buf, len, header) - deflate_state *s; - charf *buf; /* the input data */ - unsigned len; /* its length */ - int header; /* true if block header must be written */ +deflate_state* s; +charf* buf; /* the input data */ +unsigned len; /* its length */ +int header; /* true if block header must be written */ #endif { bi_windup(s); /* align on byte boundary */ - if (header) { + if (header) + { put_short(s, (ush)len); put_short(s, (ush)~len); #ifdef DEBUG - s->bits_sent += 2*16; + s->bits_sent += 2 * 16; #endif } + #ifdef DEBUG - s->bits_sent += (ulg)len<<3; + s->bits_sent += (ulg)len << 3; #endif - while (len--) { + + while (len--) + { put_byte(s, *buf++); } } diff --git a/extern/zlib/trees.h b/extern/zlib/trees.h index d35639d..a4dc23c 100644 --- a/extern/zlib/trees.h +++ b/extern/zlib/trees.h @@ -1,128 +1,134 @@ /* header created automatically with -DGEN_TREES_H */ -local const ct_data static_ltree[L_CODES+2] = { -{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, -{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, -{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, -{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, -{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, -{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, -{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, -{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, -{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, -{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, -{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, -{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, -{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, -{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, -{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, -{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, -{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, -{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, -{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, -{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, -{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, -{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, -{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, -{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, -{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, -{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, -{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, -{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, -{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, -{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, -{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, -{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, -{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, -{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, -{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, -{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, -{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, -{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, -{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, -{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, -{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, -{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, -{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, -{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, -{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, -{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, -{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, -{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, -{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, -{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, -{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, -{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, -{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, -{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, -{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, -{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, -{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, -{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} +local const ct_data static_ltree[L_CODES + 2] = +{ + {{ 12}, { 8}}, {{140}, { 8}}, {{ 76}, { 8}}, {{204}, { 8}}, {{ 44}, { 8}}, + {{172}, { 8}}, {{108}, { 8}}, {{236}, { 8}}, {{ 28}, { 8}}, {{156}, { 8}}, + {{ 92}, { 8}}, {{220}, { 8}}, {{ 60}, { 8}}, {{188}, { 8}}, {{124}, { 8}}, + {{252}, { 8}}, {{ 2}, { 8}}, {{130}, { 8}}, {{ 66}, { 8}}, {{194}, { 8}}, + {{ 34}, { 8}}, {{162}, { 8}}, {{ 98}, { 8}}, {{226}, { 8}}, {{ 18}, { 8}}, + {{146}, { 8}}, {{ 82}, { 8}}, {{210}, { 8}}, {{ 50}, { 8}}, {{178}, { 8}}, + {{114}, { 8}}, {{242}, { 8}}, {{ 10}, { 8}}, {{138}, { 8}}, {{ 74}, { 8}}, + {{202}, { 8}}, {{ 42}, { 8}}, {{170}, { 8}}, {{106}, { 8}}, {{234}, { 8}}, + {{ 26}, { 8}}, {{154}, { 8}}, {{ 90}, { 8}}, {{218}, { 8}}, {{ 58}, { 8}}, + {{186}, { 8}}, {{122}, { 8}}, {{250}, { 8}}, {{ 6}, { 8}}, {{134}, { 8}}, + {{ 70}, { 8}}, {{198}, { 8}}, {{ 38}, { 8}}, {{166}, { 8}}, {{102}, { 8}}, + {{230}, { 8}}, {{ 22}, { 8}}, {{150}, { 8}}, {{ 86}, { 8}}, {{214}, { 8}}, + {{ 54}, { 8}}, {{182}, { 8}}, {{118}, { 8}}, {{246}, { 8}}, {{ 14}, { 8}}, + {{142}, { 8}}, {{ 78}, { 8}}, {{206}, { 8}}, {{ 46}, { 8}}, {{174}, { 8}}, + {{110}, { 8}}, {{238}, { 8}}, {{ 30}, { 8}}, {{158}, { 8}}, {{ 94}, { 8}}, + {{222}, { 8}}, {{ 62}, { 8}}, {{190}, { 8}}, {{126}, { 8}}, {{254}, { 8}}, + {{ 1}, { 8}}, {{129}, { 8}}, {{ 65}, { 8}}, {{193}, { 8}}, {{ 33}, { 8}}, + {{161}, { 8}}, {{ 97}, { 8}}, {{225}, { 8}}, {{ 17}, { 8}}, {{145}, { 8}}, + {{ 81}, { 8}}, {{209}, { 8}}, {{ 49}, { 8}}, {{177}, { 8}}, {{113}, { 8}}, + {{241}, { 8}}, {{ 9}, { 8}}, {{137}, { 8}}, {{ 73}, { 8}}, {{201}, { 8}}, + {{ 41}, { 8}}, {{169}, { 8}}, {{105}, { 8}}, {{233}, { 8}}, {{ 25}, { 8}}, + {{153}, { 8}}, {{ 89}, { 8}}, {{217}, { 8}}, {{ 57}, { 8}}, {{185}, { 8}}, + {{121}, { 8}}, {{249}, { 8}}, {{ 5}, { 8}}, {{133}, { 8}}, {{ 69}, { 8}}, + {{197}, { 8}}, {{ 37}, { 8}}, {{165}, { 8}}, {{101}, { 8}}, {{229}, { 8}}, + {{ 21}, { 8}}, {{149}, { 8}}, {{ 85}, { 8}}, {{213}, { 8}}, {{ 53}, { 8}}, + {{181}, { 8}}, {{117}, { 8}}, {{245}, { 8}}, {{ 13}, { 8}}, {{141}, { 8}}, + {{ 77}, { 8}}, {{205}, { 8}}, {{ 45}, { 8}}, {{173}, { 8}}, {{109}, { 8}}, + {{237}, { 8}}, {{ 29}, { 8}}, {{157}, { 8}}, {{ 93}, { 8}}, {{221}, { 8}}, + {{ 61}, { 8}}, {{189}, { 8}}, {{125}, { 8}}, {{253}, { 8}}, {{ 19}, { 9}}, + {{275}, { 9}}, {{147}, { 9}}, {{403}, { 9}}, {{ 83}, { 9}}, {{339}, { 9}}, + {{211}, { 9}}, {{467}, { 9}}, {{ 51}, { 9}}, {{307}, { 9}}, {{179}, { 9}}, + {{435}, { 9}}, {{115}, { 9}}, {{371}, { 9}}, {{243}, { 9}}, {{499}, { 9}}, + {{ 11}, { 9}}, {{267}, { 9}}, {{139}, { 9}}, {{395}, { 9}}, {{ 75}, { 9}}, + {{331}, { 9}}, {{203}, { 9}}, {{459}, { 9}}, {{ 43}, { 9}}, {{299}, { 9}}, + {{171}, { 9}}, {{427}, { 9}}, {{107}, { 9}}, {{363}, { 9}}, {{235}, { 9}}, + {{491}, { 9}}, {{ 27}, { 9}}, {{283}, { 9}}, {{155}, { 9}}, {{411}, { 9}}, + {{ 91}, { 9}}, {{347}, { 9}}, {{219}, { 9}}, {{475}, { 9}}, {{ 59}, { 9}}, + {{315}, { 9}}, {{187}, { 9}}, {{443}, { 9}}, {{123}, { 9}}, {{379}, { 9}}, + {{251}, { 9}}, {{507}, { 9}}, {{ 7}, { 9}}, {{263}, { 9}}, {{135}, { 9}}, + {{391}, { 9}}, {{ 71}, { 9}}, {{327}, { 9}}, {{199}, { 9}}, {{455}, { 9}}, + {{ 39}, { 9}}, {{295}, { 9}}, {{167}, { 9}}, {{423}, { 9}}, {{103}, { 9}}, + {{359}, { 9}}, {{231}, { 9}}, {{487}, { 9}}, {{ 23}, { 9}}, {{279}, { 9}}, + {{151}, { 9}}, {{407}, { 9}}, {{ 87}, { 9}}, {{343}, { 9}}, {{215}, { 9}}, + {{471}, { 9}}, {{ 55}, { 9}}, {{311}, { 9}}, {{183}, { 9}}, {{439}, { 9}}, + {{119}, { 9}}, {{375}, { 9}}, {{247}, { 9}}, {{503}, { 9}}, {{ 15}, { 9}}, + {{271}, { 9}}, {{143}, { 9}}, {{399}, { 9}}, {{ 79}, { 9}}, {{335}, { 9}}, + {{207}, { 9}}, {{463}, { 9}}, {{ 47}, { 9}}, {{303}, { 9}}, {{175}, { 9}}, + {{431}, { 9}}, {{111}, { 9}}, {{367}, { 9}}, {{239}, { 9}}, {{495}, { 9}}, + {{ 31}, { 9}}, {{287}, { 9}}, {{159}, { 9}}, {{415}, { 9}}, {{ 95}, { 9}}, + {{351}, { 9}}, {{223}, { 9}}, {{479}, { 9}}, {{ 63}, { 9}}, {{319}, { 9}}, + {{191}, { 9}}, {{447}, { 9}}, {{127}, { 9}}, {{383}, { 9}}, {{255}, { 9}}, + {{511}, { 9}}, {{ 0}, { 7}}, {{ 64}, { 7}}, {{ 32}, { 7}}, {{ 96}, { 7}}, + {{ 16}, { 7}}, {{ 80}, { 7}}, {{ 48}, { 7}}, {{112}, { 7}}, {{ 8}, { 7}}, + {{ 72}, { 7}}, {{ 40}, { 7}}, {{104}, { 7}}, {{ 24}, { 7}}, {{ 88}, { 7}}, + {{ 56}, { 7}}, {{120}, { 7}}, {{ 4}, { 7}}, {{ 68}, { 7}}, {{ 36}, { 7}}, + {{100}, { 7}}, {{ 20}, { 7}}, {{ 84}, { 7}}, {{ 52}, { 7}}, {{116}, { 7}}, + {{ 3}, { 8}}, {{131}, { 8}}, {{ 67}, { 8}}, {{195}, { 8}}, {{ 35}, { 8}}, + {{163}, { 8}}, {{ 99}, { 8}}, {{227}, { 8}} }; -local const ct_data static_dtree[D_CODES] = { -{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, -{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, -{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, -{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, -{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, -{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} +local const ct_data static_dtree[D_CODES] = +{ + {{ 0}, { 5}}, {{16}, { 5}}, {{ 8}, { 5}}, {{24}, { 5}}, {{ 4}, { 5}}, + {{20}, { 5}}, {{12}, { 5}}, {{28}, { 5}}, {{ 2}, { 5}}, {{18}, { 5}}, + {{10}, { 5}}, {{26}, { 5}}, {{ 6}, { 5}}, {{22}, { 5}}, {{14}, { 5}}, + {{30}, { 5}}, {{ 1}, { 5}}, {{17}, { 5}}, {{ 9}, { 5}}, {{25}, { 5}}, + {{ 5}, { 5}}, {{21}, { 5}}, {{13}, { 5}}, {{29}, { 5}}, {{ 3}, { 5}}, + {{19}, { 5}}, {{11}, { 5}}, {{27}, { 5}}, {{ 7}, { 5}}, {{23}, { 5}} }; -const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = { - 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, - 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, -10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, -11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, -12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, -18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, -23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 +const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = +{ + 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, + 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, + 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, + 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, + 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, + 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, + 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 }; -const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= { - 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, -13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, -17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, -19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 +const uch ZLIB_INTERNAL _length_code[MAX_MATCH - MIN_MATCH + 1] = +{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, + 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, + 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, + 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, + 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 }; -local const int base_length[LENGTH_CODES] = { -0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, -64, 80, 96, 112, 128, 160, 192, 224, 0 +local const int base_length[LENGTH_CODES] = +{ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, + 64, 80, 96, 112, 128, 160, 192, 224, 0 }; -local const int base_dist[D_CODES] = { +local const int base_dist[D_CODES] = +{ 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, - 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, - 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 + 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, + 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 }; diff --git a/extern/zlib/uncompr.c b/extern/zlib/uncompr.c index cde9dae..0f9c664 100644 --- a/extern/zlib/uncompr.c +++ b/extern/zlib/uncompr.c @@ -22,13 +22,13 @@ buffer, or Z_DATA_ERROR if the input data was corrupted. */ #ifdef WIN32 -int ZEXPORT uncompress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen) +int ZEXPORT uncompress(Bytef* dest, uLongf* destLen, const Bytef* source, uLong sourceLen) #else -int ZEXPORT uncompress (dest, destLen, source, sourceLen) - Bytef *dest; - uLongf *destLen; - const Bytef *source; - uLong sourceLen; +int ZEXPORT uncompress(dest, destLen, source, sourceLen) +Bytef* dest; +uLongf* destLen; +const Bytef* source; +uLong sourceLen; #endif { z_stream stream; @@ -36,26 +36,34 @@ int ZEXPORT uncompress (dest, destLen, source, sourceLen) stream.next_in = (Bytef*)source; stream.avail_in = (uInt)sourceLen; + /* Check for source > 64K on 16-bit machine: */ if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; stream.next_out = dest; - stream.avail_out = (uInt)*destLen; + stream.avail_out = (uInt) * destLen; + if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; stream.zalloc = (alloc_func)0; stream.zfree = (free_func)0; err = inflateInit(&stream); + if (err != Z_OK) return err; err = inflate(&stream, Z_FINISH); - if (err != Z_STREAM_END) { + + if (err != Z_STREAM_END) + { inflateEnd(&stream); + if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) return Z_DATA_ERROR; + return err; } + *destLen = stream.total_out; err = inflateEnd(&stream); diff --git a/extern/zlib/zconf.h b/extern/zlib/zconf.h index 8a46a58..758ee95 100644 --- a/extern/zlib/zconf.h +++ b/extern/zlib/zconf.h @@ -257,7 +257,7 @@ for small objects. */ - /* Type declarations */ +/* Type declarations */ #ifndef OF /* function prototypes */ # ifdef STDC @@ -283,7 +283,7 @@ */ #ifdef SYS16BIT # if defined(M_I86SM) || defined(M_I86MM) - /* MSC small or medium model */ +/* MSC small or medium model */ # define SMALL_MEDIUM # ifdef _MSC_VER # define FAR _far @@ -292,7 +292,7 @@ # endif # endif # if (defined(__SMALL__) || defined(__MEDIUM__)) - /* Turbo C small or medium model */ +/* Turbo C small or medium model */ # define SMALL_MEDIUM # ifdef __BORLANDC__ # define FAR _far @@ -303,9 +303,9 @@ #endif #if defined(WINDOWS) || defined(WIN32) - /* If building or using zlib as a DLL, define ZLIB_DLL. - * This is not mandatory, but it offers a little performance increase. - */ +/* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ # ifdef ZLIB_DLL # if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) # ifdef ZLIB_INTERNAL @@ -315,17 +315,17 @@ # endif # endif # endif /* ZLIB_DLL */ - /* If building or using zlib with the WINAPI/WINAPIV calling convention, - * define ZLIB_WINAPI. - * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. - */ +/* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ # ifdef ZLIB_WINAPI # ifdef FAR # undef FAR # endif # include - /* No need for _export, use ZLIB.DEF instead. */ - /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +/* No need for _export, use ZLIB.DEF instead. */ +/* For complete Windows compatibility, use WINAPI, not __stdcall. */ # define ZEXPORT WINAPI # ifdef WIN32 # define ZEXPORTVA WINAPIV @@ -368,10 +368,10 @@ typedef unsigned int uInt; /* 16 bits or more */ typedef unsigned long uLong; /* 32 bits or more */ #ifdef SMALL_MEDIUM - /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +/* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ # define Bytef Byte FAR #else - typedef Byte FAR Bytef; +typedef Byte FAR Bytef; #endif typedef char FAR charf; typedef int FAR intf; @@ -379,13 +379,13 @@ typedef uInt FAR uIntf; typedef uLong FAR uLongf; #ifdef STDC - typedef void const *voidpc; - typedef void FAR *voidpf; - typedef void *voidp; +typedef void const* voidpc; +typedef void FAR* voidpf; +typedef void* voidp; #else - typedef Byte const *voidpc; - typedef Byte FAR *voidpf; - typedef Byte *voidp; +typedef Byte const* voidpc; +typedef Byte FAR* voidpf; +typedef Byte* voidp; #endif /* ./configure may #define Z_U4 here */ @@ -406,9 +406,9 @@ typedef uLong FAR uLongf; #endif #ifdef Z_U4 - typedef Z_U4 z_crc_t; +typedef Z_U4 z_crc_t; #else - typedef unsigned long z_crc_t; +typedef unsigned long z_crc_t; #endif #ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ @@ -488,19 +488,19 @@ typedef uLong FAR uLongf; /* MVS linker does not support external names larger than 8 bytes */ #if defined(__MVS__) - #pragma map(deflateInit_,"DEIN") - #pragma map(deflateInit2_,"DEIN2") - #pragma map(deflateEnd,"DEEND") - #pragma map(deflateBound,"DEBND") - #pragma map(inflateInit_,"ININ") - #pragma map(inflateInit2_,"ININ2") - #pragma map(inflateEnd,"INEND") - #pragma map(inflateSync,"INSY") - #pragma map(inflateSetDictionary,"INSEDI") - #pragma map(compressBound,"CMBND") - #pragma map(inflate_table,"INTABL") - #pragma map(inflate_fast,"INFA") - #pragma map(inflate_copyright,"INCOPY") +#pragma map(deflateInit_,"DEIN") +#pragma map(deflateInit2_,"DEIN2") +#pragma map(deflateEnd,"DEEND") +#pragma map(deflateBound,"DEBND") +#pragma map(inflateInit_,"ININ") +#pragma map(inflateInit2_,"ININ2") +#pragma map(inflateEnd,"INEND") +#pragma map(inflateSync,"INSY") +#pragma map(inflateSetDictionary,"INSEDI") +#pragma map(compressBound,"CMBND") +#pragma map(inflate_table,"INTABL") +#pragma map(inflate_fast,"INFA") +#pragma map(inflate_copyright,"INCOPY") #endif #endif /* ZCONF_H */ diff --git a/extern/zlib/zlib.h b/extern/zlib/zlib.h index 81c7241..53b50f9 100644 --- a/extern/zlib/zlib.h +++ b/extern/zlib/zlib.h @@ -31,7 +31,7 @@ -/* +/* version 1.2.7.f-hanba-win64-v3, May 31, 2014 Copyright (C) 2012-2014 Jonathan Hanba (hanbaj@gmail.com) @@ -102,22 +102,23 @@ extern "C" { even in case of corrupted input. */ -typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); -typedef void (*free_func) OF((voidpf opaque, voidpf address)); +typedef voidpf(*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); struct internal_state; -typedef struct z_stream_s { - z_const Bytef *next_in; /* next input byte */ +typedef struct z_stream_s +{ + z_const Bytef* next_in; /* next input byte */ uInt avail_in; /* number of bytes available at next_in */ uLong total_in; /* total number of input bytes read so far */ - Bytef *next_out; /* next output byte should be put there */ + Bytef* next_out; /* next output byte should be put there */ uInt avail_out; /* remaining free space at next_out */ uLong total_out; /* total number of bytes output so far */ - z_const char *msg; /* last error message, NULL if no error */ - struct internal_state FAR *state; /* not visible by applications */ + z_const char* msg; /* last error message, NULL if no error */ + struct internal_state FAR* state; /* not visible by applications */ alloc_func zalloc; /* used to allocate the internal state */ free_func zfree; /* used to free the internal state */ @@ -128,30 +129,31 @@ typedef struct z_stream_s { uLong reserved; /* reserved for future use */ } z_stream; -typedef z_stream FAR *z_streamp; +typedef z_stream FAR* z_streamp; /* gzip header information passed to and from zlib routines. See RFC 1952 for more details on the meanings of these fields. */ -typedef struct gz_header_s { +typedef struct gz_header_s +{ int text; /* true if compressed data believed to be text */ uLong time; /* modification time */ int xflags; /* extra flags (not used when writing a gzip file) */ int os; /* operating system */ - Bytef *extra; /* pointer to extra field or Z_NULL if none */ + Bytef* extra; /* pointer to extra field or Z_NULL if none */ uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ uInt extra_max; /* space at extra (only when reading header) */ - Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + Bytef* name; /* pointer to zero-terminated file name or Z_NULL */ uInt name_max; /* space at name (only when reading header) */ - Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + Bytef* comment; /* pointer to zero-terminated comment or Z_NULL */ uInt comm_max; /* space at comment (only when reading header) */ int hcrc; /* true if there was or will be a header crc */ int done; /* true when done reading gzip header (not used when writing a gzip file) */ } gz_header; -typedef gz_header FAR *gz_headerp; +typedef gz_header FAR* gz_headerp; /* The application must update next_in and avail_in when avail_in has dropped @@ -184,7 +186,7 @@ typedef gz_header FAR *gz_headerp; if the decompressor wants to decompress everything in a single step). */ - /* constants */ +/* constants */ #define Z_NO_FLUSH 0 #define Z_PARTIAL_FLUSH 1 @@ -236,9 +238,9 @@ typedef gz_header FAR *gz_headerp; /* for compatibility with versions < 1.0.2 */ - /* basic functions */ +/* basic functions */ -ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +ZEXTERN const char* ZEXPORT zlibVersion OF((void)); /* The application can compare zlibVersion and ZLIB_VERSION for consistency. If the first character differs, the library code actually used is not compatible with the zlib.h header file used by the application. This check @@ -542,7 +544,7 @@ ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); */ - /* Advanced functions */ +/* Advanced functions */ /* The following functions are needed only in some special applications. @@ -610,8 +612,8 @@ ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, */ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, - const Bytef *dictionary, - uInt dictLength)); + const Bytef* dictionary, + uInt dictLength)); /* Initializes the compression dictionary from the given byte sequence without producing any compressed output. When using the zlib format, this @@ -736,8 +738,8 @@ ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, */ ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, - unsigned *pending, - int *bits)); + unsigned* pending, + int* bits)); /* deflatePending() returns the number of bytes and bits of output that have been generated, but not yet provided in the available output. The bytes not @@ -768,7 +770,7 @@ ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, */ ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, - gz_headerp head)); + gz_headerp head)); /* deflateSetHeader() provides gzip header information for when a gzip stream is requested by deflateInit2(). deflateSetHeader() may be called @@ -842,8 +844,8 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, */ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, - const Bytef *dictionary, - uInt dictLength)); + const Bytef* dictionary, + uInt dictLength)); /* Initializes the decompression dictionary from the given uncompressed byte sequence. This function must be called immediately after a call of inflate, @@ -971,7 +973,7 @@ ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); */ ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, - gz_headerp head)); + gz_headerp head)); /* inflateGetHeader() requests that gzip header information be stored in the provided gz_header structure. inflateGetHeader() may be called after @@ -1032,12 +1034,12 @@ ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, the version of the header file. */ -typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); -typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); +typedef unsigned(*in_func) OF((void FAR*, unsigned char FAR* FAR*)); +typedef int (*out_func) OF((void FAR*, unsigned char FAR*, unsigned)); ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, - in_func in, void FAR *in_desc, - out_func out, void FAR *out_desc)); + in_func in, void FAR* in_desc, + out_func out, void FAR* out_desc)); /* inflateBack() does a raw inflate with a single call using a call-back interface for input and output. This is more efficient than inflate() for @@ -1155,7 +1157,7 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); #ifndef Z_SOLO - /* utility functions */ +/* utility functions */ /* The following utility functions are implemented on top of the basic @@ -1165,8 +1167,8 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); you need special options. */ -ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, - const Bytef *source, uLong sourceLen)); +ZEXTERN int ZEXPORT compress OF((Bytef* dest, uLongf* destLen, + const Bytef* source, uLong sourceLen)); /* Compresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size @@ -1179,8 +1181,8 @@ ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, buffer. */ -ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, - const Bytef *source, uLong sourceLen, +ZEXTERN int ZEXPORT compress2 OF((Bytef* dest, uLongf* destLen, + const Bytef* source, uLong sourceLen, int level)); /* Compresses the source buffer into the destination buffer. The level @@ -1202,8 +1204,8 @@ ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); compress() or compress2() call to allocate the destination buffer. */ -ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, - const Bytef *source, uLong sourceLen)); +ZEXTERN int ZEXPORT uncompress OF((Bytef* dest, uLongf* destLen, + const Bytef* source, uLong sourceLen)); /* Decompresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size @@ -1220,7 +1222,7 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, buffer with the uncompressed data up to that point. */ - /* gzip file access functions */ +/* gzip file access functions */ /* This library supports reading and writing files in gzip (.gz) format with @@ -1229,7 +1231,7 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, wrapper, documented in RFC 1952, wrapped around a deflate stream. */ -typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ +typedef struct gzFile_s* gzFile; /* semi-opaque gzip file descriptor */ /* ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); @@ -1269,7 +1271,7 @@ ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); file could not be opened. */ -ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char* mode)); /* gzdopen associates a gzFile with the file descriptor fd. File descriptors are obtained from calls like open, dup, creat, pipe or fileno (if the file @@ -1354,7 +1356,7 @@ ZEXTERN int ZEXPORT gzwrite OF((gzFile file, error. */ -ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); +ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char* format, ...)); /* Converts, formats, and writes the arguments to the compressed file under control of the format string, as in fprintf. gzprintf returns the number of @@ -1369,7 +1371,7 @@ ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); zlibCompileFlags(). */ -ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char* s)); /* Writes the given null-terminated string to the compressed file, excluding the terminating null character. @@ -1377,7 +1379,7 @@ ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); gzputs returns the number of characters written, or -1 in case of error. */ -ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +ZEXTERN char* ZEXPORT gzgets OF((gzFile file, char* buf, int len)); /* Reads bytes from the compressed file until len-1 characters are read, or a newline character is read and transferred to buf, or an end-of-file @@ -1549,7 +1551,7 @@ ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); zlib library. */ -ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +ZEXTERN const char* ZEXPORT gzerror OF((gzFile file, int* errnum)); /* Returns the error message for the last error which occurred on the given compressed file. errnum is set to zlib error number. If an error occurred @@ -1574,7 +1576,7 @@ ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); #endif /* !Z_SOLO */ - /* checksum functions */ +/* checksum functions */ /* These functions are not related to compression but are exported @@ -1582,7 +1584,7 @@ ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); library. */ -ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef* buf, uInt len)); /* Update a running Adler-32 checksum with the bytes buf[0..len-1] and return the updated checksum. If buf is Z_NULL, this function returns the @@ -1613,7 +1615,7 @@ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, negative, the result has no meaning or utility. */ -ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef* buf, uInt len)); /* Update a running CRC-32 with the bytes buf[0..len-1] and return the updated CRC-32. If buf is Z_NULL, this function returns the required @@ -1641,25 +1643,25 @@ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); */ - /* various hacks, don't look :) */ +/* various hacks, don't look :) */ /* deflateInit and inflateInit are macros to allow checking the zlib version * and the compiler's view of z_stream: */ ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, - const char *version, int stream_size)); + const char* version, int stream_size)); ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, - const char *version, int stream_size)); + const char* version, int stream_size)); ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, int windowBits, int memLevel, - int strategy, const char *version, + int strategy, const char* version, int stream_size)); ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, - const char *version, int stream_size)); + const char* version, int stream_size)); ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, - unsigned char FAR *window, - const char *version, - int stream_size)); + unsigned char FAR* window, + const char* version, + int stream_size)); #define deflateInit(strm, level) \ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) #define inflateInit(strm) \ @@ -1683,9 +1685,10 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, * behavior could change in the future, perhaps even capriciously. They can * only be used by the gzgetc() macro. You have been warned. */ -struct gzFile_s { +struct gzFile_s +{ unsigned have; - unsigned char *next; + unsigned char* next; z_off64_t pos; }; ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ @@ -1705,12 +1708,12 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ * without large file support, _LFS64_LARGEFILE must also be true */ #ifdef Z_LARGE64 - ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); - ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); - ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); - ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); - ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); - ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); +ZEXTERN gzFile ZEXPORT gzopen64 OF((const char*, const char*)); +ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); +ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); +ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); +ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); +ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); #endif #if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) @@ -1730,44 +1733,44 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ # define crc32_combine crc32_combine64 # endif # ifndef Z_LARGE64 - ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); - ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); - ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); - ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); - ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); +ZEXTERN gzFile ZEXPORT gzopen64 OF((const char*, const char*)); +ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); +ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); +ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); +ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); +ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); # endif #else - ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); - ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); - ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); - ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); - ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); +ZEXTERN gzFile ZEXPORT gzopen OF((const char*, const char*)); +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); +ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); +ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); +ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); #endif #else /* Z_SOLO */ - ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); +ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); +ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); #endif /* !Z_SOLO */ /* hack for buggy compilers */ #if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) - struct internal_state {int dummy;}; +struct internal_state {int dummy;}; #endif /* undocumented functions */ -ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN const char* ZEXPORT zError OF((int)); ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); -ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); +ZEXTERN const z_crc_t FAR* ZEXPORT get_crc_table OF((void)); ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); #if defined(_WIN32) && !defined(Z_SOLO) -ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, - const char *mode)); +ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t* path, + const char* mode)); #endif #ifdef __cplusplus diff --git a/extern/zlib/zutil.c b/extern/zlib/zutil.c index fb47c42..ea3643a 100644 --- a/extern/zlib/zutil.c +++ b/extern/zlib/zutil.c @@ -14,20 +14,22 @@ struct internal_state {int dummy;}; /* for buggy compilers */ #endif -const char * const z_errmsg[10] = { -"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) */ -""}; +const char* const z_errmsg[10] = +{ + "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) */ + "" +}; -const char * ZEXPORT zlibVersion() +const char* ZEXPORT zlibVersion() { return ZLIB_VERSION; } @@ -37,30 +39,75 @@ uLong ZEXPORT zlibCompileFlags() uLong flags; flags = 0; - switch ((int)(sizeof(uInt))) { - case 2: break; - case 4: flags += 1; break; - case 8: flags += 2; break; - default: flags += 3; + + switch ((int)(sizeof(uInt))) + { + case 2: + break; + + case 4: + flags += 1; + break; + + case 8: + flags += 2; + break; + + default: + flags += 3; } - switch ((int)(sizeof(uLong))) { - case 2: break; - case 4: flags += 1 << 2; break; - case 8: flags += 2 << 2; break; - default: flags += 3 << 2; + + switch ((int)(sizeof(uLong))) + { + case 2: + break; + + case 4: + flags += 1 << 2; + break; + + case 8: + flags += 2 << 2; + break; + + default: + flags += 3 << 2; } - switch ((int)(sizeof(voidpf))) { - case 2: break; - case 4: flags += 1 << 4; break; - case 8: flags += 2 << 4; break; - default: flags += 3 << 4; + + switch ((int)(sizeof(voidpf))) + { + case 2: + break; + + case 4: + flags += 1 << 4; + break; + + case 8: + flags += 2 << 4; + break; + + default: + flags += 3 << 4; } - switch ((int)(sizeof(z_off_t))) { - case 2: break; - case 4: flags += 1 << 6; break; - case 8: flags += 2 << 6; break; - default: flags += 3 << 6; + + switch ((int)(sizeof(z_off_t))) + { + case 2: + break; + + case 4: + flags += 1 << 6; + break; + + case 8: + flags += 2 << 6; + break; + + default: + flags += 3 << 6; } + #ifdef DEBUG flags += 1 << 8; #endif @@ -122,8 +169,8 @@ uLong ZEXPORT zlibCompileFlags() # endif int ZLIB_INTERNAL z_verbose = verbose; -void ZLIB_INTERNAL z_error (m) - char *m; +void ZLIB_INTERNAL z_error(m) +char* m; { fprintf(stderr, "%s\n", m); exit(1); @@ -134,57 +181,65 @@ void ZLIB_INTERNAL z_error (m) * uncompress() */ #ifdef WIN32 -const char * ZEXPORT zError(int err) +const char* ZEXPORT zError(int err) #else -const char * ZEXPORT zError(err) - int err; +const char* ZEXPORT zError(err) +int err; #endif { return ERR_MSG(err); } #if defined(_WIN32_WCE) - /* The Microsoft C Run-Time Library for Windows CE doesn't have - * errno. We define it as a global variable to simplify porting. - * Its value is always 0 and should not be used. - */ - int errno = 0; +/* The Microsoft C Run-Time Library for Windows CE doesn't have + * errno. We define it as a global variable to simplify porting. + * Its value is always 0 and should not be used. + */ +int errno = 0; #endif #ifndef HAVE_MEMCPY void ZLIB_INTERNAL zmemcpy(dest, source, len) - Bytef* dest; - const Bytef* source; - uInt len; +Bytef* dest; +const Bytef* source; +uInt len; { if (len == 0) return; - do { + + do + { *dest++ = *source++; /* ??? to be unrolled */ - } while (--len != 0); + } + while (--len != 0); } int ZLIB_INTERNAL zmemcmp(s1, s2, len) - const Bytef* s1; - const Bytef* s2; - uInt len; +const Bytef* s1; +const Bytef* s2; +uInt len; { uInt j; - for (j = 0; j < len; j++) { - if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1; + for (j = 0; j < len; j++) + { + if (s1[j] != s2[j]) return 2 * (s1[j] > s2[j]) - 1; } + return 0; } void ZLIB_INTERNAL zmemzero(dest, len) - Bytef* dest; - uInt len; +Bytef* dest; +uInt len; { if (len == 0) return; - do { + + do + { *dest++ = 0; /* ??? to be unrolled */ - } while (--len != 0); + } + while (--len != 0); } #endif @@ -208,7 +263,8 @@ void ZLIB_INTERNAL zmemzero(dest, len) local int next_ptr = 0; -typedef struct ptr_table_s { +typedef struct ptr_table_s +{ voidpf org_ptr; voidpf new_ptr; } ptr_table; @@ -221,48 +277,62 @@ local ptr_table table[MAX_PTR]; * a protected system like OS/2. Use Microsoft C instead. */ -voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) +voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, unsigned size) { voidpf buf = opaque; /* just to make some compilers happy */ - ulg bsize = (ulg)items*size; + ulg bsize = (ulg)items * size; /* If we allocate less than 65520 bytes, we assume that farmalloc * will return a usable pointer which doesn't have to be normalized. */ - if (bsize < 65520L) { + if (bsize < 65520L) + { buf = farmalloc(bsize); + if (*(ush*)&buf != 0) return buf; - } else { + } + else + { buf = farmalloc(bsize + 16L); } + if (buf == NULL || next_ptr >= MAX_PTR) return NULL; + table[next_ptr].org_ptr = buf; /* Normalize the pointer to seg:0 */ - *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; + *((ush*)&buf + 1) += ((ush)((uch*)buf - 0) + 15) >> 4; *(ush*)&buf = 0; table[next_ptr++].new_ptr = buf; return buf; } -void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) +void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) { int n; - if (*(ush*)&ptr != 0) { /* object < 64K */ + + if (*(ush*)&ptr != 0) /* object < 64K */ + { farfree(ptr); return; } + /* Find the original pointer */ - for (n = 0; n < next_ptr; n++) { + for (n = 0; n < next_ptr; n++) + { if (ptr != table[n].new_ptr) continue; farfree(table[n].org_ptr); - while (++n < next_ptr) { - table[n-1] = table[n]; + + while (++n < next_ptr) + { + table[n - 1] = table[n]; } + next_ptr--; return; } + ptr = opaque; /* just to make some compilers happy */ Assert(0, "zcfree: ptr not found"); } @@ -280,15 +350,17 @@ void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) # define _hfree hfree #endif -voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size) +voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, uInt items, uInt size) { if (opaque) opaque = 0; /* to make compiler happy */ + return _halloc((long)items, size); } -void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) +void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) { if (opaque) opaque = 0; /* to make compiler happy */ + _hfree(ptr); } @@ -306,28 +378,30 @@ extern void free OF((voidpf ptr)); #endif #ifdef WIN32 -voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) +voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, unsigned size) #else -voidpf ZLIB_INTERNAL zcalloc (opaque, items, size) - voidpf opaque; - unsigned items; - unsigned size; +voidpf ZLIB_INTERNAL zcalloc(opaque, items, size) +voidpf opaque; +unsigned items; +unsigned size; #endif { if (opaque) items += size - size; /* make compiler happy */ + return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : - (voidpf)calloc(items, size); + (voidpf)calloc(items, size); } #ifdef WIN32 -void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) +void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr) #else -void ZLIB_INTERNAL zcfree (opaque, ptr) - voidpf opaque; - voidpf ptr; +void ZLIB_INTERNAL zcfree(opaque, ptr) +voidpf opaque; +voidpf ptr; #endif { free(ptr); + if (opaque) return; /* make compiler happy */ } diff --git a/extern/zlib/zutil.h b/extern/zlib/zutil.h index 4e3dcc6..b63c3a9 100644 --- a/extern/zlib/zutil.h +++ b/extern/zlib/zutil.h @@ -30,7 +30,7 @@ #endif #ifdef Z_SOLO - typedef long ptrdiff_t; /* guess -- will be caught if guess is wrong */ +typedef long ptrdiff_t; /* guess -- will be caught if guess is wrong */ #endif #ifndef local @@ -44,7 +44,7 @@ typedef unsigned short ush; typedef ush FAR ushf; typedef unsigned long ulg; -extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ +extern const char* const z_errmsg[10]; /* indexed by 2-zlib_error */ /* (size given to avoid silly warnings with Visual C++) */ #define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] @@ -53,7 +53,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ return (strm->msg = (char*)ERR_MSG(err), (err)) /* To be used only when the state is known to be valid */ - /* common constants */ +/* common constants */ #ifndef DEF_WBITS # define DEF_WBITS MAX_WBITS @@ -78,16 +78,16 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ - /* target dependencies */ +/* target dependencies */ #if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) # define OS_CODE 0x00 # ifndef Z_SOLO # if defined(__TURBOC__) || defined(__BORLANDC__) # if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) - /* Allow compilation with ANSI keywords only enabled */ - void _Cdecl farfree( void *block ); - void *_Cdecl farmalloc( unsigned long nbytes ); +/* Allow compilation with ANSI keywords only enabled */ +void _Cdecl farfree(void* block); +void* _Cdecl farmalloc(unsigned long nbytes); # else # include # endif @@ -153,7 +153,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ # if defined(_WIN32_WCE) # define fdopen(fd,mode) NULL /* No fdopen() */ # ifndef _PTRDIFF_T_DEFINED - typedef int ptrdiff_t; +typedef int ptrdiff_t; # define _PTRDIFF_T_DEFINED # endif # else @@ -162,18 +162,18 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ #endif #if defined(__BORLANDC__) && !defined(MSDOS) - #pragma warn -8004 - #pragma warn -8008 - #pragma warn -8066 +#pragma warn -8004 +#pragma warn -8008 +#pragma warn -8066 #endif /* provide prototypes for these when building zlib without LFS */ #if !defined(_WIN32) && (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0) - ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); - ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); +ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); +ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); #endif - /* common defaults */ +/* common defaults */ #ifndef OS_CODE # define OS_CODE 0x03 /* assume Unix */ @@ -183,16 +183,16 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ # define F_OPEN(name, mode) fopen((name), (mode)) #endif - /* functions */ +/* functions */ #if defined(pyr) || defined(Z_SOLO) # define NO_MEMCPY #endif #if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) - /* Use our own functions for small and medium model with MSC <= 5.0. - * You may have to use the same strategy for Borland C (untested). - * The __SC__ check is for Symantec. - */ +/* Use our own functions for small and medium model with MSC <= 5.0. + * You may have to use the same strategy for Borland C (untested). + * The __SC__ check is for Symantec. + */ # define NO_MEMCPY #endif #if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) @@ -209,16 +209,16 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ # define zmemzero(dest, len) memset(dest, 0, len) # endif #else - void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); - int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); - void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); +void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); +int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); +void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); #endif /* Diagnostic functions */ #ifdef DEBUG # include - extern int ZLIB_INTERNAL z_verbose; - extern void ZLIB_INTERNAL z_error OF((char *m)); +extern int ZLIB_INTERNAL z_verbose; +extern void ZLIB_INTERNAL z_error OF((char* m)); # define Assert(cond,msg) {if(!(cond)) z_error(msg);} # define Trace(x) {if (z_verbose>=0) fprintf x ;} # define Tracev(x) {if (z_verbose>0) fprintf x ;} @@ -235,9 +235,9 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ #endif #ifndef Z_SOLO - voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, - unsigned size)); - void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); +voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, + unsigned size)); +void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); #endif #define ZALLOC(strm, items, size) \ diff --git a/include/Athena/ALTTPQuest.hpp b/include/Athena/ALTTPQuest.hpp index 5a46ec9..516d991 100644 --- a/include/Athena/ALTTPQuest.hpp +++ b/include/Athena/ALTTPQuest.hpp @@ -337,7 +337,8 @@ public: * \brief setCrystals * \param val */ - void setCrystals(ALTTPCrystals val);\ + void setCrystals(ALTTPCrystals val); + \ /*! * \brief crystals diff --git a/include/Athena/ALTTPStructs.hpp b/include/Athena/ALTTPStructs.hpp index 5f6183e..5c30e99 100644 --- a/include/Athena/ALTTPStructs.hpp +++ b/include/Athena/ALTTPStructs.hpp @@ -26,34 +26,34 @@ namespace Athena struct ALTTPRoomFlags { - bool Chest1:1; - bool Chest2:1; - bool Chest3:1; - bool Chest4:1; - bool Quadrant1:1; - bool Quadrant2:1; - bool Quadrant3:1; - bool Quadrant4:1; - bool Door1:1; - bool Door2:1; - bool Door3:1; - bool Door4:1; - bool BossBattleWon:1; - bool Key:1; - bool KeyOrChest:1; - bool ChestOrTile:1; + bool Chest1: 1; + bool Chest2: 1; + bool Chest3: 1; + bool Chest4: 1; + bool Quadrant1: 1; + bool Quadrant2: 1; + bool Quadrant3: 1; + bool Quadrant4: 1; + bool Door1: 1; + bool Door2: 1; + bool Door3: 1; + bool Door4: 1; + bool BossBattleWon: 1; + bool Key: 1; + bool KeyOrChest: 1; + bool ChestOrTile: 1; }; struct ALTTPOverworldEvent { - bool Unused1:1; - bool HeartPiece:1; - bool Overlay:1; - bool Unused2:1; - bool Unused3:1; - bool Unused4:1; - bool Set:1; - bool Unused5:1; + bool Unused1: 1; + bool HeartPiece: 1; + bool Overlay: 1; + bool Unused2: 1; + bool Unused3: 1; + bool Unused4: 1; + bool Set: 1; + bool Unused5: 1; }; struct ALTTPInventory @@ -93,14 +93,14 @@ struct ALTTPInventory */ struct ALTTPLightDarkWorldIndicator { - bool Unused1:1; - bool Unused2:1; - bool Unused3:1; - bool Unused4:1; - bool Unused5:1; - bool Unused6:1; - bool IsDarkWorld:1; - bool Unused7:1; + bool Unused1: 1; + bool Unused2: 1; + bool Unused3: 1; + bool Unused4: 1; + bool Unused5: 1; + bool Unused6: 1; + bool IsDarkWorld: 1; + bool Unused7: 1; }; @@ -110,14 +110,14 @@ struct ALTTPDungeonItemFlags { struct { - bool Unused1:1; - bool Unused2:1; - bool GanonsTower:1; - bool TurtleRock:1; - bool GargoylesDomain:1; - bool TowerOfHera:1; - bool IcePalace:1; - bool SkullWoods:1; + bool Unused1: 1; + bool Unused2: 1; + bool GanonsTower: 1; + bool TurtleRock: 1; + bool GargoylesDomain: 1; + bool TowerOfHera: 1; + bool IcePalace: 1; + bool SkullWoods: 1; }; atUint8 flags1; }; @@ -126,14 +126,14 @@ struct ALTTPDungeonItemFlags { struct { - bool MiseryMire:1; - bool DarkPalace:1; - bool SwampPalace:1; - bool HyruleCastle2:1; // unused in orignal game - bool DesertPalace:1; - bool EasternPalace:1; - bool HyruleCastle:1; // unused exist in original game - bool SewerPassage:1; // unused exist in original game + bool MiseryMire: 1; + bool DarkPalace: 1; + bool SwampPalace: 1; + bool HyruleCastle2: 1; // unused in orignal game + bool DesertPalace: 1; + bool EasternPalace: 1; + bool HyruleCastle: 1; // unused exist in original game + bool SewerPassage: 1; // unused exist in original game }; atUint8 flags2; }; @@ -141,75 +141,75 @@ struct ALTTPDungeonItemFlags struct ALTTPPendants { - bool Courage:1; - bool Wisdom:1; - bool Power:1; - bool Unused1:1; - bool Unused2:1; - bool Unused3:1; - bool Unused4:1; - bool Unused5:1; + bool Courage: 1; + bool Wisdom: 1; + bool Power: 1; + bool Unused1: 1; + bool Unused2: 1; + bool Unused3: 1; + bool Unused4: 1; + bool Unused5: 1; }; struct ALTTPAbilities { - bool Nothing:1; //? - bool Swim:1; - bool Dash:1; - bool Pull:1; - bool Unknown1:1; //--- - bool Talk:1; - bool Read:1; - bool Unknown2:1; //--- + bool Nothing: 1; //? + bool Swim: 1; + bool Dash: 1; + bool Pull: 1; + bool Unknown1: 1; //--- + bool Talk: 1; + bool Read: 1; + bool Unknown2: 1; //--- }; struct ALTTPCrystals { - bool MiseryMire:1; - bool DarkPalace:1; - bool IcePalace:1; - bool TurtleRock:1; - bool SwampPalace:1; - bool GargoyleDomain:1; - bool SkullWoods:1; + bool MiseryMire: 1; + bool DarkPalace: 1; + bool IcePalace: 1; + bool TurtleRock: 1; + bool SwampPalace: 1; + bool GargoyleDomain: 1; + bool SkullWoods: 1; }; struct ALTTPMagicUsage { - bool Normal:1; - bool Half:1; - bool Quarter:1; - bool Unused1:1; - bool Unused2:1; - bool Unused3:1; - bool Unused4:1; - bool Unused5:1; + bool Normal: 1; + bool Half: 1; + bool Quarter: 1; + bool Unused1: 1; + bool Unused2: 1; + bool Unused3: 1; + bool Unused4: 1; + bool Unused5: 1; }; struct ALTTPProgressFlags1 { - bool UncleSecretPassage:1; - bool DyingPriest:1; //? - bool ZeldaSanctuary:1; //? - bool Unused1:1; - bool UncleLeftHouse:1; - bool BookOfMudora:1;//? Math says it's a guess need to investigate - bool DwarfPartner:1; //? - bool Unused2:1; + bool UncleSecretPassage: 1; + bool DyingPriest: 1; //? + bool ZeldaSanctuary: 1; //? + bool Unused1: 1; + bool UncleLeftHouse: 1; + bool BookOfMudora: 1; //? Math says it's a guess need to investigate + bool DwarfPartner: 1; //? + bool Unused2: 1; }; struct ALTTPProgressFlags2 { - bool BottleFromBum:1; - bool BottleFromSalesMen:1; - bool Unused1:1; //? - bool FluteBoy:1; - bool ThiefsChest:1; - bool SavedSmithPartner:1; - bool Unused2:1; //? - bool SmithsHaveSword:1; + bool BottleFromBum: 1; + bool BottleFromSalesMen: 1; + bool Unused1: 1; //? + bool FluteBoy: 1; + bool ThiefsChest: 1; + bool SavedSmithPartner: 1; + bool Unused2: 1; //? + bool SmithsHaveSword: 1; }; } diff --git a/include/Athena/FileWriter.hpp b/include/Athena/FileWriter.hpp index 4576e9c..0685c28 100644 --- a/include/Athena/FileWriter.hpp +++ b/include/Athena/FileWriter.hpp @@ -42,21 +42,21 @@ public: atUint64 position() const; atUint64 length() const; - void writeBit (bool val); - void seekBit (int bit); - void writeUByte (atUint8 val); - void writeByte (atInt8 val); + void writeBit(bool val); + void seekBit(int bit); + void writeUByte(atUint8 val); + void writeByte(atInt8 val); void writeUBytes(atUint8* data, atUint64 len); - void writeBytes (atInt8* data, atUint64 len); + void writeBytes(atInt8* data, atUint64 len); void writeUint16(atUint16 val); - void writeInt16 (atInt16 val); + void writeInt16(atInt16 val); void writeUint32(atUint32 val); - void writeInt32 (atInt32 val); + void writeInt32(atInt32 val); void writeUint64(atUint64 val); - void writeInt64 (atInt64 val); + void writeInt64(atInt64 val); void writeDouble(double val); - void writeFloat (float val); - void writeBool (bool val); + void writeFloat(float val); + void writeBool(bool val); void writeString(const std::string& val); void writeUnicode(const std::string& str); void fill(atInt8 byte, atUint64 len); diff --git a/include/Athena/IOException.hpp b/include/Athena/IOException.hpp index d498262..5046bc5 100644 --- a/include/Athena/IOException.hpp +++ b/include/Athena/IOException.hpp @@ -54,10 +54,13 @@ public: do { \ if (atGetExceptionHandler()) {atGetExceptionHandler()(__FILE__, AT_PRETTY_FUNCTION, __LINE__, __VA_ARGS__); return; \ } else { - std::string msg = Athena::utility::sprintf(args, __VA_ARGS__); \ - throw Athena::error::IOException(std::string("IOException: ")+msg, __FILE__, AT_PRETTY_FUNCTION, __LINE__); \ - } \ - } while(0) +std::string msg = Athena::utility::sprintf(args, __VA_ARGS__); +\ +throw Athena::error::IOException(std::string("IOException: ") + msg, __FILE__, AT_PRETTY_FUNCTION, __LINE__); +\ +} \ + +} while (0) #elif defined(__GNUC__) #define THROW_IO_EXCEPTION(args...) \ do { \ @@ -73,10 +76,14 @@ public: do { \ if (atGetExceptionHandler()) {atGetExceptionHandler()(__FILE__, AT_PRETTY_FUNCTION, __LINE__, __VA_ARGS__); return ret; \ } else { - std::string msg = Athena::utility::sprintf(args, __VA_ARGS__); \ - throw Athena::error::IOException(std::string("IOException: ")+msg, __FILE__, AT_PRETTY_FUNCTION, __LINE__); \ - } \ - } while(0) + std::string msg = Athena::utility::sprintf(args, __VA_ARGS__); + +\ +throw Athena::error::IOException(std::string("IOException: ") + msg, __FILE__, AT_PRETTY_FUNCTION, __LINE__); +\ +} \ + +} while (0) #elif defined(__GNUC__) #define THROW_IO_EXCEPTION_RETURN(ret, args...) \ do { \ diff --git a/include/Athena/IStream.hpp b/include/Athena/IStream.hpp index 95207cb..99a9e84 100644 --- a/include/Athena/IStream.hpp +++ b/include/Athena/IStream.hpp @@ -31,15 +31,15 @@ public: virtual ~IStream() {} virtual void setEndian(Endian) = 0; - virtual Endian endian() const= 0; - virtual bool isBigEndian() const= 0; - virtual bool isLittleEndian()const= 0; - virtual bool isOpen() const= 0; - virtual void seek(atInt64, SeekOrigin)=0; - virtual bool atEnd() const= 0; - virtual atUint64 position() const= 0; - virtual atUint64 length() const= 0; - virtual void seekBit (int)=0; + virtual Endian endian() const = 0; + virtual bool isBigEndian() const = 0; + virtual bool isLittleEndian()const = 0; + virtual bool isOpen() const = 0; + virtual void seek(atInt64, SeekOrigin) = 0; + virtual bool atEnd() const = 0; + virtual atUint64 position() const = 0; + virtual atUint64 length() const = 0; + virtual void seekBit(int) = 0; }; } } diff --git a/include/Athena/IStreamReader.hpp b/include/Athena/IStreamReader.hpp index de1fb3c..4124136 100644 --- a/include/Athena/IStreamReader.hpp +++ b/include/Athena/IStreamReader.hpp @@ -12,34 +12,34 @@ class IStreamReader : public IStream public: virtual ~IStreamReader() {} virtual void setEndian(Endian) = 0; - virtual Endian endian() const= 0; - virtual bool isBigEndian() const= 0; - virtual bool isLittleEndian()const= 0; - virtual bool isOpen() const= 0; - virtual void seek(atInt64, SeekOrigin)=0; - virtual void seekAlign32()=0; - virtual bool atEnd() const= 0; - virtual atUint64 position() const= 0; - virtual atUint64 length() const= 0; - virtual void seekBit (int)=0; - virtual bool readBit()=0; - virtual atUint8 readUByte()=0; - virtual atInt8 readByte()=0; - virtual atUint8* readUBytes(atUint64)=0; - virtual atInt8* readBytes(atUint64)=0; - virtual atUint64 readUBytesToBuf(void*, atUint64)=0; - virtual atUint64 readBytesToBuf(void*, atUint64)=0; - virtual atUint16 readUint16()=0; - virtual atInt16 readInt16()=0; - virtual atUint32 readUint32()=0; - virtual atInt32 readInt32()=0; - virtual atUint64 readUint64()=0; - virtual atInt64 readInt64()=0; - virtual double readDouble()=0; - virtual float readFloat()=0; - virtual bool readBool()=0; - virtual std::string readUnicode(atInt32=-1)=0; - virtual std::string readString(atInt32=-1)=0; + virtual Endian endian() const = 0; + virtual bool isBigEndian() const = 0; + virtual bool isLittleEndian()const = 0; + virtual bool isOpen() const = 0; + virtual void seek(atInt64, SeekOrigin) = 0; + virtual void seekAlign32() = 0; + virtual bool atEnd() const = 0; + virtual atUint64 position() const = 0; + virtual atUint64 length() const = 0; + virtual void seekBit(int) = 0; + virtual bool readBit() = 0; + virtual atUint8 readUByte() = 0; + virtual atInt8 readByte() = 0; + virtual atUint8* readUBytes(atUint64) = 0; + virtual atInt8* readBytes(atUint64) = 0; + virtual atUint64 readUBytesToBuf(void*, atUint64) = 0; + virtual atUint64 readBytesToBuf(void*, atUint64) = 0; + virtual atUint16 readUint16() = 0; + virtual atInt16 readInt16() = 0; + virtual atUint32 readUint32() = 0; + virtual atInt32 readInt32() = 0; + virtual atUint64 readUint64() = 0; + virtual atInt64 readInt64() = 0; + virtual double readDouble() = 0; + virtual float readFloat() = 0; + virtual bool readBool() = 0; + virtual std::string readUnicode(atInt32 = -1) = 0; + virtual std::string readString(atInt32 = -1) = 0; }; } } diff --git a/include/Athena/IStreamWriter.hpp b/include/Athena/IStreamWriter.hpp index bdc2712..1f72f3e 100644 --- a/include/Athena/IStreamWriter.hpp +++ b/include/Athena/IStreamWriter.hpp @@ -12,34 +12,34 @@ class IStreamWriter : public IStream public: virtual ~IStreamWriter() {} virtual void setEndian(Endian) = 0; - virtual Endian endian() const= 0; - virtual bool isBigEndian() const= 0; - virtual bool isLittleEndian()const= 0; - virtual bool isOpen() const= 0; - virtual void seek(atInt64, SeekOrigin)=0; - virtual void seekAlign32()=0; - virtual bool atEnd() const= 0; - virtual atUint64 position() const= 0; - virtual atUint64 length() const= 0; - virtual void seekBit (int)=0; - virtual void writeBit (bool)=0; - virtual void writeUByte (atUint8)=0; - virtual void writeByte (atInt8)=0; - virtual void writeUBytes(atUint8*, atUint64)=0; - virtual void writeBytes (atInt8*, atUint64)=0; - virtual void writeUint16(atUint16)=0; - virtual void writeInt16 (atInt16)=0; - virtual void writeUint32(atUint32)=0; - virtual void writeInt32 (atInt32)=0; - virtual void writeUint64(atUint64)=0; - virtual void writeInt64 (atInt64)=0; - virtual void writeDouble(double)=0; - virtual void writeFloat (float)=0; - virtual void writeBool (bool)=0; - virtual void writeString(const std::string&)=0; - virtual void writeUnicode(const std::string&)=0; - virtual void fill(atUint8, atUint64)=0; - virtual void fill(atInt8, atUint64)=0; + virtual Endian endian() const = 0; + virtual bool isBigEndian() const = 0; + virtual bool isLittleEndian()const = 0; + virtual bool isOpen() const = 0; + virtual void seek(atInt64, SeekOrigin) = 0; + virtual void seekAlign32() = 0; + virtual bool atEnd() const = 0; + virtual atUint64 position() const = 0; + virtual atUint64 length() const = 0; + virtual void seekBit(int) = 0; + virtual void writeBit(bool) = 0; + virtual void writeUByte(atUint8) = 0; + virtual void writeByte(atInt8) = 0; + virtual void writeUBytes(atUint8*, atUint64) = 0; + virtual void writeBytes(atInt8*, atUint64) = 0; + virtual void writeUint16(atUint16) = 0; + virtual void writeInt16(atInt16) = 0; + virtual void writeUint32(atUint32) = 0; + virtual void writeInt32(atInt32) = 0; + virtual void writeUint64(atUint64) = 0; + virtual void writeInt64(atInt64) = 0; + virtual void writeDouble(double) = 0; + virtual void writeFloat(float) = 0; + virtual void writeBool(bool) = 0; + virtual void writeString(const std::string&) = 0; + virtual void writeUnicode(const std::string&) = 0; + virtual void fill(atUint8, atUint64) = 0; + virtual void fill(atInt8, atUint64) = 0; }; } } diff --git a/include/Athena/InvalidOperationException.hpp b/include/Athena/InvalidOperationException.hpp index c58f6b9..28487a9 100644 --- a/include/Athena/InvalidOperationException.hpp +++ b/include/Athena/InvalidOperationException.hpp @@ -53,10 +53,13 @@ public: do { \ if (atGetExceptionHandler()) {atGetExceptionHandler()(__FILE__, AT_PRETTY_FUNCTION, __LINE__, __VA_ARGS__); return; \ } else { - std::string msg = Athena::utility::sprintf(args, __VA_ARGS__); \ - throw Athena::error::InvalidOperationException(std::string("InvalidOperationException: ")+msg, __FILE__, AT_PRETTY_FUNCTION, __LINE__); \ - } \ - } while(0) +std::string msg = Athena::utility::sprintf(args, __VA_ARGS__); +\ +throw Athena::error::InvalidOperationException(std::string("InvalidOperationException: ") + msg, __FILE__, AT_PRETTY_FUNCTION, __LINE__); +\ +} \ + +} while (0) #elif defined (__GNUC__) #define THROW_INVALID_OPERATION_EXCEPTION(args...) \ do { \ @@ -72,10 +75,14 @@ public: do { \ if (atGetExceptionHandler()) {atGetExceptionHandler()(__FILE__, AT_PRETTY_FUNCTION, __LINE__, __VA_ARGS__); return ret; \ } else { - std::string msg = Athena::utility::sprintf(args, __VA_ARGS__); \ - throw Athena::error::InvalidOperationException(std::string("InvalidOperationException: ")+msg, __FILE__, AT_PRETTY_FUNCTION, __LINE__); \ - } \ - } while(0) + std::string msg = Athena::utility::sprintf(args, __VA_ARGS__); + +\ +throw Athena::error::InvalidOperationException(std::string("InvalidOperationException: ") + msg, __FILE__, AT_PRETTY_FUNCTION, __LINE__); +\ +} \ + +} while (0) #elif defined(__GNUC__) #define THROW_INVALID_OPERATION_EXCEPTION_RETURN(ret, args...) \ do { \ diff --git a/include/Athena/MemoryReader.hpp b/include/Athena/MemoryReader.hpp index 7737429..b4cec76 100644 --- a/include/Athena/MemoryReader.hpp +++ b/include/Athena/MemoryReader.hpp @@ -177,7 +177,7 @@ public: * \return Int8* The buffer at the current position from the given length. */ atUint8* readUBytes(atUint64 length); - + atUint64 readBytesToBuf(void* buf, atUint64 len) {return readUBytesToBuf(buf, len);} atUint64 readUBytesToBuf(void* buf, atUint64 len); diff --git a/include/Athena/MemoryWriter.hpp b/include/Athena/MemoryWriter.hpp index a1e563b..5042da5 100644 --- a/include/Athena/MemoryWriter.hpp +++ b/include/Athena/MemoryWriter.hpp @@ -41,7 +41,7 @@ public: * \param data The existing buffer * \param length The length of the existing buffer */ - explicit MemoryWriter(atUint8* data = nullptr, atUint64 length=0x10); + explicit MemoryWriter(atUint8* data = nullptr, atUint64 length = 0x10); /*! \brief This constructor creates an instance from a file on disk. * @@ -87,7 +87,7 @@ public: * \param origin The Origin to seek \sa SeekOrigin */ void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current); - + /*! \brief Sets the buffers position relative to the next 32-byte aligned position.
*/ inline void seekAlign32() {seek(ROUND_UP_32(m_position), SeekOrigin::Begin);} @@ -148,7 +148,7 @@ public: * * \param filename If not empty, the filename to save to */ - void save(const std::string& filename=""); + void save(const std::string& filename = ""); /*! * \brief Seeks to the specified bit within the current byte diff --git a/include/Athena/SkywardSwordQuest.hpp b/include/Athena/SkywardSwordQuest.hpp index 5b2bc13..7bcdcd4 100644 --- a/include/Athena/SkywardSwordQuest.hpp +++ b/include/Athena/SkywardSwordQuest.hpp @@ -1,18 +1,18 @@ #if !defined(ATHENA_NO_SAVES) && !defined(ATHENA_NO_ZQUEST) -// This file is part of libAthena. -// -// libAthena is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// libAthena is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with libAthena. If not, see + // This file is part of libAthena. + // + // libAthena is free software: you can redistribute it and/or modify + // it under the terms of the GNU General Public License as published by + // the Free Software Foundation, either version 3 of the License, or + // (at your option) any later version. + // + // libAthena is distributed in the hope that it will be useful, + // but WITHOUT ANY WARRANTY; without even the implied warranty of + // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + // GNU General Public License for more details. + // + // You should have received a copy of the GNU General Public License + // along with libAthena. If not, see #ifndef SKYWARDSWORDQUEST_HPP #define SKYWARDSWORDQUEST_HPP @@ -20,57 +20,57 @@ #include "Athena/Global.hpp" #include "Athena/ZQuestFile.hpp" -namespace Athena -{ - -// TODO: Handle game specific data -class SkywardSwordQuest : public ZQuestFile -{ -public: - enum AmmoType + namespace Athena { - Arrows, - Bombs, - Seeds + + // TODO: Handle game specific data + class SkywardSwordQuest : public ZQuestFile + { + public: + enum AmmoType + { + Arrows, + Bombs, + Seeds + }; + + SkywardSwordQuest(atUint8* data, atUint32 len); + + void setPlayerName(const std::string& name); + std::string playerName() const; + + void setRupeeCount(atUint16 value); + atUint16 rupeeCount(); + void setAmmoCount(AmmoType type, atUint32 count); + atUint32 ammoCount(AmmoType type); + void setMaxHP(atUint16 val); + atUint16 maxHP(); + float maxHearts(); + void setSpawnHP(atUint16 val); + atUint16 spawnHP(); + float spawnHearts(); + void setCurrentHP(atUint16 val); + atUint16 currentHP(); + float currentHearts(); + std::string currentLocation(); + std::string currentArea(); + std::string currentLocationCopy(); + + void setSkipData(const atUint8* data); + atUint8* skipData() const; + + + atUint32 slotChecksum(); + atUint32 skipChecksum(); + void fixChecksums(); + + void setNew(bool isNew); + bool isNew() const; + private: + atUint8* m_skipData; }; - SkywardSwordQuest(atUint8* data, atUint32 len); - void setPlayerName(const std::string& name); - std::string playerName() const; - - void setRupeeCount(atUint16 value); - atUint16 rupeeCount(); - void setAmmoCount(AmmoType type, atUint32 count); - atUint32 ammoCount(AmmoType type); - void setMaxHP(atUint16 val); - atUint16 maxHP(); - float maxHearts(); - void setSpawnHP(atUint16 val); - atUint16 spawnHP(); - float spawnHearts(); - void setCurrentHP(atUint16 val); - atUint16 currentHP(); - float currentHearts(); - std::string currentLocation(); - std::string currentArea(); - std::string currentLocationCopy(); - - void setSkipData(const atUint8* data); - atUint8* skipData() const; - - - atUint32 slotChecksum(); - atUint32 skipChecksum(); - void fixChecksums(); - - void setNew(bool isNew); - bool isNew() const; -private: - atUint8* m_skipData; -}; - - -} // zelda + } // zelda #endif // SSQUEST_HPP #endif // ATHENA_NO_SAVES diff --git a/include/Athena/SpriteFile.hpp b/include/Athena/SpriteFile.hpp index d6fc0fc..23ae089 100644 --- a/include/Athena/SpriteFile.hpp +++ b/include/Athena/SpriteFile.hpp @@ -258,9 +258,9 @@ signals: void originChanged(QPoint); void sizeChanged(QSize); #endif - private: - #ifndef ATHENA_USE_QT - std::vector m_textures; +private: +#ifndef ATHENA_USE_QT + std::vector m_textures; Vector2Di m_size; Vector2Df m_origin; std::unordered_map m_sprites; diff --git a/include/Athena/SpritePart.hpp b/include/Athena/SpritePart.hpp index 1282334..9cb1b1f 100644 --- a/include/Athena/SpritePart.hpp +++ b/include/Athena/SpritePart.hpp @@ -178,7 +178,7 @@ public: #ifdef ATHENA_USE_QT signals: void nameChanged(QString); - void orientationChanged(bool,bool); + void orientationChanged(bool, bool); void offsetChanged(QPoint); void textureOffsetChanged(QPoint); void sizeChanged(QSize); diff --git a/include/Athena/Types.hpp b/include/Athena/Types.hpp index 59903de..7e55f11 100644 --- a/include/Athena/Types.hpp +++ b/include/Athena/Types.hpp @@ -19,38 +19,38 @@ // 8 bits integer types #if UCHAR_MAX == 0xFF - typedef signed char atInt8; - typedef unsigned char atUint8; +typedef signed char atInt8; +typedef unsigned char atUint8; #else - #error No 8 bits integer type for this platform +#error No 8 bits integer type for this platform #endif // 16 bits integer types #if USHRT_MAX == 0xFFFF - typedef signed short atInt16; - typedef unsigned short atUint16; +typedef signed short atInt16; +typedef unsigned short atUint16; #elif UINT_MAX == 0xFFFF - typedef signed int atInt16; - typedef unsigned int atUint16; +typedef signed int atInt16; +typedef unsigned int atUint16; #elif ULONG_MAX == 0xFFFF - typedef signed long atInt16; - typedef unsigned long atUint16; +typedef signed long atInt16; +typedef unsigned long atUint16; #else - #error No 16 bits integer type for this platform +#error No 16 bits integer type for this platform #endif // 32 bits integer types #if USHRT_MAX == 0xFFFFFFFF - typedef signed short atInt32; - typedef unsigned short atUint32; +typedef signed short atInt32; +typedef unsigned short atUint32; #elif UINT_MAX == 0xFFFFFFFF - typedef signed int atInt32; - typedef unsigned int atUint32; +typedef signed int atInt32; +typedef unsigned int atUint32; #elif ULONG_MAX == 0xFFFFFFFF - typedef signed long atInt32; - typedef unsigned long atUint32; +typedef signed long atInt32; +typedef unsigned long atUint32; #else - #error No 32 bits integer type for this platform +#error No 32 bits integer type for this platform #endif typedef signed long long atInt64; diff --git a/include/Athena/Utility.hpp b/include/Athena/Utility.hpp index 02eff72..27f5127 100644 --- a/include/Athena/Utility.hpp +++ b/include/Athena/Utility.hpp @@ -31,7 +31,7 @@ namespace utility inline bool isEmpty(atInt8* buf, atUint32 size) {return !memcmp(buf, buf + 1, size - 1);} bool isSystemBigEndian(); -inline atInt16 swap16 (atInt16 val) +inline atInt16 swap16(atInt16 val) { #if __GNUC__ return __builtin_bswap16(val); @@ -42,7 +42,7 @@ inline atInt16 swap16 (atInt16 val) #endif } inline atUint16 swapU16(atUint16 val) {return (atUint16)swap16(val);} -inline atInt32 swap32 (atInt32 val) +inline atInt32 swap32(atInt32 val) { #if __GNUC__ return __builtin_bswap32(val); @@ -55,7 +55,7 @@ inline atInt32 swap32 (atInt32 val) #endif } inline atUint32 swapU32(atUint32 val) {return (atUint32)swap32(val);} -inline atInt64 swap64 (atInt64 val) +inline atInt64 swap64(atInt64 val) { #if __GNUC__ return __builtin_bswap64(val); @@ -87,7 +87,7 @@ inline atInt16 LittleInt16(atInt16& val) { if (Athena::utility::isSystemBigEndian()) val = Athena::utility::swap16(val); - + return val; } inline atUint16 LittleUint16(atUint16& val) @@ -95,14 +95,14 @@ inline atUint16 LittleUint16(atUint16& val) atInt16 ret = val; LittleInt16(ret); val = ret; - + return val; } inline atInt16 BigInt16(atInt16& val) { if (!Athena::utility::isSystemBigEndian()) val = Athena::utility::swap16(val); - + return val; } inline atUint16 BigUint16(atUint16& val) @@ -110,14 +110,14 @@ inline atUint16 BigUint16(atUint16& val) atInt16 ret = val; BigInt16(ret); val = ret; - + return val; } inline atInt32 LittleInt32(atInt32& val) { if (Athena::utility::isSystemBigEndian()) val = Athena::utility::swap32(val); - + return val; } inline atUint32 LittleUint32(atUint32& val) @@ -125,14 +125,14 @@ inline atUint32 LittleUint32(atUint32& val) atInt32 ret = val; LittleInt32(ret); val = ret; - + return val; } inline atInt32 BigInt32(atInt32& val) { if (!Athena::utility::isSystemBigEndian()) val = Athena::utility::swap32(val); - + return val; } inline atUint32 BigUint32(atUint32& val) @@ -140,14 +140,14 @@ inline atUint32 BigUint32(atUint32& val) atInt32 ret = val; BigInt32(ret); val = ret; - + return val; } inline atInt64 LittleInt64(atInt64& val) { if (Athena::utility::isSystemBigEndian()) val = Athena::utility::swap64(val); - + return val; } inline atUint64 LittleUint64(atUint64& val) @@ -155,14 +155,14 @@ inline atUint64 LittleUint64(atUint64& val) atInt64 ret = val; LittleInt64(ret); val = ret; - + return val; } inline atInt64 BigInt64(atInt64& val) { if (!Athena::utility::isSystemBigEndian()) val = Athena::utility::swap64(val); - + return val; } inline atUint64 BigUint64(atUint64& val) @@ -170,7 +170,7 @@ inline atUint64 BigUint64(atUint64& val) atInt64 ret = val; BigInt64(ret); val = ret; - + return val; } @@ -178,33 +178,33 @@ inline float LittleFloat(float& val) { if (Athena::utility::isSystemBigEndian()) val = Athena::utility::swapFloat(val); - + return val; } inline float BigFloat(float& val) { if (!Athena::utility::isSystemBigEndian()) val = Athena::utility::swapFloat(val); - + return val; } inline double LittleDouble(double& val) { if (Athena::utility::isSystemBigEndian()) val = Athena::utility::swapDouble(val); - + return val; } inline double BigDouble(double& val) { if (!Athena::utility::isSystemBigEndian()) val = Athena::utility::swapDouble(val); - + return val; } -void fillRandom(atUint8 * rndArea, atUint64 count); -std::vector split(const std::string &s, char delim); +void fillRandom(atUint8* rndArea, atUint64 count); +std::vector split(const std::string& s, char delim); std::string join(const std::vector& elems, const std::string& delims); void tolower(std::string& str); void toupper(std::string& str); @@ -215,13 +215,13 @@ bool parseBool(const std::string& boolean, bool* valid = NULL); int countChar(const std::string& str, const char chr, int* lastOccur = NULL); // trim from start -std::string <rim(std::string &s); +std::string& ltrim(std::string& s); // trim from end -std::string &rtrim(std::string &s); +std::string& rtrim(std::string& s); // trim from both ends -std::string &trim(std::string &s); +std::string& trim(std::string& s); atUint64 fileSize(const std::string& filename); } // utility } // Athena diff --git a/include/Athena/WiiFile.hpp b/include/Athena/WiiFile.hpp index 3d8b4e2..dae03e1 100644 --- a/include/Athena/WiiFile.hpp +++ b/include/Athena/WiiFile.hpp @@ -51,9 +51,9 @@ public: OwnerWrite = 0x20, // Mask values; - OtherRW = (OtherRead|OtherWrite), //!< Mask to get the Other group permissions - GroupRW = (GroupRead|GroupWrite), - OwnerRW = (OwnerRead|OwnerWrite) + OtherRW = (OtherRead | OtherWrite), //!< Mask to get the Other group permissions + GroupRW = (GroupRead | GroupWrite), + OwnerRW = (OwnerRead | OwnerWrite) }; /*! @@ -173,7 +173,7 @@ public: void removeChild(WiiFile* file); WiiFile* parent(); - void setParent(WiiFile *parent); + void setParent(WiiFile* parent); atUint32 fileCount(); diff --git a/include/Athena/ZQuestFileReader.hpp b/include/Athena/ZQuestFileReader.hpp index efe1cd8..fdac002 100644 --- a/include/Athena/ZQuestFileReader.hpp +++ b/include/Athena/ZQuestFileReader.hpp @@ -33,7 +33,7 @@ class ZQuestFileReader : protected MemoryReader { MEMORYREADER_BASE(); -public: +public: /*! * \brief ZQuestFileReader * \param data diff --git a/include/LZ77/LZBase.hpp b/include/LZ77/LZBase.hpp index ad65935..68b6c79 100644 --- a/include/LZ77/LZBase.hpp +++ b/include/LZ77/LZBase.hpp @@ -7,12 +7,12 @@ class LZBase { public: - explicit LZBase(atInt32 minimumOffset=1,atInt32 slidingWindow=4096, atInt32 minimumMatch=3, atInt32 blockSize=8); + explicit LZBase(atInt32 minimumOffset = 1, atInt32 slidingWindow = 4096, atInt32 minimumMatch = 3, atInt32 blockSize = 8); virtual ~LZBase() {} - virtual atUint32 compress(const atUint8* src, atUint8** dest, atUint32 srcLength)=0; - virtual atUint32 decompress(const atUint8* src, atUint8** dest, atUint32 srcLength)=0; - + virtual atUint32 compress(const atUint8* src, atUint8** dest, atUint32 srcLength) = 0; + virtual atUint32 decompress(const atUint8* src, atUint8** dest, atUint32 srcLength) = 0; + void setSlidingWindow(atInt32 SlidingWindow); atInt32 slidingWindow(); void setReadAheadBuffer(atInt32 ReadAheadBuffer); @@ -23,15 +23,15 @@ public: atInt32 blockSize(); void setMinimumOffset(atUint32 minimumOffset); atUint32 minimumOffset(); - - + + private: - - atInt32 subMatch(const atUint8* str1,const uint8_t* str2,const atInt32 len); + + atInt32 subMatch(const atUint8* str1, const uint8_t* str2, const atInt32 len); LZLengthOffset windowSearch(atUint8* beginSearchPtr, atUint8* searchPosPtr, atUint8* endLABufferPtr, atUint8* startLBPtr); protected: LZLengthOffset search(atUint8* posPtr, atUint8* dataBegin, atUint8* dataEnd); - + atInt32 m_slidingWindow; atInt32 m_readAheadBuffer; atInt32 m_minMatch;//Minimum number of bytes that have to matched to go through with compression diff --git a/include/LZ77/LZLookupTable.hpp b/include/LZ77/LZLookupTable.hpp index f6c243a..8d24ae2 100644 --- a/include/LZ77/LZLookupTable.hpp +++ b/include/LZ77/LZLookupTable.hpp @@ -21,19 +21,19 @@ class LZLookupTable { public: LZLookupTable(); - LZLookupTable(atInt32 minimumMatch, atInt32 slidingWindow=4096, atInt32 lookAheadWindow=18); + LZLookupTable(atInt32 minimumMatch, atInt32 slidingWindow = 4096, atInt32 lookAheadWindow = 18); ~LZLookupTable(); LZLengthOffset search(atUint8* curPos, const atUint8* dataBegin, const atUint8* dataEnd); void setLookAheadWindow(atInt32 lookAheadWindow); private: typedef std::multimap, int32_t> LookupTable; - LookupTable table; + LookupTable table; atInt32 m_minimumMatch; atInt32 m_slidingWindow; atInt32 m_lookAheadWindow; std::vector m_buffer; - - + + }; #endif // LZLOOKUPTABLE_HPP diff --git a/include/LZ77/LZType10.hpp b/include/LZ77/LZType10.hpp index 2707801..130dd57 100644 --- a/include/LZ77/LZType10.hpp +++ b/include/LZ77/LZType10.hpp @@ -3,9 +3,10 @@ #include "LZBase.hpp" -class LZType10 : public LZBase { +class LZType10 : public LZBase +{ public: - explicit LZType10(atInt32 minimumOffset=1, atInt32 SlidingWindow=4096, atInt32 MinimumMatch=3, atInt32 BlockSize=8); + explicit LZType10(atInt32 minimumOffset = 1, atInt32 SlidingWindow = 4096, atInt32 MinimumMatch = 3, atInt32 BlockSize = 8); atUint32 compress(const atUint8* src, atUint8** dest, atUint32 srcLength); atUint32 decompress(const atUint8* src, atUint8** dst, atUint32 srcLen); }; diff --git a/include/LZ77/LZType11.hpp b/include/LZ77/LZType11.hpp index 08d8c0a..35cca28 100644 --- a/include/LZ77/LZType11.hpp +++ b/include/LZ77/LZType11.hpp @@ -4,12 +4,13 @@ #include "LZBase.hpp" -class LZType11 : public LZBase { +class LZType11 : public LZBase +{ public: - explicit LZType11(atInt32 MinimumOffset=1, atInt32 SlidingWindow=4096, atInt32 MinimumMatch=3, atInt32 BlockSize=8); - atUint32 compress(const atUint8 *src, atUint8** dest, atUint32 srcLength); - atUint32 decompress(const atUint8 *src, atUint8** dest, atUint32 srcLength); - + explicit LZType11(atInt32 MinimumOffset = 1, atInt32 SlidingWindow = 4096, atInt32 MinimumMatch = 3, atInt32 BlockSize = 8); + atUint32 compress(const atUint8* src, atUint8** dest, atUint32 srcLength); + atUint32 decompress(const atUint8* src, atUint8** dest, atUint32 srcLength); + }; #endif // LZTYPE11_HPP diff --git a/include/aes.h b/include/aes.h index d454e17..f3cd1ae 100644 --- a/include/aes.h +++ b/include/aes.h @@ -7,9 +7,9 @@ extern "C" { #endif -void aes_encrypt(atUint8 *iv, const atUint8 *inbuf, atUint8 *outbuf, atUint64 len); -void aes_decrypt(atUint8 *iv, const atUint8 *inbuf, atUint8 *outbuf, atUint64 len); -void aes_set_key(const atUint8 *key ); +void aes_encrypt(atUint8* iv, const atUint8* inbuf, atUint8* outbuf, atUint64 len); +void aes_decrypt(atUint8* iv, const atUint8* inbuf, atUint8* outbuf, atUint64 len); +void aes_set_key(const atUint8* key); #ifdef __cplusplus } diff --git a/include/bn.h b/include/bn.h index 851ced8..a5140d9 100644 --- a/include/bn.h +++ b/include/bn.h @@ -4,12 +4,12 @@ #ifndef __DOXYGEN_IGNORE__ #include "Athena/Types.hpp" -int bn_compare(atUint8 *a, atUint8 *b, atUint32 n); -void bn_sub_modulus(atUint8 *a, atUint8 *N, atUint32 n); -void bn_add(atUint8 *d, atUint8 *a, atUint8 *b, atUint8 *N, atUint32 n); -void bn_mul(atUint8 *d, atUint8 *a, atUint8 *b, atUint8 *N, atUint32 n); -void bn_exp(atUint8 *d, atUint8 *a, atUint8 *N, atUint32 n, atUint8 *e, atUint32 en); -void bn_inv(atUint8 *d, atUint8 *a, atUint8 *N, atUint32 n); +int bn_compare(atUint8* a, atUint8* b, atUint32 n); +void bn_sub_modulus(atUint8* a, atUint8* N, atUint32 n); +void bn_add(atUint8* d, atUint8* a, atUint8* b, atUint8* N, atUint32 n); +void bn_mul(atUint8* d, atUint8* a, atUint8* b, atUint8* N, atUint32 n); +void bn_exp(atUint8* d, atUint8* a, atUint8* N, atUint32 n, atUint8* e, atUint32 en); +void bn_inv(atUint8* d, atUint8* a, atUint8* N, atUint32 n); #endif // __DOXYGEN_IGNORE__ #endif // BN_H diff --git a/include/ec.h b/include/ec.h index 85cb494..19d4d2f 100644 --- a/include/ec.h +++ b/include/ec.h @@ -2,9 +2,9 @@ #define EC_H #include "Athena/Types.hpp" -bool check_ec ( atUint8 *ng, atUint8 *ap, atUint8 *sig, atUint8 *sig_hash ); -void make_ec_cert ( atUint8 *cert, atUint8 *sig, char *signer, char *name, atUint8 *priv, atUint32 key_id ); -void generate_ecdsa( atUint8 *R, atUint8 *S, atUint8 *k, atUint8 *hash ); +bool check_ec(atUint8* ng, atUint8* ap, atUint8* sig, atUint8* sig_hash); +void make_ec_cert(atUint8* cert, atUint8* sig, char* signer, char* name, atUint8* priv, atUint32 key_id); +void generate_ecdsa(atUint8* R, atUint8* S, atUint8* k, atUint8* hash); #endif // EC_H diff --git a/include/md5.h b/include/md5.h index 9cd3732..7f22fae 100644 --- a/include/md5.h +++ b/include/md5.h @@ -5,7 +5,7 @@ /* ========================================================================== ** * - * MD5.h + * MD5.h * * Copyright: * Copyright (C) 2003-2005 by Christopher R. Hertel @@ -54,15 +54,15 @@ * * There are three primary motivations for this particular implementation. * 1) Programmer's pride. I wanted to be able to say I'd done it, and I - * wanted to learn from the experience. + * wanted to learn from the experience. * 2) Portability. I wanted an implementation that I knew to be portable - * to a reasonable number of platforms. In particular, the algorithm is - * designed with little-endian platforms in mind, but I wanted an - * endian-agnostic implementation. + * to a reasonable number of platforms. In particular, the algorithm is + * designed with little-endian platforms in mind, but I wanted an + * endian-agnostic implementation. * 3) Compactness. While not an overriding goal, I thought it worth-while - * to see if I could reduce the overall size of the result. This is in - * keeping with my hopes that this library will be suitable for use in - * some embedded environments. + * to see if I could reduce the overall size of the result. This is in + * keeping with my hopes that this library will be suitable for use in + * some embedded environments. * Beyond that, cleanliness and clarity are always worth pursuing. * * As mentioned above, the code really only makes sense if you are familiar @@ -75,7 +75,7 @@ * * References: * IETF RFC 1321: The MD5 Message-Digest Algorithm - * Ron Rivest. IETF, April, 1992 + * Ron Rivest. IETF, April, 1992 * * ========================================================================== ** */ @@ -98,44 +98,44 @@ typedef struct auth_md5Ctx_ * Functions: */ -auth_md5Ctx *auth_md5InitCtx(auth_md5Ctx *ctx); +auth_md5Ctx* auth_md5InitCtx(auth_md5Ctx* ctx); /* ------------------------------------------------------------------------ ** * Initialize an MD5 context. * * Input: ctx - A pointer to the MD5 context structure to be initialized. - * Contexts are typically created thusly: - * ctx = (auth_md5Ctx *)malloc( sizeof(auth_md5Ctx) ); + * Contexts are typically created thusly: + * ctx = (auth_md5Ctx *)malloc( sizeof(auth_md5Ctx) ); * * Output: A pointer to the initialized context (same as ). * * Notes: The purpose of the context is to make it possible to generate - * an MD5 Message Digest in stages, rather than having to pass a - * single large block to a single MD5 function. The context - * structure keeps track of various bits of state information. + * an MD5 Message Digest in stages, rather than having to pass a + * single large block to a single MD5 function. The context + * structure keeps track of various bits of state information. * - * Once the context is initialized, the blocks of message data - * are passed to the function. Once the - * final bit of data has been handed to the - * context can be closed out by calling , - * which also calculates the final MD5 result. + * Once the context is initialized, the blocks of message data + * are passed to the function. Once the + * final bit of data has been handed to the + * context can be closed out by calling , + * which also calculates the final MD5 result. * - * Don't forget to free an allocated context structure when - * you've finished using it. + * Don't forget to free an allocated context structure when + * you've finished using it. * * See Also: , * * ------------------------------------------------------------------------ ** */ -auth_md5Ctx *auth_md5SumCtx(auth_md5Ctx *ctx, const unsigned char *src, const int len); +auth_md5Ctx* auth_md5SumCtx(auth_md5Ctx* ctx, const unsigned char* src, const int len); /* ------------------------------------------------------------------------ ** * Build an MD5 Message Digest within the given context. * * Input: ctx - Pointer to the context in which the MD5 sum is being - * built. - * src - A chunk of source data. This will be used to drive - * the MD5 algorithm. - * len - The number of bytes in . + * built. + * src - A chunk of source data. This will be used to drive + * the MD5 algorithm. + * len - The number of bytes in . * * Output: A pointer to the updated context (same as ). * @@ -144,94 +144,94 @@ auth_md5Ctx *auth_md5SumCtx(auth_md5Ctx *ctx, const unsigned char *src, const in * ------------------------------------------------------------------------ ** */ -auth_md5Ctx *auth_md5CloseCtx(auth_md5Ctx *ctx, unsigned char *dst); +auth_md5Ctx* auth_md5CloseCtx(auth_md5Ctx* ctx, unsigned char* dst); /* ------------------------------------------------------------------------ ** * Close an MD5 Message Digest context and generate the final MD5 sum. * * Input: ctx - Pointer to the context in which the MD5 sum is being - * built. - * dst - A pointer to at least 16 bytes of memory, which will - * receive the finished MD5 sum. + * built. + * dst - A pointer to at least 16 bytes of memory, which will + * receive the finished MD5 sum. * * Output: A pointer to the closed context (same as ). - * You might use this to free a malloc'd context structure. :) + * You might use this to free a malloc'd context structure. :) * * Notes: The context () is returned in an undefined state. - * It must be re-initialized before re-use. + * It must be re-initialized before re-use. * * See Also: , * * ------------------------------------------------------------------------ ** */ -unsigned char * MD5(unsigned char * hash, const unsigned char *src, const int len); +unsigned char* MD5(unsigned char* hash, const unsigned char* src, const int len); /* ------------------------------------------------------------------------ ** * Compute an MD5 message digest. * * Input: dst - Destination buffer into which the result will be written. - * Must be 16 bytes, minimum. - * src - Source data block to be MD5'd. - * len - The length, in bytes, of the source block. - * (Note that the length is given in bytes, not bits.) + * Must be 16 bytes, minimum. + * src - Source data block to be MD5'd. + * len - The length, in bytes, of the source block. + * (Note that the length is given in bytes, not bits.) * * Output: A pointer to , which will contain the calculated 16-byte - * MD5 message digest. + * MD5 message digest. * * Notes: This function is a shortcut. It takes a single input block. - * For more drawn-out operations, see . + * For more drawn-out operations, see . * - * This function is interface-compatible with the - * function in the MD4 module. + * This function is interface-compatible with the + * function in the MD4 module. * - * The MD5 algorithm is designed to work on data with an - * arbitrary *bit* length. Most implementations, this one - * included, handle the input data in byte-sized chunks. + * The MD5 algorithm is designed to work on data with an + * arbitrary *bit* length. Most implementations, this one + * included, handle the input data in byte-sized chunks. * - * The MD5 algorithm does much of its work using four-byte - * words, and so can be tuned for speed based on the endian-ness - * of the host. This implementation is intended to be - * endian-neutral, which may make it a teeny bit slower than - * others. ...maybe. + * The MD5 algorithm does much of its work using four-byte + * words, and so can be tuned for speed based on the endian-ness + * of the host. This implementation is intended to be + * endian-neutral, which may make it a teeny bit slower than + * others. ...maybe. * * See Also: * * ------------------------------------------------------------------------ ** */ -unsigned char * MD5fromFile(unsigned char *dst, const char *src); +unsigned char* MD5fromFile(unsigned char* dst, const char* src); /* ------------------------------------------------------------------------ ** * Compute an MD5 message digest. * * Input: dst - Destination buffer into which the result will be written. - * Must be 16 bytes, minimum. - * src - filepath to the file to be MD5'd. + * Must be 16 bytes, minimum. + * src - filepath to the file to be MD5'd. * * Output: A pointer to , which will contain the calculated 16-byte - * MD5 message digest. + * MD5 message digest. * * Notes: This function is a shortcut. It takes a single input block. - * For more drawn-out operations, see . + * For more drawn-out operations, see . * - * This function is interface-compatible with the - * function in the MD4 module. + * This function is interface-compatible with the + * function in the MD4 module. * - * The MD5 algorithm is designed to work on data with an - * arbitrary *bit* length. Most implementations, this one - * included, handle the input data in byte-sized chunks. + * The MD5 algorithm is designed to work on data with an + * arbitrary *bit* length. Most implementations, this one + * included, handle the input data in byte-sized chunks. * - * The MD5 algorithm does much of its work using four-byte - * words, and so can be tuned for speed based on the endian-ness - * of the host. This implementation is intended to be - * endian-neutral, which may make it a teeny bit slower than - * others. ...maybe. + * The MD5 algorithm does much of its work using four-byte + * words, and so can be tuned for speed based on the endian-ness + * of the host. This implementation is intended to be + * endian-neutral, which may make it a teeny bit slower than + * others. ...maybe. * * See Also: * * ------------------------------------------------------------------------ ** */ -const char * MD5ToString(const unsigned char *hash, char *dst); -unsigned char * StringToMD5(const char * hash, unsigned char * dst); +const char* MD5ToString(const unsigned char* hash, char* dst); +unsigned char* StringToMD5(const char* hash, unsigned char* dst); /* ========================================================================== */ diff --git a/include/sha1.h b/include/sha1.h index 7c6dc1a..480c317 100644 --- a/include/sha1.h +++ b/include/sha1.h @@ -29,15 +29,15 @@ typedef struct SHA1Context /* * Function Prototypes */ -void SHA1Reset(SHA1Context *); -int SHA1Result(SHA1Context *); -void SHA1Input( SHA1Context *, - const unsigned char *, - unsigned); +void SHA1Reset(SHA1Context*); +int SHA1Result(SHA1Context*); +void SHA1Input(SHA1Context*, + const unsigned char*, + unsigned); -atUint8* getSha1( atUint8 * stuff, atUint32 stuff_size ); +atUint8* getSha1(atUint8* stuff, atUint32 stuff_size); #ifdef __cplusplus } diff --git a/include/utf8/checked.h b/include/utf8/checked.h index 8465700..33ee3ec 100644 --- a/include/utf8/checked.h +++ b/include/utf8/checked.h @@ -34,11 +34,13 @@ DEALINGS IN THE SOFTWARE. namespace utf8 { // Base for the exceptions that may be thrown from the library -class exception : public ::std::exception { +class exception : public ::std::exception +{ }; // Exceptions that may be thrown from the library functions. -class invalid_code_point : public exception { +class invalid_code_point : public exception +{ uint32_t cp; public: invalid_code_point(uint32_t cp) : cp(cp) {} @@ -46,23 +48,26 @@ public: uint32_t code_point() const {return cp;} }; -class invalid_utf8 : public exception { +class invalid_utf8 : public exception +{ uint8_t u8; public: - invalid_utf8 (uint8_t u) : u8(u) {} + invalid_utf8(uint8_t u) : u8(u) {} virtual const char* what() const throw() { return "Invalid UTF-8"; } uint8_t utf8_octet() const {return u8;} }; -class invalid_utf16 : public exception { +class invalid_utf16 : public exception +{ uint16_t u16; public: - invalid_utf16 (uint16_t u) : u16(u) {} + invalid_utf16(uint16_t u) : u16(u) {} virtual const char* what() const throw() { return "Invalid UTF-16"; } uint16_t utf16_word() const {return u16;} }; -class not_enough_room : public exception { +class not_enough_room : public exception +{ public: virtual const char* what() const throw() { return "Not enough space"; } }; @@ -77,52 +82,66 @@ octet_iterator append(uint32_t cp, octet_iterator result) if (cp < 0x80) // one octet *(result++) = static_cast(cp); - else if (cp < 0x800) { // two octets + else if (cp < 0x800) // two octets + { *(result++) = static_cast((cp >> 6) | 0xc0); *(result++) = static_cast((cp & 0x3f) | 0x80); } - else if (cp < 0x10000) { // three octets + else if (cp < 0x10000) // three octets + { *(result++) = static_cast((cp >> 12) | 0xe0); *(result++) = static_cast(((cp >> 6) & 0x3f) | 0x80); *(result++) = static_cast((cp & 0x3f) | 0x80); } - else { // four octets + else // four octets + { *(result++) = static_cast((cp >> 18) | 0xf0); *(result++) = static_cast(((cp >> 12) & 0x3f) | 0x80); *(result++) = static_cast(((cp >> 6) & 0x3f) | 0x80); *(result++) = static_cast((cp & 0x3f) | 0x80); } + return result; } template output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, uint32_t replacement) { - while (start != end) { + while (start != end) + { octet_iterator sequence_start = start; internal::utf_error err_code = utf8::internal::validate_next(start, end); - switch (err_code) { + + switch (err_code) + { case internal::UTF8_OK : for (octet_iterator it = sequence_start; it != start; ++it) *out++ = *it; + break; + case internal::NOT_ENOUGH_ROOM: throw not_enough_room(); + case internal::INVALID_LEAD: - utf8::append (replacement, out); + utf8::append(replacement, out); ++start; break; + case internal::INCOMPLETE_SEQUENCE: case internal::OVERLONG_SEQUENCE: case internal::INVALID_CODE_POINT: - utf8::append (replacement, out); + utf8::append(replacement, out); ++start; + // just one replacement mark for the sequence while (start != end && utf8::internal::is_trail(*start)) ++start; + break; } } + return out; } @@ -138,18 +157,24 @@ uint32_t next(octet_iterator& it, octet_iterator end) { uint32_t cp = 0; internal::utf_error err_code = utf8::internal::validate_next(it, end, cp); - switch (err_code) { + + switch (err_code) + { case internal::UTF8_OK : break; + case internal::NOT_ENOUGH_ROOM : throw not_enough_room(); + case internal::INVALID_LEAD : case internal::INCOMPLETE_SEQUENCE : case internal::OVERLONG_SEQUENCE : throw invalid_utf8(*it); + case internal::INVALID_CODE_POINT : throw invalid_code_point(cp); } + return cp; } @@ -167,10 +192,12 @@ uint32_t prior(octet_iterator& it, octet_iterator start) throw not_enough_room(); octet_iterator end = it; + // Go back until we hit either a lead octet or start while (utf8::internal::is_trail(*(--it))) if (it == start) throw invalid_utf8(*it); // error - no lead byte in the sequence + return utf8::peek_next(it, end); } @@ -179,15 +206,17 @@ template uint32_t previous(octet_iterator& it, octet_iterator pass_start) { octet_iterator end = it; + while (utf8::internal::is_trail(*(--it))) if (it == pass_start) throw invalid_utf8(*it); // error - no lead byte in the sequence + octet_iterator temp = it; return utf8::next(temp, end); } template -void advance (octet_iterator& it, distance_type n, octet_iterator end) +void advance(octet_iterator& it, distance_type n, octet_iterator end) { for (distance_type i = 0; i < n; ++i) utf8::next(it, end); @@ -195,23 +224,30 @@ void advance (octet_iterator& it, distance_type n, octet_iterator end) template typename std::iterator_traits::difference_type -distance (octet_iterator first, octet_iterator last) +distance(octet_iterator first, octet_iterator last) { typename std::iterator_traits::difference_type dist; + for (dist = 0; first < last; ++dist) utf8::next(first, last); + return dist; } template -octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result) +octet_iterator utf16to8(u16bit_iterator start, u16bit_iterator end, octet_iterator result) { - while (start != end) { + while (start != end) + { uint32_t cp = utf8::internal::mask16(*start++); + // Take care of surrogate pairs first - if (utf8::internal::is_lead_surrogate(cp)) { - if (start != end) { + if (utf8::internal::is_lead_surrogate(cp)) + { + if (start != end) + { uint32_t trail_surrogate = utf8::internal::mask16(*start++); + if (utf8::internal::is_trail_surrogate(trail_surrogate)) cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET; else @@ -227,26 +263,31 @@ octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_itera result = utf8::append(cp, result); } + return result; } template -u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result) +u16bit_iterator utf8to16(octet_iterator start, octet_iterator end, u16bit_iterator result) { - while (start != end) { + while (start != end) + { uint32_t cp = utf8::next(start, end); - if (cp > 0xffff) { //make a surrogate pair + + if (cp > 0xffff) //make a surrogate pair + { *result++ = static_cast((cp >> 10) + internal::LEAD_OFFSET); *result++ = static_cast((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN); } else *result++ = static_cast(cp); } + return result; } template -octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result) +octet_iterator utf32to8(u32bit_iterator start, u32bit_iterator end, octet_iterator result) { while (start != end) result = utf8::append(*(start++), result); @@ -255,7 +296,7 @@ octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_itera } template -u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result) +u32bit_iterator utf8to32(octet_iterator start, octet_iterator end, u32bit_iterator result) { while (start != end) (*result++) = utf8::next(start, end); @@ -265,22 +306,23 @@ u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_itera // The iterator class template -class iterator : public std::iterator { +class iterator : public std::iterator +{ octet_iterator it; octet_iterator range_start; octet_iterator range_end; public: - iterator () {}; - explicit iterator (const octet_iterator& octet_it, - const octet_iterator& range_start, - const octet_iterator& range_end) : + iterator() {}; + explicit iterator(const octet_iterator& octet_it, + const octet_iterator& range_start, + const octet_iterator& range_end) : it(octet_it), range_start(range_start), range_end(range_end) { if (it < range_start || it > range_end) throw std::out_of_range("Invalid utf-8 iterator position"); } // the default "big three" are OK - octet_iterator base () const { return it; } + octet_iterator base() const { return it; } uint32_t operator * () const { octet_iterator temp = it; @@ -290,6 +332,7 @@ public: { if (range_start != rhs.range_start || range_end != rhs.range_end) throw std::logic_error("Comparing utf-8 iterators defined with different ranges"); + return (it == rhs.it); } bool operator != (const iterator& rhs) const diff --git a/include/utf8/core.h b/include/utf8/core.h index fb82101..f50a25c 100644 --- a/include/utf8/core.h +++ b/include/utf8/core.h @@ -100,6 +100,7 @@ inline typename std::iterator_traits::difference_type sequence_length(octet_iterator lead_it) { uint8_t lead = utf8::internal::mask8(*lead_it); + if (lead < 0x80) return 1; else if ((lead >> 5) == 0x6) @@ -115,15 +116,18 @@ sequence_length(octet_iterator lead_it) template inline bool is_overlong_sequence(uint32_t cp, octet_difference_type length) { - if (cp < 0x80) { + if (cp < 0x80) + { if (length != 1) return true; } - else if (cp < 0x800) { + else if (cp < 0x800) + { if (length != 2) return true; } - else if (cp < 0x10000) { + else if (cp < 0x10000) + { if (length != 3) return true; } @@ -170,7 +174,7 @@ utf_error get_sequence_2(octet_iterator& it, octet_iterator end, uint32_t& code_ UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) - code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f); + code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f); return UTF8_OK; } @@ -185,11 +189,11 @@ utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_ UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) - code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff); + code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff); UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) - code_point += (*it) & 0x3f; + code_point += (*it) & 0x3f; return UTF8_OK; } @@ -204,15 +208,15 @@ utf_error get_sequence_4(octet_iterator& it, octet_iterator end, uint32_t& code_ UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) - code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff); + code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff); UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) - code_point += (utf8::internal::mask8(*it) << 6) & 0xfff; + code_point += (utf8::internal::mask8(*it) << 6) & 0xfff; UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) - code_point += (*it) & 0x3f; + code_point += (*it) & 0x3f; return UTF8_OK; } @@ -233,27 +237,36 @@ utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_p // Get trail octets and calculate the code point utf_error err = UTF8_OK; - switch (length) { + + switch (length) + { case 0: return INVALID_LEAD; + case 1: err = utf8::internal::get_sequence_1(it, end, cp); break; + case 2: err = utf8::internal::get_sequence_2(it, end, cp); break; + case 3: err = utf8::internal::get_sequence_3(it, end, cp); break; + case 4: err = utf8::internal::get_sequence_4(it, end, cp); break; } - if (err == UTF8_OK) { + if (err == UTF8_OK) + { // Decoding succeeded. Now, security checks... - if (utf8::internal::is_code_point_valid(cp)) { - if (!utf8::internal::is_overlong_sequence(cp, length)){ + if (utf8::internal::is_code_point_valid(cp)) + { + if (!utf8::internal::is_overlong_sequence(cp, length)) + { // Passed! Return here. code_point = cp; ++it; @@ -272,7 +285,8 @@ utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_p } template -inline utf_error validate_next(octet_iterator& it, octet_iterator end) { +inline utf_error validate_next(octet_iterator& it, octet_iterator end) +{ uint32_t ignored; return utf8::internal::validate_next(it, end, ignored); } @@ -288,11 +302,15 @@ template octet_iterator find_invalid(octet_iterator start, octet_iterator end) { octet_iterator result = start; - while (result != end) { + + while (result != end) + { utf8::internal::utf_error err_code = utf8::internal::validate_next(result, end); + if (err_code != internal::UTF8_OK) return result; } + return result; } @@ -303,24 +321,24 @@ inline bool is_valid(octet_iterator start, octet_iterator end) } template -inline bool starts_with_bom (octet_iterator it, octet_iterator end) +inline bool starts_with_bom(octet_iterator it, octet_iterator end) { return ( - ((it != end) && (utf8::internal::mask8(*it++)) == bom[0]) && - ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) && - ((it != end) && (utf8::internal::mask8(*it)) == bom[2]) - ); + ((it != end) && (utf8::internal::mask8(*it++)) == bom[0]) && + ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) && + ((it != end) && (utf8::internal::mask8(*it)) == bom[2]) + ); } //Deprecated in release 2.3 template -inline bool is_bom (octet_iterator it) +inline bool is_bom(octet_iterator it) { return ( - (utf8::internal::mask8(*it++)) == bom[0] && - (utf8::internal::mask8(*it++)) == bom[1] && - (utf8::internal::mask8(*it)) == bom[2] - ); + (utf8::internal::mask8(*it++)) == bom[0] && + (utf8::internal::mask8(*it++)) == bom[1] && + (utf8::internal::mask8(*it)) == bom[2] + ); } } // namespace utf8 diff --git a/include/utf8/unchecked.h b/include/utf8/unchecked.h index 5acddd2..1270994 100644 --- a/include/utf8/unchecked.h +++ b/include/utf8/unchecked.h @@ -39,21 +39,25 @@ octet_iterator append(uint32_t cp, octet_iterator result) { if (cp < 0x80) // one octet *(result++) = static_cast(cp); - else if (cp < 0x800) { // two octets + else if (cp < 0x800) // two octets + { *(result++) = static_cast((cp >> 6) | 0xc0); *(result++) = static_cast((cp & 0x3f) | 0x80); } - else if (cp < 0x10000) { // three octets + else if (cp < 0x10000) // three octets + { *(result++) = static_cast((cp >> 12) | 0xe0); *(result++) = static_cast(((cp >> 6) & 0x3f) | 0x80); *(result++) = static_cast((cp & 0x3f) | 0x80); } - else { // four octets + else // four octets + { *(result++) = static_cast((cp >> 18) | 0xf0); - *(result++) = static_cast(((cp >> 12) & 0x3f)| 0x80); + *(result++) = static_cast(((cp >> 12) & 0x3f) | 0x80); *(result++) = static_cast(((cp >> 6) & 0x3f) | 0x80); *(result++) = static_cast((cp & 0x3f) | 0x80); } + return result; } @@ -62,19 +66,24 @@ uint32_t next(octet_iterator& it) { uint32_t cp = utf8::internal::mask8(*it); typename std::iterator_traits::difference_type length = utf8::internal::sequence_length(it); - switch (length) { + + switch (length) + { case 1: break; + case 2: it++; cp = ((cp << 6) & 0x7ff) + ((*it) & 0x3f); break; + case 3: ++it; cp = ((cp << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff); ++it; cp += (*it) & 0x3f; break; + case 4: ++it; cp = ((cp << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff); @@ -84,6 +93,7 @@ uint32_t next(octet_iterator& it) cp += (*it) & 0x3f; break; } + ++it; return cp; } @@ -98,6 +108,7 @@ template uint32_t prior(octet_iterator& it) { while (utf8::internal::is_trail(*(--it))) ; + octet_iterator temp = it; return utf8::unchecked::next(temp); } @@ -110,7 +121,7 @@ inline uint32_t previous(octet_iterator& it) } template -void advance (octet_iterator& it, distance_type n) +void advance(octet_iterator& it, distance_type n) { for (distance_type i = 0; i < n; ++i) utf8::unchecked::next(it); @@ -118,46 +129,57 @@ void advance (octet_iterator& it, distance_type n) template typename std::iterator_traits::difference_type -distance (octet_iterator first, octet_iterator last) +distance(octet_iterator first, octet_iterator last) { typename std::iterator_traits::difference_type dist; + for (dist = 0; first < last; ++dist) utf8::unchecked::next(first); + return dist; } template -octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result) +octet_iterator utf16to8(u16bit_iterator start, u16bit_iterator end, octet_iterator result) { - while (start != end) { + while (start != end) + { uint32_t cp = utf8::internal::mask16(*start++); + // Take care of surrogate pairs first - if (utf8::internal::is_lead_surrogate(cp)) { + if (utf8::internal::is_lead_surrogate(cp)) + { uint32_t trail_surrogate = utf8::internal::mask16(*start++); cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET; } + result = utf8::unchecked::append(cp, result); } + return result; } template -u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result) +u16bit_iterator utf8to16(octet_iterator start, octet_iterator end, u16bit_iterator result) { - while (start < end) { + while (start < end) + { uint32_t cp = utf8::unchecked::next(start); - if (cp > 0xffff) { //make a surrogate pair + + if (cp > 0xffff) //make a surrogate pair + { *result++ = static_cast((cp >> 10) + internal::LEAD_OFFSET); *result++ = static_cast((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN); } else *result++ = static_cast(cp); } + return result; } template -octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result) +octet_iterator utf32to8(u32bit_iterator start, u32bit_iterator end, octet_iterator result) { while (start != end) result = utf8::unchecked::append(*(start++), result); @@ -166,7 +188,7 @@ octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_itera } template -u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result) +u32bit_iterator utf8to32(octet_iterator start, octet_iterator end, u32bit_iterator result) { while (start < end) (*result++) = utf8::unchecked::next(start); @@ -176,13 +198,14 @@ u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_itera // The iterator class template -class iterator : public std::iterator { +class iterator : public std::iterator +{ octet_iterator it; public: - iterator () {}; - explicit iterator (const octet_iterator& octet_it): it(octet_it) {} + iterator() {}; + explicit iterator(const octet_iterator& octet_it): it(octet_it) {} // the default "big three" are OK - octet_iterator base () const { return it; } + octet_iterator base() const { return it; } uint32_t operator * () const { octet_iterator temp = it; @@ -221,7 +244,7 @@ public: }; // class iterator } // namespace utf8::unchecked -} // namespace utf8 +} // namespace utf8 #endif // header guard diff --git a/src/Athena/ALTTPFileReader.cpp b/src/Athena/ALTTPFileReader.cpp index 1e7d780..a96b1b3 100644 --- a/src/Athena/ALTTPFileReader.cpp +++ b/src/Athena/ALTTPFileReader.cpp @@ -53,13 +53,16 @@ ALTTPFile* ALTTPFileReader::readFile() std::vector dungeonDeaths; int j = 0x140; + while ((j--) > 0) { roomFlags.push_back(readRoomFlags()); } + quest->setRoomFlags(roomFlags); j = 0x0C0; + while ((j--) > 0) owEvents.push_back(readOverworldEvent()); @@ -108,6 +111,7 @@ ALTTPFile* ALTTPFileReader::readFile() quest->setMagicUsage((ALTTPMagicUsage&)*base::readBytes(sizeof(ALTTPMagicUsage))); j = 0x10; + while ((j--) > 0) { dungeonKeys.push_back(base::readByte()); @@ -125,7 +129,8 @@ ALTTPFile* ALTTPFileReader::readFile() quest->setTagAlong((ALTTPTagAlong)base::readByte()); j = 6; - while((j--) > 0) + + while ((j--) > 0) { oldmanFlags.push_back(base::readByte()); } @@ -134,7 +139,8 @@ ALTTPFile* ALTTPFileReader::readFile() quest->setBombFlag(base::readByte()); j = 5; - while((j--) > 0) + + while ((j--) > 0) { unknown1.push_back(base::readByte()); } @@ -142,7 +148,8 @@ ALTTPFile* ALTTPFileReader::readFile() quest->setUnknown1(unknown1); j = 6; - while((j--) > 0) + + while ((j--) > 0) { playerName.push_back(base::readUint16()); } @@ -151,10 +158,12 @@ ALTTPFile* ALTTPFileReader::readFile() quest->setValid((base::readUint16() == 0x55AA)); j = 0x0D; - while((j--) > 0) + + while ((j--) > 0) { dungeonDeaths.push_back(base::readUint16()); } + quest->setDungeonDeathTotals(dungeonDeaths); quest->setUnknown2(base::readUint16()); diff --git a/src/Athena/ALTTPFileWriter.cpp b/src/Athena/ALTTPFileWriter.cpp index 3786beb..97e0a07 100644 --- a/src/Athena/ALTTPFileWriter.cpp +++ b/src/Athena/ALTTPFileWriter.cpp @@ -38,6 +38,7 @@ ALTTPFileWriter::ALTTPFileWriter(const std::string& filename) void ALTTPFileWriter::writeFile(ALTTPFile* file) { ALTTPQuest* quest = NULL; + for (atUint32 i = 0; i < 6; i++) { if (i < 3) @@ -108,7 +109,7 @@ void ALTTPFileWriter::writeFile(ALTTPFile* file) base::seek(1); base::writeByte(quest->tagAlong()); - for(int j = 0; j < 6; j++) + for (int j = 0; j < 6; j++) base::writeByte(quest->oldManFlag(j)); base::writeByte(quest->bombFlag()); @@ -204,6 +205,7 @@ atUint16 ALTTPFileWriter::calculateChecksum(atUint32 game) // First we start at 0 atUint16 sum = 0; + for (atUint32 i = 0; i < 0x4FE; i += 2) // Add each word one by one sum += *(atUint16*)(m_data + (i + (0x500 * game))); diff --git a/src/Athena/ALTTPQuest.cpp b/src/Athena/ALTTPQuest.cpp index 082d9de..333650a 100644 --- a/src/Athena/ALTTPQuest.cpp +++ b/src/Athena/ALTTPQuest.cpp @@ -73,6 +73,7 @@ ALTTPOverworldEvent* ALTTPQuest::overworldEvent(atUint32 id) const { if (id > m_overworldEvents.size() - 1) THROW_INVALID_OPERATION_EXCEPTION_RETURN(nullptr, "index out of range"); + return m_overworldEvents[id]; } @@ -443,7 +444,7 @@ void ALTTPQuest::setUnknown1(atUint32 id, atUint8 val) atUint8 ALTTPQuest::unknown1(atUint32 id) { if (id > m_unknown1.size()) - THROW_INVALID_OPERATION_EXCEPTION_RETURN(0,"index out of range"); + THROW_INVALID_OPERATION_EXCEPTION_RETURN(0, "index out of range"); return m_unknown1[id]; } @@ -472,25 +473,30 @@ void ALTTPQuest::setPlayerName(const std::string& playerName) m_playerName.push_back((atUint16)0xA9); continue; } + char c = playerName[i]; + if (c >= 'A' && c <= 'P' && c != 'I') { m_playerName.push_back((atUint16)(c - 'A')); continue; } + if (c >= 'Q' && c <= 'Z') { std::cout << std::hex << (atUint16)((c - 'Q') + 0x20) << std::endl; m_playerName.push_back((atUint16)((c - 'Q') + 0x20)); continue; } + if (c >= 'a' && c <= 'f') { std::cout << std::hex << (atUint16)((c - 'a') + 0x2A) << std::endl; m_playerName.push_back((atUint16)((c - 'a') + 0x2A)); continue; } + if (c >= 'g' && c <= 'v') { if (c == 'k') @@ -498,38 +504,60 @@ void ALTTPQuest::setPlayerName(const std::string& playerName) m_playerName.push_back(0x42); continue; } + if (c == 'i') { m_playerName.push_back(0x44); continue; } + m_playerName.push_back((atUint16)((c - 'g') + 0x40)); continue; } + if (c >= 'w' && c <= 'z') { m_playerName.push_back((atUint16)((c - 'w') + 0x60)); continue; } + if (c >= '0' && c <= '9') { m_playerName.push_back((atUint16)((c - '0') + 0x64)); continue; } + if (c == '-' || c == '.') { m_playerName.push_back((atUint16)(c - '-') + 0x80); continue; } - switch(c) + switch (c) { - case '?' : m_playerName.push_back(0x6E); break; - case '!' : m_playerName.push_back(0x6F); break; - case ',' : m_playerName.push_back(0x82); break; - case '(' : m_playerName.push_back(0x85); break; - case ')' : m_playerName.push_back(0x86); break; - case 'I' : m_playerName.push_back(0xAF); break; + case '?' : + m_playerName.push_back(0x6E); + break; + + case '!' : + m_playerName.push_back(0x6F); + break; + + case ',' : + m_playerName.push_back(0x82); + break; + + case '(' : + m_playerName.push_back(0x85); + break; + + case ')' : + m_playerName.push_back(0x86); + break; + + case 'I' : + m_playerName.push_back(0xAF); + break; } } } @@ -550,16 +578,19 @@ std::string ALTTPQuest::playerNameToString() const ret.push_back((char)('A' + c)); continue; } + if (c >= 0x20 && c <= 0x29) { ret.push_back((char)('Q' + (c - 0x20))); continue; } + if (c >= 0x2A && c <= 0x2F) { ret.push_back((char)('a' + (c - 0x2A))); continue; } + if (c >= 0x40 && c <= 0x4F) { if (c == 0x42) @@ -567,39 +598,62 @@ std::string ALTTPQuest::playerNameToString() const ret.push_back('k'); continue; } + if (c == 0x44) { ret.push_back('i'); continue; } + ret.push_back((char)('g' + (c - 0x40))); } + if (c >= 0x60 && c <= 0x63) { ret.push_back((char)('w' + (c - 0x60))); continue; } + if (c >= 0x64 && c <= 0x6D) { ret.push_back((char)('0' + (c - 0x64))); continue; } + if (c == 0x80 || c == 0x81) { ret.push_back((char)('-' + (c - 0x80))); continue; } - switch(c) + switch (c) { - case 0x6E: ret.push_back('?'); break; - case 0x6F: ret.push_back('!'); break; - case 0x82: ret.push_back(','); break; - case 0x85: ret.push_back('('); break; - case 0x86: ret.push_back(')'); break; - case 0xAF: ret.push_back('I'); break; + case 0x6E: + ret.push_back('?'); + break; + + case 0x6F: + ret.push_back('!'); + break; + + case 0x82: + ret.push_back(','); + break; + + case 0x85: + ret.push_back('('); + break; + + case 0x86: + ret.push_back(')'); + break; + + case 0xAF: + ret.push_back('I'); + break; } } + return ret; } diff --git a/src/Athena/Checksums.cpp b/src/Athena/Checksums.cpp index dd3a2f8..d07f0a9 100644 --- a/src/Athena/Checksums.cpp +++ b/src/Athena/Checksums.cpp @@ -157,8 +157,10 @@ atUint16 crc16(const atUint8* data, atUint64 length) atInt32 pos = 0; atUint16 checksum = 0; + while (length--) checksum = (crc16Table[(checksum ^ data[pos++]) & 0xFF] ^ (checksum >> 8)); + return checksum; } diff --git a/src/Athena/Compression.cpp b/src/Athena/Compression.cpp index e69bcd5..7ae38fa 100644 --- a/src/Athena/Compression.cpp +++ b/src/Athena/Compression.cpp @@ -33,8 +33,8 @@ atInt32 decompressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint z_stream strm = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; strm.total_in = strm.avail_in = srcLen; strm.total_out = strm.avail_out = dstLen; - strm.next_in = (Bytef *) src; - strm.next_out = (Bytef *) dst; + strm.next_in = (Bytef*) src; + strm.next_out = (Bytef*) dst; strm.zalloc = Z_NULL; strm.zfree = Z_NULL; @@ -44,9 +44,11 @@ atInt32 decompressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint atInt32 ret = -1; err = inflateInit(&strm); //15 window bits, and the +32 tells zlib to to detect if using gzip or zlib + if (err == Z_OK) { err = inflate(&strm, Z_FINISH); + if (err == Z_STREAM_END) ret = strm.total_out; else @@ -66,13 +68,13 @@ atInt32 decompressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint return ret; } -atInt32 compressZlib(const atUint8 *src, atUint32 srcLen, atUint8* dst, atUint32 dstLen) +atInt32 compressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32 dstLen) { z_stream strm = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; strm.total_in = strm.avail_in = srcLen; strm.total_out = strm.avail_out = dstLen; - strm.next_in = (Bytef *) src; - strm.next_out = (Bytef *) dst; + strm.next_in = (Bytef*) src; + strm.next_out = (Bytef*) dst; strm.zalloc = Z_NULL; strm.zfree = Z_NULL; @@ -86,6 +88,7 @@ atInt32 compressZlib(const atUint8 *src, atUint32 srcLen, atUint8* dst, atUint32 if (err == Z_OK) { err = deflate(&strm, Z_FINISH); + if (err == Z_STREAM_END) ret = strm.total_out; else @@ -124,17 +127,18 @@ atUint32 yaz0Decode(const atUint8* src, atUint8* dst, atUint32 uncompressedSize) atInt32 validBitCount = 0; //number of valid bits left in "code" byte atUint8 currCodeByte; - while(dstPlace < uncompressedSize) + + while (dstPlace < uncompressedSize) { //read new "code" byte if the current one is used up - if(validBitCount == 0) + if (validBitCount == 0) { currCodeByte = src[srcPlace]; ++srcPlace; validBitCount = 8; } - if((currCodeByte & 0x80) != 0) + if ((currCodeByte & 0x80) != 0) { //straight copy dst[dstPlace] = src[srcPlace]; @@ -152,7 +156,8 @@ atUint32 yaz0Decode(const atUint8* src, atUint8* dst, atUint32 uncompressedSize) atUint32 copySource = dstPlace - (dist + 1); atUint32 numBytes = byte1 >> 4; - if(numBytes == 0) + + if (numBytes == 0) { numBytes = src[srcPlace] + 0x12; srcPlace++; @@ -161,7 +166,7 @@ atUint32 yaz0Decode(const atUint8* src, atUint8* dst, atUint32 uncompressedSize) numBytes += 2; //copy run - for(atUint32 i = 0; i < numBytes; ++i) + for (atUint32 i = 0; i < numBytes; ++i) { dst[dstPlace] = dst[copySource]; copySource++; @@ -171,7 +176,7 @@ atUint32 yaz0Decode(const atUint8* src, atUint8* dst, atUint32 uncompressedSize) //use next bit from "code" byte currCodeByte <<= 1; - validBitCount-=1; + validBitCount -= 1; } return dstPlace; @@ -183,8 +188,8 @@ typedef struct atUint32 srcPos, dstPos; } yaz0_Ret; -atUint32 simpleEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32 *pMatchPos); -atUint32 nintendoEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32 *pMatchPos); +atUint32 simpleEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32* pMatchPos); +atUint32 nintendoEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32* pMatchPos); atUint32 yaz0Encode(const atUint8* src, atUint32 srcSize, atUint8* data) { @@ -196,11 +201,13 @@ atUint32 yaz0Encode(const atUint8* src, atUint32 srcSize, atUint8* data) atUint32 validBitCount = 0; //number of valid bits left in "code" byte atUint8 currCodeByte = 0; - while(r.srcPos < srcSize) + + while (r.srcPos < srcSize) { atUint32 numBytes; atUint32 matchPos; numBytes = nintendoEnc(src, srcSize, r.srcPos, &matchPos); + if (numBytes < 3) { //straight copy @@ -222,9 +229,11 @@ atUint32 yaz0Encode(const atUint8* src, atUint32 srcSize, atUint8* data) byte2 = dist & 0xff; dst[r.dstPos++] = byte1; dst[r.dstPos++] = byte2; + // maximum runlength for 3 byte encoding - if (numBytes > 0xff+0x12) - numBytes = 0xff+0x12; + if (numBytes > 0xff + 0x12) + numBytes = 0xff + 0x12; + byte3 = numBytes - 0x12; dst[r.dstPos++] = byte3; } @@ -235,30 +244,38 @@ atUint32 yaz0Encode(const atUint8* src, atUint32 srcSize, atUint8* data) dst[r.dstPos++] = byte1; dst[r.dstPos++] = byte2; } + r.srcPos += numBytes; } + validBitCount++; + //write eight codes - if(validBitCount == 8) + if (validBitCount == 8) { data[pos] = currCodeByte; pos++; - for (i=0;i 0) + + if (validBitCount > 0) { data[pos] = currCodeByte; pos++; - for (i=0;i= 3) { - numBytes1 = simpleEnc(src, size, pos+1, &matchPos); + if (numBytes >= 3) + { + numBytes1 = simpleEnc(src, size, pos + 1, &matchPos); + // if the next position encoding is +2 longer than current position, choose it. // this does not guarantee the best optimization, but fairly good optimization with speed. - if (numBytes1 >= numBytes+2) { + if (numBytes1 >= numBytes + 2) + { numBytes = 1; prevFlag = 1; } } + return numBytes; } // simple and straight encoding scheme for Yaz0 -atUint32 simpleEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32 *pMatchPos) +atUint32 simpleEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32* pMatchPos) { int startPos = pos - 0x1000, j, i; atUint32 numBytes = 1; @@ -309,28 +332,34 @@ atUint32 simpleEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32 *pMat if (startPos < 0) startPos = 0; + for (i = startPos; i < pos; i++) { - for (j = 0; j < size-pos; j++) + for (j = 0; j < size - pos; j++) { - if (src[i+j] != src[j+pos]) + if (src[i + j] != src[j + pos]) break; } + if ((atUint32)j > numBytes) { numBytes = j; matchPos = i; } } + *pMatchPos = matchPos; + if (numBytes == 2) numBytes = 1; + return numBytes; } atUint32 decompressLZ77(const atUint8* src, atUint32 srcLen, atUint8** dst) { LZBase* lzCodec; + if (*(atUint8*)src == 0x11) lzCodec = new LZType11; else @@ -345,6 +374,7 @@ atUint32 decompressLZ77(const atUint8* src, atUint32 srcLen, atUint8** dst) atUint32 compressLZ77(const atUint8* src, atUint32 srcLen, atUint8** dst, bool extended) { LZBase* lzCodec; + if (extended) lzCodec = new LZType11; else diff --git a/src/Athena/FileReader.cpp b/src/Athena/FileReader.cpp index 86a90fb..28850e8 100644 --- a/src/Athena/FileReader.cpp +++ b/src/Athena/FileReader.cpp @@ -72,6 +72,7 @@ bool FileReader::isLittleEndian() const void FileReader::open() { m_fileHandle = fopen(m_filename.c_str(), "rb"); + if (!m_fileHandle) THROW_FILE_NOT_FOUND_EXCEPTION(m_filename); @@ -143,6 +144,7 @@ bool FileReader::readBit() if (!m_bitValid) { size_t size = fread(&m_currentByte, 1, 1, m_fileHandle); + if (size != sizeof(atUint8)) THROW_IO_EXCEPTION_RETURN(false, "Error reading from file."); @@ -152,6 +154,7 @@ bool FileReader::readBit() atUint8 flag = (1 << m_bitShift); m_bitShift++; + if (m_bitShift > 7) m_bitValid = false; @@ -173,6 +176,7 @@ atInt8 FileReader::readByte() { if (!isOpen()) THROW_INVALID_OPERATION_EXCEPTION_RETURN(0, "File not open for reading"); + return (atInt8)readUByte(); } @@ -180,16 +184,18 @@ atUint8* FileReader::readUBytes(atUint64 len) { if (!isOpen()) THROW_INVALID_OPERATION_EXCEPTION_RETURN(nullptr, "File not open for reading"); + m_bitValid = false; atUint8* val = new atUint8[len]; fread(val, 1, len, m_fileHandle); return val; } - + atUint64 FileReader::readUBytesToBuf(void* buf, atUint64 len) { if (!isOpen()) THROW_INVALID_OPERATION_EXCEPTION_RETURN(0, "File not open for reading"); + m_bitValid = false; return fread(buf, 1, len, m_fileHandle); } @@ -198,6 +204,7 @@ atInt8* FileReader::readBytes(atUint64 len) { if (!isOpen()) THROW_INVALID_OPERATION_EXCEPTION_RETURN(nullptr, "File not open for reading"); + return (atInt8*)readUBytes(len); } @@ -314,6 +321,7 @@ std::string FileReader::readString(atInt32 maxlen) atUint8 chr = readByte(); atInt32 i = 0; + while (chr != 0) { if (maxlen >= 0 && i >= maxlen - 1) @@ -336,20 +344,24 @@ std::string FileReader::readUnicode(atInt32 maxlen) std::vector tmp; atInt32 i = 0; - for(;;) + + for (;;) { if (maxlen >= 0 && i >= maxlen - 1) break; short chr = readUint16(); + if (chr) tmp.push_back(chr); else break; + i++; }; utf8::utf16to8(tmp.begin(), tmp.end(), back_inserter(ret)); + return ret; } diff --git a/src/Athena/FileWriter.cpp b/src/Athena/FileWriter.cpp index 438db10..b0fbb64 100644 --- a/src/Athena/FileWriter.cpp +++ b/src/Athena/FileWriter.cpp @@ -71,6 +71,7 @@ bool FileWriter::isLittleEndian() const void FileWriter::open() { m_fileHandle = fopen(m_filename.c_str(), "w+b"); + if (!m_fileHandle) THROW_FILE_NOT_FOUND_EXCEPTION(m_filename); @@ -141,6 +142,7 @@ void FileWriter::writeBit(bool val) m_bitValid = false; fseeko64(m_fileHandle, m_bytePosition, (int)SeekOrigin::Begin); + if (fwrite(&m_currentByte, 1, 1, m_fileHandle) != sizeof(atInt8)) THROW_IO_EXCEPTION("Unable to data to file"); } @@ -149,6 +151,7 @@ void FileWriter::seekBit(int bit) { if (bit < 0 || bit > 7) THROW_INVALID_OPERATION_EXCEPTION("bit must be >= 0 and <= 7"); + m_bitShift = bit; m_bitValid = true; } @@ -283,8 +286,10 @@ void FileWriter::writeString(const std::string& val) m_bitValid = false; char term = '\0'; + if (fwrite(val.c_str(), 1, val.length(), m_fileHandle) != val.length()) THROW_IO_EXCEPTION("Unable to write to stream"); + if (fwrite(&term, 1, 1, m_fileHandle) != 1) THROW_IO_EXCEPTION("Unable to write to stream"); } @@ -311,6 +316,7 @@ void FileWriter::fill(atInt8 byte, atUint64 len) { if (!isOpen()) THROW_INVALID_OPERATION_EXCEPTION("File not open for writing"); + fwrite(&byte, 1, len, m_fileHandle); } diff --git a/src/Athena/Global.cpp b/src/Athena/Global.cpp index 80ab8b5..b100581 100644 --- a/src/Athena/Global.cpp +++ b/src/Athena/Global.cpp @@ -17,33 +17,38 @@ std::ostream& operator<<(std::ostream& os, const Athena::SeekOrigin& origin) { - switch(origin) + switch (origin) { case Athena::SeekOrigin::Begin: os << "Begin"; break; + case Athena::SeekOrigin::Current: os << "Current"; break; + case Athena::SeekOrigin::End: os << "End"; break; } + return os; } std::ostream& operator<<(std::ostream& os, const Athena::Endian& endian) { - switch(endian) + switch (endian) { case Athena::Endian::LittleEndian: os << "LittleEndian"; break; + case Athena::Endian::BigEndian: os << "BigEndian"; break; } + return os; } diff --git a/src/Athena/MCFile.cpp b/src/Athena/MCFile.cpp index 5363a08..8839986 100644 --- a/src/Athena/MCFile.cpp +++ b/src/Athena/MCFile.cpp @@ -30,7 +30,7 @@ atUint8* reverse(atUint8* data, atUint32 length) atUint32 a = 0; atUint32 swap; - for (;a<--length; a++) + for (; a < --length; a++) { swap = data[a]; data[a] = data[length]; diff --git a/src/Athena/MCFileWriter.cpp b/src/Athena/MCFileWriter.cpp index d516283..9eb89c9 100644 --- a/src/Athena/MCFileWriter.cpp +++ b/src/Athena/MCFileWriter.cpp @@ -41,14 +41,14 @@ atUint16 MCFileWriter::calculateSlotChecksum(atUint32 game) first = (first + second) & 0xFFFF; atUint16 result = first << 16; - second = ~first&0xFFFF; + second = ~first & 0xFFFF; second += 1; result += second; return result; } -atUint16 MCFileWriter::calculateChecksum(atUint8 *data, atUint32 length) +atUint16 MCFileWriter::calculateChecksum(atUint8* data, atUint32 length) { atUint16 sum = 0; int i = length; diff --git a/src/Athena/MemoryReader.cpp b/src/Athena/MemoryReader.cpp index 9e1e936..e22d3a5 100644 --- a/src/Athena/MemoryReader.cpp +++ b/src/Athena/MemoryReader.cpp @@ -43,6 +43,7 @@ MemoryReader::MemoryReader(const atUint8* data, atUint64 length) { if (!data) THROW_INVALID_DATA_EXCEPTION("data cannot be NULL"); + if (length == 0) THROW_INVALID_OPERATION_EXCEPTION("length cannot be 0"); @@ -97,21 +98,26 @@ void MemoryReader::seek(atInt64 position, SeekOrigin origin) { switch (origin) { - case SeekOrigin::Begin: - if ((position < 0 || (atInt64)position > (atInt64)m_length)) - THROW_IO_EXCEPTION("Position %0.8X outside stream bounds ", position); - m_position = position; - break; - case SeekOrigin::Current: - if ((((atInt64)m_position + position) < 0 || (m_position + position) > m_length)) - THROW_IO_EXCEPTION("Position %0.8X outside stream bounds ", position); - m_position += position; - break; - case SeekOrigin::End: - if ((((atInt64)m_length - position < 0) || (m_length - position) > m_length)) - THROW_IO_EXCEPTION("Position %0.8X outside stream bounds ", position); - m_position = m_length - position; - break; + case SeekOrigin::Begin: + if ((position < 0 || (atInt64)position > (atInt64)m_length)) + THROW_IO_EXCEPTION("Position %0.8X outside stream bounds ", position); + + m_position = position; + break; + + case SeekOrigin::Current: + if ((((atInt64)m_position + position) < 0 || (m_position + position) > m_length)) + THROW_IO_EXCEPTION("Position %0.8X outside stream bounds ", position); + + m_position += position; + break; + + case SeekOrigin::End: + if ((((atInt64)m_length - position < 0) || (m_length - position) > m_length)) + THROW_IO_EXCEPTION("Position %0.8X outside stream bounds ", position); + + m_position = m_length - position; + break; } } @@ -174,12 +180,14 @@ bool MemoryReader::readBit() { if (!m_data) loadData(); + if (m_position > m_length) THROW_IO_EXCEPTION_RETURN(false, "Position %0.8X outside stream bounds ", m_position); bool ret = (*(atUint8*)(m_data + m_position) & (1 << m_bitPosition)) != 0; m_bitPosition++; + if (m_bitPosition > 7) { m_bitPosition = 0; @@ -199,6 +207,7 @@ atInt8 MemoryReader::readByte() m_bitPosition = 0; m_position += sizeof(atUint8); } + if (m_position + 1 > m_length) THROW_IO_EXCEPTION_RETURN(0, "Position %0.8X outside stream bounds ", m_position); @@ -218,6 +227,7 @@ atUint8 MemoryReader::readUByte() m_bitPosition = 0; m_position += sizeof(atUint8); } + if (m_position + 1 > m_length) THROW_IO_EXCEPTION_RETURN(0, "Position %0.8X outside stream bounds ", m_position); @@ -245,26 +255,26 @@ atUint8* MemoryReader::readUBytes(atUint64 length) m_position += length; return ret; } - + atUint64 MemoryReader::readUBytesToBuf(void* buf, atUint64 length) { if (!m_data) loadData(); - + if (m_bitPosition > 0) { m_bitPosition = 0; m_position += sizeof(atUint8); } - + if (m_position + length > m_length) THROW_IO_EXCEPTION_RETURN(0, "Position %0.8X outside stream bounds ", m_position); - + memcpy(buf, (const atUint8*)(m_data + m_position), length); m_position += length; return length; } - + atInt16 MemoryReader::readInt16() { if (!m_data) @@ -278,6 +288,7 @@ atInt16 MemoryReader::readInt16() if (m_position + sizeof(atInt16) > m_length) THROW_IO_EXCEPTION_RETURN(0, "Position %0.8X outside stream bounds ", m_position); + atInt16 ret = *(atInt16*)(m_data + m_position); m_position += sizeof(atInt16); @@ -307,6 +318,7 @@ atInt32 MemoryReader::readInt32() if (m_position + sizeof(atInt32) > m_length) THROW_IO_EXCEPTION_RETURN(0, "Position %0.8X outside stream bounds ", m_position); + atInt32 ret = *(atInt32*)(m_data + m_position); m_position += 4; @@ -333,6 +345,7 @@ atInt64 MemoryReader::readInt64() m_bitPosition = 0; m_position += sizeof(atUint8); } + if (m_position + sizeof(atInt64) > m_length) THROW_IO_EXCEPTION_RETURN(0, "Position %0.8X outside stream bounds ", m_position); @@ -362,6 +375,7 @@ float MemoryReader::readFloat() m_bitPosition = 0; m_position += sizeof(atUint8); } + if (m_position + sizeof(float) > m_length) THROW_IO_EXCEPTION_RETURN(0, "Position %0.8X outside stream bounds ", m_position); @@ -386,6 +400,7 @@ double MemoryReader::readDouble() m_bitPosition = 0; m_position += sizeof(atUint8); } + if (m_position + sizeof(double) > m_length) THROW_IO_EXCEPTION_RETURN(0, "Position %0.8X outside stream bounds ", m_position); @@ -396,6 +411,7 @@ double MemoryReader::readDouble() utility::BigDouble(ret); else utility::LittleDouble(ret); + return ret; } @@ -409,6 +425,7 @@ bool MemoryReader::readBool() m_bitPosition = 0; m_position += sizeof(atUint8); } + if (m_position + sizeof(bool) > m_length) THROW_IO_EXCEPTION_RETURN(false, "Position %0.8X outside stream bounds ", m_position); @@ -421,18 +438,21 @@ std::string MemoryReader::readUnicode(atInt32 maxlen) { if (!m_data) loadData(); + std::string ret; std::vector tmp; atUint16 chr = readUint16(); atInt32 i = 0; - for(;;) + + for (;;) { if (maxlen >= 0 && i >= maxlen - 1) break; if (!chr) break; + tmp.push_back(chr); chr = readUint16(); i++; @@ -448,6 +468,7 @@ std::string MemoryReader::readString(atInt32 maxlen) atUint8 chr = readByte(); atInt32 i = 0; + while (chr != 0) { if (maxlen >= 0 && i >= maxlen - 1) @@ -474,6 +495,7 @@ void MemoryReader::loadData() if (!in) THROW_FILE_NOT_FOUND_EXCEPTION(m_filepath); + rewind(in); length = utility::fileSize(m_filepath); @@ -485,6 +507,7 @@ void MemoryReader::loadData() atUint64 done = 0; atUint64 blocksize = BLOCKSZ; + do { if (blocksize > length - done) @@ -500,9 +523,10 @@ void MemoryReader::loadData() done += ret; if (m_progressCallback) - m_progressCallback((int)((float)(done* 100.f)/length)); + m_progressCallback((int)((float)(done * 100.f) / length)); - } while (done < length); + } + while (done < length); fclose(in); m_length = length; diff --git a/src/Athena/MemoryWriter.cpp b/src/Athena/MemoryWriter.cpp index c7e3bb0..e4dd14b 100644 --- a/src/Athena/MemoryWriter.cpp +++ b/src/Athena/MemoryWriter.cpp @@ -106,8 +106,10 @@ void MemoryWriter::seek(atInt64 position, SeekOrigin origin) if ((atUint64)position > m_length) resize(position); + m_position = position; break; + case SeekOrigin::Current: if ((((atInt64)m_position + position) < 0)) THROW_IO_EXCEPTION("Position outside stream bounds"); @@ -117,12 +119,14 @@ void MemoryWriter::seek(atInt64 position, SeekOrigin origin) m_position += position; break; + case SeekOrigin::End: if (((atInt64)m_length - position) < 0) THROW_IO_EXCEPTION("Position outside stream bounds"); if ((atUint64)position > m_length) resize(position); + m_position = m_length - position; break; } @@ -185,11 +189,13 @@ void MemoryWriter::save(const std::string& filename) m_filepath = filename; FILE* out = fopen(m_filepath.c_str(), "wb"); + if (!out) THROW_FILE_NOT_FOUND_EXCEPTION(m_filepath); atUint64 done = 0; atUint64 blocksize = BLOCKSZ; + do { if (blocksize > m_length - done) @@ -203,7 +209,8 @@ void MemoryWriter::save(const std::string& filename) break; done += blocksize; - }while (done < m_length); + } + while (done < m_length); fclose(out); } @@ -228,7 +235,9 @@ void MemoryWriter::writeBit(bool val) *(atUint8*)(m_data + m_position) |= (1 << m_bitPosition); else *(atUint8*)(m_data + m_position) &= ~(1 << m_bitPosition); + m_bitPosition++; + if (m_bitPosition > 7) { m_bitPosition = 0; @@ -246,6 +255,7 @@ void MemoryWriter::writeUByte(atUint8 val) m_bitPosition = 0; m_position += sizeof(atUint8); } + if (m_position + 1 > m_length) resize(m_position + 1); @@ -272,6 +282,7 @@ void MemoryWriter::writeUBytes(atUint8* data, atUint64 length) if (!data) THROW_INVALID_DATA_EXCEPTION("data cannnot be NULL"); + if (m_position + length > m_length) resize(m_position + length); @@ -413,7 +424,7 @@ void MemoryWriter::writeDouble(double val) else utility::LittleDouble(val); - *(double*)(m_data + m_position)= val; + *(double*)(m_data + m_position) = val; m_position += sizeof(double); } @@ -445,6 +456,7 @@ void MemoryWriter::writeUnicode(const std::string& str) if (chr != 0xFEFF) writeInt16(chr); } + writeInt16(0); } @@ -453,9 +465,11 @@ void MemoryWriter::writeString(const std::string& str) for (atUint8 c : str) { writeUByte(c); + if (c == '\0') break; } + writeUByte(0); } diff --git a/src/Athena/PHYSFSFileReader.cpp b/src/Athena/PHYSFSFileReader.cpp index f61b256..2d6e58a 100644 --- a/src/Athena/PHYSFSFileReader.cpp +++ b/src/Athena/PHYSFSFileReader.cpp @@ -42,23 +42,29 @@ bool PHYSFSFileReader::isOpen() const void PHYSFSFileReader::seek(atInt64 position, SeekOrigin origin) { atInt64 curPos = PHYSFS_tell(m_handle); + switch (origin) { - case SeekOrigin::Begin: - if ((position < 0 || (atInt64)position > (atInt64)m_length)) - THROW_IO_EXCEPTION("Position %0.16X outside stream bounds ", position); - PHYSFS_seek(m_handle, position); - break; - case SeekOrigin::Current: - if ((((atInt64)curPos + position) < 0 || (curPos + position) > m_length)) - THROW_IO_EXCEPTION("Position %0.16X outside stream bounds ", position); - PHYSFS_seek(m_handle, curPos + position); - break; - case SeekOrigin::End: - if ((((atInt64)m_length - position < 0) || (m_length - position) > m_length)) - THROW_IO_EXCEPTION("Position %0.16X outside stream bounds ", position); - PHYSFS_seek(m_handle, m_length - position); - break; + case SeekOrigin::Begin: + if ((position < 0 || (atInt64)position > (atInt64)m_length)) + THROW_IO_EXCEPTION("Position %0.16X outside stream bounds ", position); + + PHYSFS_seek(m_handle, position); + break; + + case SeekOrigin::Current: + if ((((atInt64)curPos + position) < 0 || (curPos + position) > m_length)) + THROW_IO_EXCEPTION("Position %0.16X outside stream bounds ", position); + + PHYSFS_seek(m_handle, curPos + position); + break; + + case SeekOrigin::End: + if ((((atInt64)m_length - position < 0) || (m_length - position) > m_length)) + THROW_IO_EXCEPTION("Position %0.16X outside stream bounds ", position); + + PHYSFS_seek(m_handle, m_length - position); + break; } } @@ -80,13 +86,15 @@ atInt8 PHYSFSFileReader::readByte() atUint8* PHYSFSFileReader::readUBytes(atUint64 length) { atUint8* data = new atUint8[length]; + if (PHYSFS_read(m_handle, data, 1, length) == length) return data; + delete[] data; THROW_IO_EXCEPTION("Position outside stream bounds"); } -atInt8*PHYSFSFileReader::readBytes(atUint64 length) +atInt8* PHYSFSFileReader::readBytes(atUint64 length) { return (atInt8*)readUBytes(length); } diff --git a/src/Athena/SkywardSwordFile.cpp b/src/Athena/SkywardSwordFile.cpp index 5659e91..5cdebb9 100644 --- a/src/Athena/SkywardSwordFile.cpp +++ b/src/Athena/SkywardSwordFile.cpp @@ -36,7 +36,7 @@ SkywardSwordFile::~SkywardSwordFile() { } -void SkywardSwordFile::addQuest(Athena::SkywardSwordQuest *q) +void SkywardSwordFile::addQuest(Athena::SkywardSwordQuest* q) { // Do not allow more than 3 quests if (m_quests.size() >= 3) @@ -45,7 +45,7 @@ void SkywardSwordFile::addQuest(Athena::SkywardSwordQuest *q) m_quests.push_back(q); } -SkywardSwordQuest *SkywardSwordFile::quest(atUint32 id) +SkywardSwordQuest* SkywardSwordFile::quest(atUint32 id) { if (id > m_quests.size() - 1) THROW_INVALID_OPERATION_EXCEPTION_RETURN(nullptr, "index out of range"); diff --git a/src/Athena/SkywardSwordFileReader.cpp b/src/Athena/SkywardSwordFileReader.cpp index b9cc215..efa9ff2 100644 --- a/src/Athena/SkywardSwordFileReader.cpp +++ b/src/Athena/SkywardSwordFileReader.cpp @@ -41,6 +41,7 @@ SkywardSwordFileReader::SkywardSwordFileReader(const std::string& filename) SkywardSwordFile* SkywardSwordFileReader::read() { SkywardSwordFile* file = NULL; + try { if (base::length() != 0xFBE0) @@ -49,17 +50,18 @@ SkywardSwordFile* SkywardSwordFileReader::read() atUint32 magic = base::readUint32(); if (magic != SkywardSwordFile::USMagic && magic != SkywardSwordFile::JAMagic && magic != SkywardSwordFile::EUMagic) - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Not a valid Skyward Sword save file"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Not a valid Skyward Sword save file"); base::seek(0x01C, SeekOrigin::Begin); atUint32 headerSize = base::readUint32(); // Seems to be (headerSize - 1) if (headerSize != 0x1D) - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Invalid header size, Corrupted data?"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Invalid header size, Corrupted data?"); // Time to read in each slot file = new SkywardSwordFile; - file->setRegion((magic == SkywardSwordFile::USMagic ? Region::NTSC: (magic == SkywardSwordFile::JAMagic ? Region::NTSCJ: Region::PAL))); + file->setRegion((magic == SkywardSwordFile::USMagic ? Region::NTSC : (magic == SkywardSwordFile::JAMagic ? Region::NTSCJ : Region::PAL))); + for (int i = 0; i < 3; i++) { SkywardSwordQuest* q = new SkywardSwordQuest((atUint8*)base::readBytes(0x53C0), 0x53C0); @@ -71,7 +73,7 @@ SkywardSwordFile* SkywardSwordFileReader::read() file->addQuest(q); } } - catch(...) + catch (...) { delete file; file = NULL; diff --git a/src/Athena/SkywardSwordFileWriter.cpp b/src/Athena/SkywardSwordFileWriter.cpp index f6fccb7..be9a716 100644 --- a/src/Athena/SkywardSwordFileWriter.cpp +++ b/src/Athena/SkywardSwordFileWriter.cpp @@ -25,25 +25,25 @@ namespace Athena namespace io { -SkywardSwordFileWriter::SkywardSwordFileWriter(atUint8 *data, atUint64 len) +SkywardSwordFileWriter::SkywardSwordFileWriter(atUint8* data, atUint64 len) : base(data, len) { base::setEndian(Endian::BigEndian); } -SkywardSwordFileWriter::SkywardSwordFileWriter(const std::string &filename) +SkywardSwordFileWriter::SkywardSwordFileWriter(const std::string& filename) : base(filename) { base::setEndian(Endian::BigEndian); } -void SkywardSwordFileWriter::write(SkywardSwordFile *file) +void SkywardSwordFileWriter::write(SkywardSwordFile* file) { if (!file) THROW_INVALID_OPERATION_EXCEPTION("file cannot be NULL"); atUint32 magic = (file->region() == Region::NTSC ? SkywardSwordFile::USMagic : - (file->region() == Region::NTSCJ ? SkywardSwordFile::JAMagic : SkywardSwordFile::EUMagic)); + (file->region() == Region::NTSCJ ? SkywardSwordFile::JAMagic : SkywardSwordFile::EUMagic)); base::writeUint32(magic); base::seek(0x1C, SeekOrigin::Begin); @@ -51,10 +51,12 @@ void SkywardSwordFileWriter::write(SkywardSwordFile *file) std::vector quests = file->questList(); int i = 0; + for (SkywardSwordQuest* q : quests) { if (q->length() != 0x53C0) THROW_INVALID_DATA_EXCEPTION("q->data() not 0x53C0 bytes in length"); + // Update the checksums q->fixChecksums(); // Write the save data diff --git a/src/Athena/SkywardSwordQuest.cpp b/src/Athena/SkywardSwordQuest.cpp index 68dac12..a76f0b0 100644 --- a/src/Athena/SkywardSwordQuest.cpp +++ b/src/Athena/SkywardSwordQuest.cpp @@ -52,13 +52,13 @@ union AmmoValues atUint32 value; }; -SkywardSwordQuest::SkywardSwordQuest(atUint8 *data, atUint32 len) +SkywardSwordQuest::SkywardSwordQuest(atUint8* data, atUint32 len) : ZQuestFile(ZQuestFile::SS, Endian::BigEndian, data, len), m_skipData(nullptr) { } -void SkywardSwordQuest::setSkipData(const atUint8 *data) +void SkywardSwordQuest::setSkipData(const atUint8* data) { if (m_skipData) { @@ -69,7 +69,7 @@ void SkywardSwordQuest::setSkipData(const atUint8 *data) m_skipData = (atUint8*)data; } -atUint8 *SkywardSwordQuest::skipData() const +atUint8* SkywardSwordQuest::skipData() const { return m_skipData; } @@ -85,6 +85,7 @@ void SkywardSwordQuest::setPlayerName(const std::string& name) for (atUint32 i = 0; i < 8; i++) { atUint16& c = *(atUint16*)(m_data + priv::NAME_OFFSET + (i * 2)); + if (i >= val.size()) { c = 0; @@ -99,9 +100,11 @@ void SkywardSwordQuest::setPlayerName(const std::string& name) std::string SkywardSwordQuest::playerName() const { std::vector val; + for (atUint32 i = 0; i < 8; i++) { atUint16 c = *(atUint16*)(m_data + priv::NAME_OFFSET + (i * 2)); + if (c == 0) break; @@ -132,14 +135,16 @@ void SkywardSwordQuest::setAmmoCount(SkywardSwordQuest::AmmoType type, atUint32 AmmoValues& values = *(AmmoValues*)(m_data + priv::AMMO_COUNT_OFFSET); utility::BigUint32(values.value); - switch(type) + switch (type) { case Arrows: values.arrows = count; break; + case Bombs: values.bombs = count; break; + case Seeds: values.seeds = count; break; @@ -153,12 +158,19 @@ atUint32 SkywardSwordQuest::ammoCount(AmmoType type) AmmoValues values = *(AmmoValues*)(m_data + priv::AMMO_COUNT_OFFSET); utility::BigUint32(values.value); - switch(type) + switch (type) { - case Arrows: return values.arrows; - case Bombs: return values.bombs; - case Seeds: return values.seeds; - default: return 0; + case Arrows: + return values.arrows; + + case Bombs: + return values.bombs; + + case Seeds: + return values.seeds; + + default: + return 0; } } diff --git a/src/Athena/Sprite.cpp b/src/Athena/Sprite.cpp index ddd380d..df05171 100644 --- a/src/Athena/Sprite.cpp +++ b/src/Athena/Sprite.cpp @@ -48,9 +48,10 @@ Sprite::Sprite(SpriteFile* root, const std::string& name) Sprite::~Sprite() { #ifndef ATHENA_USE_QT + for (SpriteFrame* frame : m_frames) #else - foreach(SpriteFrame* frame, m_frames) + foreach (SpriteFrame* frame, m_frames) #endif { delete frame; @@ -172,6 +173,7 @@ bool Sprite::addFrame(SpriteFrame* part) { if (m_frames.size() > 65536) return false; + for (SpriteFrame* tmp : m_frames) { if (tmp == part) @@ -186,14 +188,18 @@ bool Sprite::removeFrame(SpriteFrame* frame) { #ifndef ATHENA_USE_QT std::vector::iterator iter = std::find(m_frames.begin(), m_frames.end(), frame); + if (iter != m_frames.end()) { m_frames.erase(iter); return true; } + #else + if (m_frames.removeOne(frame)) return true; + #endif return false; } @@ -209,6 +215,7 @@ void Sprite::setFrames(std::vector frames) { if (frames.size() == 0) return; + if (m_frames.size() > 0) { for (SpriteFrame* frame : m_frames) @@ -216,8 +223,10 @@ void Sprite::setFrames(std::vector frames) delete frame; frame = NULL; } + m_frames.clear(); } + m_frames = frames; } #else @@ -251,6 +260,7 @@ SpriteFile* Sprite::container() const void Sprite::setCurrentFrame(SpriteFrame* frame) { atUint32 id = 0; + for (SpriteFrame* tmpFrame : m_frames) { if (tmpFrame == frame) @@ -258,6 +268,7 @@ void Sprite::setCurrentFrame(SpriteFrame* frame) setCurrentFrame(id); return; } + id++; } } @@ -281,6 +292,7 @@ SpriteFrame* Sprite::currentFrame() const void Sprite::advanceFrame() { m_currentFrame++; + if (m_currentFrame >= m_frames.size()) m_currentFrame = (atUint32)m_frames.size() - 1; } diff --git a/src/Athena/SpriteFile.cpp b/src/Athena/SpriteFile.cpp index d9ecc0e..e5abf75 100644 --- a/src/Athena/SpriteFile.cpp +++ b/src/Athena/SpriteFile.cpp @@ -55,11 +55,13 @@ SpriteFile::SpriteFile(const QSize& size, const QPoint& origin) SpriteFile::~SpriteFile() { #ifndef ATHENA_USE_QT + for (std::pair sprite : m_sprites) { delete sprite.second; sprite.second = NULL; } + #endif m_sprites.clear(); } @@ -207,12 +209,16 @@ void SpriteFile::addSprite(Sprite* sprite) #ifndef ATHENA_USE_QT std::string name(sprite->name()); Athena::utility::tolower(name); + if (m_sprites.find(name) != m_sprites.end()) return; + #else QString name = sprite->name().toLower(); + if (m_sprites.contains(name)) return; + #endif m_sprites[name] = sprite; @@ -224,6 +230,7 @@ void SpriteFile::removeSprite(const std::string& name) std::string tmpName(name); Athena::utility::tolower(tmpName); std::unordered_map::iterator iterator = m_sprites.find(tmpName); + if (iterator != m_sprites.end()) m_sprites.erase(iterator); } @@ -244,6 +251,7 @@ void SpriteFile::setSprites(std::unordered_map sprites) { if (sprites.size() == 0) return; + if (m_sprites.size() > 0) { for (std::pair sprite : m_sprites) @@ -251,16 +259,18 @@ void SpriteFile::setSprites(std::unordered_map sprites) delete sprite.second; sprite.second = NULL; } + m_sprites.clear(); } m_sprites = sprites; } #else -void SpriteFile::setSprites(QMap sprites) +void SpriteFile::setSprites(QMap sprites) { if (sprites.size() == 0) return; + m_sprites.clear(); m_sprites = sprites; } @@ -271,6 +281,7 @@ Sprite* SpriteFile::sprite(const std::string& name) { std::string nameLow(name); Athena::utility::tolower(nameLow); + if (m_sprites.find(nameLow) == m_sprites.end()) return NULL; @@ -308,18 +319,19 @@ void SpriteFile::setTextures(std::vector textures) if (m_textures.size() > 0) { - for(STexture* tex : m_textures) + for (STexture* tex : m_textures) { delete tex; tex = NULL; } + m_textures.clear(); } m_textures = textures; } #else -void SpriteFile::setTextures(QList textures) +void SpriteFile::setTextures(QList textures) { if (textures.size() == 0) return; diff --git a/src/Athena/SpriteFileReader.cpp b/src/Athena/SpriteFileReader.cpp index 3ffb079..f092a0d 100644 --- a/src/Athena/SpriteFileReader.cpp +++ b/src/Athena/SpriteFileReader.cpp @@ -42,18 +42,19 @@ SpriteFileReader::SpriteFileReader(const std::string& filepath) Sakura::SpriteFile* SpriteFileReader::readFile() { Sakura::SpriteFile* ret = NULL; + try { atUint32 magic = base::readUint32(); if (magic != Sakura::SpriteFile::Magic) - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Not a valid Sakura Sprite container"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Not a valid Sakura Sprite container"); atUint32 version = base::readUint32(); // TODO: Make this more verbose if (version != Sakura::SpriteFile::Version) - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Unsupported version"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Unsupported version"); // After reading in the magic and version we need to load some // metadata about the file. @@ -126,6 +127,7 @@ Sakura::SpriteFile* SpriteFileReader::readFile() // Each state id corresponds to a texture held in the parent class std::vector stateIds; + for (int j = 0; j < stateCount; j++) stateIds.push_back(base::readUint16()); @@ -157,6 +159,7 @@ Sakura::SpriteFile* SpriteFileReader::readFile() #else QList parts; #endif + for (atUint8 j = 0; j < partCount; j++) { Sakura::SpritePart* part = new Sakura::SpritePart(frame); @@ -184,29 +187,34 @@ Sakura::SpriteFile* SpriteFileReader::readFile() parts.push_back(part); } + frame->setParts(parts); frames.push_back(frame); } sprite->setFrames(frames); #ifndef ATHENA_USE_QT + if (sprite->name() != std::string()) { std::string nameLow(sprite->name()); Athena::utility::tolower(nameLow); sprites[nameLow] = sprite; } + #else + if (!sprite->name().isEmpty()) sprites[sprite->name().toLower()] = sprite; + #endif else - THROW_IO_EXCEPTION_RETURN(nullptr,"Sprite names cannot be empty"); + THROW_IO_EXCEPTION_RETURN(nullptr, "Sprite names cannot be empty"); } ret->setSprites(sprites); } - catch(...) + catch (...) { delete ret; ret = NULL; diff --git a/src/Athena/SpriteFileWriter.cpp b/src/Athena/SpriteFileWriter.cpp index 1dc6f1d..63ea1ad 100644 --- a/src/Athena/SpriteFileWriter.cpp +++ b/src/Athena/SpriteFileWriter.cpp @@ -26,7 +26,7 @@ namespace Athena { namespace io { -SpriteFileWriter::SpriteFileWriter(atUint8 *data, atUint64 length) +SpriteFileWriter::SpriteFileWriter(atUint8* data, atUint64 length) : base(data, length) { } @@ -60,12 +60,14 @@ void SpriteFileWriter::writeFile(Sakura::SpriteFile* file) } #ifndef ATHENA_USE_QT + for (std::pair spritePair : file->sprites()) { Sakura::Sprite* sprite = spritePair.second; base::writeString(sprite->name()); #else - foreach(Sakura::Sprite* sprite, file->sprites().values()) + + foreach (Sakura::Sprite* sprite, file->sprites().values()) { base::writeString(sprite->name().toStdString()); @@ -80,7 +82,8 @@ void SpriteFileWriter::writeFile(Sakura::SpriteFile* file) { base::writeFloat(frame->frameTime()); base::writeUint16(frame->partCount()); - for (Sakura::SpritePart* part: frame->parts()) + + for (Sakura::SpritePart* part : frame->parts()) { #ifndef ATHENA_USE_QT base::writeString(part->name()); diff --git a/src/Athena/Utility.cpp b/src/Athena/Utility.cpp index b5045a3..16b254d 100644 --- a/src/Athena/Utility.cpp +++ b/src/Athena/Utility.cpp @@ -41,23 +41,25 @@ bool isSystemBigEndian() return (*(atUint16*)test == 0xFEFF); } -void fillRandom(atUint8 * rndArea, atUint64 count) +void fillRandom(atUint8* rndArea, atUint64 count) { - for(atUint64 i = 0; i < count; i++) - rndArea[i]=rand(); + for (atUint64 i = 0; i < count; i++) + rndArea[i] = rand(); } -std::vector &split(const std::string &s, char delim, std::vector &elems) +std::vector& split(const std::string& s, char delim, std::vector& elems) { std::stringstream ss(s); std::string item; + while (std::getline(ss, item, delim)) elems.push_back(item); + return elems; } -std::vector split(const std::string &s, char delim) +std::vector split(const std::string& s, char delim) { std::vector elems; split(s, delim, elems); @@ -88,13 +90,16 @@ std::string vsprintf(const char* fmt, va_list list) char* buffer = 0; buffer = new char[size]; int nsize = ::vsnprintf(buffer, size, fmt, list); - while(size<=nsize) - { //fail delete buffer and try again + + while (size <= nsize) + { + //fail delete buffer and try again delete[] buffer; buffer = 0; - buffer = new char[nsize+1]; //+1 for /0 + buffer = new char[nsize + 1]; //+1 for /0 nsize = ::vsnprintf(buffer, size, fmt, list); } + std::string ret(buffer); delete[] buffer; return ret; @@ -120,6 +125,7 @@ bool parseBool(const std::string& boolean, bool* valid) { if (valid) *valid = true; + return true; } @@ -128,6 +134,7 @@ bool parseBool(const std::string& boolean, bool* valid) { if (valid) *valid = true; + return false; } @@ -144,6 +151,7 @@ int countChar(const std::string& str, const char chr, int* lastOccur) int ret = 0; int index = 0; + for (char c : str) { if (c == chr) @@ -153,6 +161,7 @@ int countChar(const std::string& str, const char chr, int* lastOccur) ret++; } + index++; } @@ -167,26 +176,28 @@ atUint64 fileSize(const std::string& filename) } // trim from both ends -std::string &trim(std::string &s) +std::string& trim(std::string& s) { // Find first non whitespace char in StrToTrim - std::string::size_type first = s.find_first_not_of( ' ' ); + std::string::size_type first = s.find_first_not_of(' '); + // Check whether something went wrong? - if( first == std::string::npos ) + if (first == std::string::npos) { - first = 0; + first = 0; } // Find last non whitespace char from StrToTrim - std::string::size_type last = s.find_last_not_of( ' ' ); + std::string::size_type last = s.find_last_not_of(' '); + // If something didn't go wrong, Last will be recomputed to get real length of substring - if( last != std::string::npos ) + if (last != std::string::npos) { - last = ( last + 1 ) - first; + last = (last + 1) - first; } // Copy such a string to TrimmedString - s = s.substr( first, last ); + s = s.substr(first, last); return s; } diff --git a/src/Athena/WiiFile.cpp b/src/Athena/WiiFile.cpp index 4e74261..f766ae6 100644 --- a/src/Athena/WiiFile.cpp +++ b/src/Athena/WiiFile.cpp @@ -23,7 +23,7 @@ namespace Athena //! TODO: Remove this? WiiFile::WiiFile() : - m_permissions(WiiFile::GroupRW|WiiFile::OtherRW|WiiFile::OwnerRW), + m_permissions(WiiFile::GroupRW | WiiFile::OtherRW | WiiFile::OwnerRW), m_attributes(0), m_type(WiiFile::File), m_filename(""), @@ -35,7 +35,7 @@ WiiFile::WiiFile() : } WiiFile::WiiFile(const std::string& filename) : - m_permissions(WiiFile::GroupRW|WiiFile::OtherRW|WiiFile::OwnerRW), + m_permissions(WiiFile::GroupRW | WiiFile::OtherRW | WiiFile::OwnerRW), m_attributes(0), m_type(WiiFile::File), m_filename(filename), @@ -92,6 +92,7 @@ void WiiFile::setData(const atUint8* data) delete[] m_fileData; m_fileData = NULL; } + m_fileData = (atUint8*)data; } @@ -140,7 +141,7 @@ bool WiiFile::isFile() const return (m_type == WiiFile::File); } -void WiiFile::addChild(WiiFile *file) +void WiiFile::addChild(WiiFile* file) { if (!isDirectory()) THROW_INVALID_OPERATION_EXCEPTION("%s is not a directory", filename().c_str()); @@ -153,10 +154,12 @@ void WiiFile::addChild(WiiFile *file) // Since we only support *NIX paths this is simple atUint32 depth = Athena::utility::countChar(tmpName, '/'); bool owned = false; + while ((depth--) > 0) { // add them from the beginning of the path up tmpName = tmpName.substr(0, tmpName.find('/')); + for (atUint32 i = 0; i < m_children.size(); i++) { if (!m_children[i]->filename().compare(tmpName)) @@ -177,15 +180,16 @@ void WiiFile::addChild(WiiFile *file) } } -WiiFile* WiiFile::child(const std::string &name) +WiiFile* WiiFile::child(const std::string& name) { std::vector::iterator iter = std::find_if(m_children.begin(), m_children.end(), - [&name](WiiFile* f) { return !f->filename().compare(name); }); + [&name](WiiFile * f) { return !f->filename().compare(name); }); + if (iter != m_children.end()) return *iter; std::string tmpName(name); - tmpName = tmpName.substr(tmpName.rfind('/')+1, tmpName.size() - tmpName.rfind('/')); + tmpName = tmpName.substr(tmpName.rfind('/') + 1, tmpName.size() - tmpName.rfind('/')); for (WiiFile* f : m_children) { @@ -193,6 +197,7 @@ WiiFile* WiiFile::child(const std::string &name) continue; WiiFile* ret = f->child(tmpName); + if (ret) return ret; } @@ -239,11 +244,13 @@ atUint32 WiiFile::fileCount() return (atUint32)ret; } -std::vector WiiFile::allChildren() +std::vector WiiFile::allChildren() { std::vector ret; + if (m_children.size() == 0) return ret; + // Add our children first for (WiiFile* f : m_children) ret.push_back(f); @@ -268,6 +275,7 @@ std::vector WiiFile::allChildren() std::string WiiFile::fullpath() { std::string ret; + if (m_parent) ret = m_parent->filename() + "/"; diff --git a/src/Athena/WiiImage.cpp b/src/Athena/WiiImage.cpp index 14f95e6..940ae07 100644 --- a/src/Athena/WiiImage.cpp +++ b/src/Athena/WiiImage.cpp @@ -33,6 +33,7 @@ WiiImage::~WiiImage() { if (m_data) delete[] m_data; + m_data = NULL; } @@ -51,7 +52,7 @@ atUint32 WiiImage::height() const return m_height; } -atUint8 *WiiImage::toRGBA() +atUint8* WiiImage::toRGBA() { atUint32 x, y; atUint32 x1, y1; @@ -59,22 +60,24 @@ atUint8 *WiiImage::toRGBA() atUint8* bitmapdata = NULL; bitmapdata = new atUint8[m_width * m_height * 4]; - if(bitmapdata == NULL) - return NULL; - for(iv = 0, y1 = 0; y1 < m_height; y1 += 4) + if (bitmapdata == NULL) + return NULL; + + for (iv = 0, y1 = 0; y1 < m_height; y1 += 4) { - for(x1 = 0; x1 < m_width; x1 += 4) + for (x1 = 0; x1 < m_width; x1 += 4) { - for(y = y1; y < (y1 + 4); y++) + for (y = y1; y < (y1 + 4); y++) { - for(x = x1; x < (x1 + 4); x++) + for (x = x1; x < (x1 + 4); x++) { atUint16 oldpixel = *(atUint16*)(m_data + ((iv++) * 2)); //if((x >= m_width) || (y >= m_height)) // continue; oldpixel = utility::swapU16(oldpixel); - if(oldpixel & (1 << 15)) + + if (oldpixel & (1 << 15)) { // RGB5 atUint8 b = (((oldpixel >> 10) & 0x1F) * 255) / 31; @@ -98,6 +101,7 @@ atUint8 *WiiImage::toRGBA() } } } + return bitmapdata; } diff --git a/src/Athena/WiiSave.cpp b/src/Athena/WiiSave.cpp index 65f1490..fdd4146 100644 --- a/src/Athena/WiiSave.cpp +++ b/src/Athena/WiiSave.cpp @@ -51,7 +51,7 @@ WiiSave::~WiiSave() } -void WiiSave::addFile( WiiFile* file) +void WiiSave::addFile(WiiFile* file) { m_root->addChild(file); } @@ -97,7 +97,7 @@ WiiBanner* WiiSave::banner() const return m_banner; } -std::vector WiiSave::allFiles() const +std::vector WiiSave::allFiles() const { return m_root->allChildren(); } diff --git a/src/Athena/WiiSaveReader.cpp b/src/Athena/WiiSaveReader.cpp index f227ab6..9cba0fe 100644 --- a/src/Athena/WiiSaveReader.cpp +++ b/src/Athena/WiiSaveReader.cpp @@ -52,24 +52,27 @@ WiiSaveReader::WiiSaveReader(const std::string& filename) WiiSave* WiiSaveReader::readSave() { WiiSave* ret = new WiiSave; + try { if (length() < 0xF0C0) - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Not a valid WiiSave"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Not a valid WiiSave"); WiiBanner* banner = this->readBanner(); + if (!banner) - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Invalid banner"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Invalid banner"); ret->setBanner(banner); atUint32 bkVer = base::readUint32(); if (bkVer != 0x00000070) - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Invalid BacKup header size"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Invalid BacKup header size"); atUint32 bkMagic = base::readUint32(); + if (bkMagic != 0x426B0001) - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Invalid BacKup header magic"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Invalid BacKup header magic"); atUint32 ngId = base::readUint32(); atUint32 numFiles = base::readUint32(); @@ -85,9 +88,11 @@ WiiSave* WiiSaveReader::readSave() base::seek(0x10); std::vector files; + for (atUint32 i = 0; i < numFiles; ++i) { WiiFile* file = readFile(); + if (file) files.push_back(file); } @@ -96,7 +101,7 @@ WiiSave* WiiSaveReader::readSave() readCerts(totalSize); } - catch(...) + catch (...) { delete ret; ret = NULL; @@ -141,18 +146,23 @@ WiiBanner* WiiSaveReader::readBanner() std::cerr << "MD5 Mismatch" << std::endl; // Make sure to reset m_reader values back to the old ones. std::cerr << "MD5 provided: "; + for (int i = 0; i < 16; ++i) std::cerr << std::setw(2) << std::setfill('0') << std::hex << (int)(md5[i]); + std::cerr << std::endl; std::cerr << "MD5 Calculated: "; + for (int i = 0; i < 16; ++i) std::cerr << std::hex << (int)(md5Calc[i]); + std::cerr << std::endl; base::setData(oldData, oldLen); base::seek(oldPos, SeekOrigin::Begin); - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"MD5 Mismatch"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "MD5 Mismatch"); } + // Set the binary reader buffer; base::setData(dec, 0xF0C0); // Start reading the header @@ -178,7 +188,7 @@ WiiBanner* WiiSaveReader::readBanner() // Make sure to reset m_reader values back to the old ones. base::setData(oldData, oldLen); base::seek(oldPos, SeekOrigin::Begin); - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Invalid Header Magic"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Invalid Header Magic"); } flags = base::readUint32(); @@ -186,10 +196,12 @@ WiiBanner* WiiSaveReader::readBanner() base::seek(22); gameTitle = base::readUnicode(); + if (base::position() != 0x0080) base::seek(0x0080, SeekOrigin::Begin); subTitle = base::readUnicode(); + if (base::position() != 0x00C0) base::seek(0x00C0, SeekOrigin::Begin); @@ -208,6 +220,7 @@ WiiBanner* WiiSaveReader::readBanner() if (banner->bannerSize() == 0x72a0) { WiiImage* icon = readImage(48, 48); + if (icon) banner->addIcon(icon); else @@ -215,9 +228,10 @@ WiiBanner* WiiSaveReader::readBanner() } else { - for(int i = 0; i < 8; i++) + for (int i = 0; i < 8; i++) { WiiImage* icon = readImage(48, 48); + if (icon) banner->addIcon(icon); else @@ -232,9 +246,9 @@ WiiBanner* WiiSaveReader::readBanner() WiiImage* WiiSaveReader::readImage(atUint32 width, atUint32 height) { - atUint8* image = (atUint8*)base::readBytes(width*height*2); + atUint8* image = (atUint8*)base::readBytes(width * height * 2); - if (!utility::isEmpty((atInt8*)image, width*height*2)) + if (!utility::isEmpty((atInt8*)image, width * height * 2)) return new WiiImage(width, height, image); return NULL; @@ -252,6 +266,7 @@ WiiFile* WiiSaveReader::readFile() WiiFile* ret; atUint32 magic = base::readUint32(); + if (magic != 0x03adf17e) { std::cerr << "Not a valid File entry header: 0x" << std::hex << magic << std::endl; diff --git a/src/Athena/WiiSaveWriter.cpp b/src/Athena/WiiSaveWriter.cpp index 7e243d0..a5b2212 100644 --- a/src/Athena/WiiSaveWriter.cpp +++ b/src/Athena/WiiSaveWriter.cpp @@ -45,17 +45,18 @@ namespace Athena namespace io { -WiiSaveWriter::WiiSaveWriter(const std::string &filename) +WiiSaveWriter::WiiSaveWriter(const std::string& filename) : base(filename) { base::setEndian(Endian::BigEndian); } -bool WiiSaveWriter::writeSave(WiiSave *save, atUint8 *macAddress, atUint32 ngId, atUint8 *ngPriv, atUint8 *ngSig, atUint32 ngKeyId,const std::string &filepath) +bool WiiSaveWriter::writeSave(WiiSave* save, atUint8* macAddress, atUint32 ngId, atUint8* ngPriv, atUint8* ngSig, atUint32 ngKeyId, const std::string& filepath) { if (!save) THROW_INVALID_OPERATION_EXCEPTION_RETURN(false, "save cannot be NULL"); + if (filepath != "") m_filepath = filepath; @@ -74,10 +75,12 @@ bool WiiSaveWriter::writeSave(WiiSave *save, atUint8 *macAddress, atUint32 ngId, base::seek(2); // unknown; base::seek(0x10); // padding; atUint32 totalSize = 0; + for (WiiFile* file : save->allFiles()) { totalSize += writeFile(file); } + atUint64 pos = base::position(); // Write size data base::seek(0xF0C0 + 0x10, SeekOrigin::Begin); @@ -93,11 +96,11 @@ bool WiiSaveWriter::writeSave(WiiSave *save, atUint8 *macAddress, atUint32 ngId, return true; } -void WiiSaveWriter::writeBanner(WiiBanner *banner) +void WiiSaveWriter::writeBanner(WiiBanner* banner) { base::setEndian(Endian::BigEndian); base::writeInt64(banner->gameID()); - base::writeInt32((0x60a0+0x1200)*(atUint32)banner->icons().size()); + base::writeInt32((0x60a0 + 0x1200) * (atUint32)banner->icons().size()); base::writeByte((atInt8)banner->permissions()); base::seek(1); base::writeBytes((atInt8*)MD5_BLANKER, 16); @@ -118,11 +121,12 @@ void WiiSaveWriter::writeBanner(WiiBanner *banner) base::seek(0x00C0, SeekOrigin::Begin); WiiImage* bannerImage = banner->bannerImage(); - base::writeBytes((atInt8*)bannerImage->data(), bannerImage->width()*bannerImage->height()*2); + base::writeBytes((atInt8*)bannerImage->data(), bannerImage->width()*bannerImage->height() * 2); // For empty icons - atUint8* tmpIcon = new atUint8[48*48*2]; - memset(tmpIcon, 0, 48*48*2); + atUint8* tmpIcon = new atUint8[48 * 48 * 2]; + memset(tmpIcon, 0, 48 * 48 * 2); + for (atUint32 i = 0; i < 8; ++i) { if (i < banner->icons().size()) @@ -131,7 +135,7 @@ void WiiSaveWriter::writeBanner(WiiBanner *banner) } else { - base::writeBytes((atInt8*)tmpIcon, 48*48*2); + base::writeBytes((atInt8*)tmpIcon, 48 * 48 * 2); } } @@ -154,7 +158,7 @@ void WiiSaveWriter::writeBanner(WiiBanner *banner) base::seek(0xF0C0, SeekOrigin::Begin); } -atUint32 WiiSaveWriter::writeFile(WiiFile *file) +atUint32 WiiSaveWriter::writeFile(WiiFile* file) { atUint32 ret = 0x80; @@ -201,7 +205,7 @@ void WiiSaveWriter::writeImage(WiiImage* image) base::writeBytes(data, image->width() * image->height() * 2); } -void WiiSaveWriter::writeCerts(atUint32 filesSize, atUint32 ngId, atUint8 *ngPriv, atUint8 *ngSig, atUint32 ngKeyId) +void WiiSaveWriter::writeCerts(atUint32 filesSize, atUint32 ngId, atUint8* ngPriv, atUint8* ngSig, atUint32 ngKeyId) { atUint8 sig[0x40]; atUint8 ngCert[0x180]; @@ -228,7 +232,7 @@ void WiiSaveWriter::writeCerts(atUint32 filesSize, atUint32 ngId, atUint8 *ngPri make_ec_cert(apCert, apSig, signer, name, apPriv, 0); hash = getSha1(apCert + 0x80, 0x100); - generate_ecdsa(apSig, apSig+30, ngPriv, hash); + generate_ecdsa(apSig, apSig + 30, ngPriv, hash); make_ec_cert(apCert, apSig, signer, name, apPriv, 0); delete[] hash; @@ -242,12 +246,13 @@ void WiiSaveWriter::writeCerts(atUint32 filesSize, atUint32 ngId, atUint8 *ngPri delete[] hash; delete[] data; - generate_ecdsa(sig, sig+30, apPriv, hash2); + generate_ecdsa(sig, sig + 30, apPriv, hash2); int stuff = 0x2f536969; + if (!utility::isSystemBigEndian()) stuff = utility::swap32(stuff); - *(atUint32*)(sig+60) = stuff; + *(atUint32*)(sig + 60) = stuff; delete[] hash2; base::writeBytes((atInt8*)sig, 0x40); diff --git a/src/Athena/ZQuestFile.cpp b/src/Athena/ZQuestFile.cpp index 5530efd..ac5464c 100644 --- a/src/Athena/ZQuestFile.cpp +++ b/src/Athena/ZQuestFile.cpp @@ -70,6 +70,7 @@ ZQuestFile::ZQuestFile(ZQuestFile::Game game, Endian endian, atUint8* data, atUi m_length(length) { initGameStrings(); + if (gameString.empty() && (m_game < GameStrings.size() - 1)) m_gameString = GameStrings[m_game]; } @@ -84,6 +85,7 @@ ZQuestFile::~ZQuestFile() void ZQuestFile::setGame(ZQuestFile::Game game) { m_game = game; + if (m_game > GameStrings.size() - 1) return; @@ -145,6 +147,7 @@ const std::vector ZQuestFile::gameStringList() { if (GameStrings.size() <= 0) initGameStrings(); + return GameStrings; } } diff --git a/src/Athena/ZQuestFileReader.cpp b/src/Athena/ZQuestFileReader.cpp index a1752b0..2b79f8d 100644 --- a/src/Athena/ZQuestFileReader.cpp +++ b/src/Athena/ZQuestFileReader.cpp @@ -30,17 +30,17 @@ namespace Athena namespace io { -ZQuestFileReader::ZQuestFileReader(atUint8 *data, atUint64 length) +ZQuestFileReader::ZQuestFileReader(atUint8* data, atUint64 length) : base(data, length) { } -ZQuestFileReader::ZQuestFileReader(const std::string &filename) +ZQuestFileReader::ZQuestFileReader(const std::string& filename) : base(filename) { } -ZQuestFile *ZQuestFileReader::read() +ZQuestFile* ZQuestFileReader::read() { atUint32 magic, version, compressedLen, uncompressedLen; ZQuestFile::Game game = ZQuestFile::NoGame; @@ -52,12 +52,12 @@ ZQuestFile *ZQuestFileReader::read() magic = base::readUint32(); if ((magic & 0x00FFFFFF) != (ZQuestFile::Magic & 0x00FFFFFF)) - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Not a valid ZQuest file"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Not a valid ZQuest file"); version = base::readUint32(); if (version > ZQuestFile::Version) - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Unsupported ZQuest version"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Unsupported ZQuest version"); compressedLen = base::readUint32(); uncompressedLen = base::readUint32(); @@ -65,6 +65,7 @@ ZQuestFile *ZQuestFileReader::read() if (version >= ZQUEST_VERSION_CHECK(2, 0, 0)) { gameString = std::string((const char*)base::readBytes(0x0A), 0x0A); + for (size_t i = 0; i < ZQuestFile::gameStringList().size(); i++) { if (!ZQuestFile::gameStringList().at(i).substr(0, 0x0A).compare(gameString)) @@ -74,6 +75,7 @@ ZQuestFile *ZQuestFileReader::read() break; } } + BOM = base::readUint16(); checksum = base::readUint32(); } @@ -91,7 +93,7 @@ ZQuestFile *ZQuestFileReader::read() if (checksum != Athena::Checksums::crc32(data, compressedLen)) { delete[] data; - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Checksum mismatch, data corrupt"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Checksum mismatch, data corrupt"); } } else @@ -109,7 +111,7 @@ ZQuestFile *ZQuestFileReader::read() { delete[] dst; delete[] data; - THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr,"Error decompressing data"); + THROW_INVALID_DATA_EXCEPTION_RETURN(nullptr, "Error decompressing data"); } delete[] data; diff --git a/src/Athena/ZQuestFileWriter.cpp b/src/Athena/ZQuestFileWriter.cpp index 66bd66e..b1d2d17 100644 --- a/src/Athena/ZQuestFileWriter.cpp +++ b/src/Athena/ZQuestFileWriter.cpp @@ -44,6 +44,7 @@ void ZQuestFileWriter::write(ZQuestFile* quest, bool compress) base::writeUint32(ZQuestFile::Version); atUint8* questData = quest->data(); atUint32 compLen; + if (compress) { atUint8* compData = new atUint8[quest->length() + 0x40]; // add 20 bytes because sometimes the file grows with compression @@ -79,6 +80,7 @@ void ZQuestFileWriter::write(ZQuestFile* quest, bool compress) base::writeUBytes(questData, compLen); base::save(); + // Delete compressed data to prevent memory leaks if (questData != quest->data()) { diff --git a/src/LZ77/LZBase.cpp b/src/LZ77/LZBase.cpp index adcf48f..05bb6f4 100644 --- a/src/LZ77/LZBase.cpp +++ b/src/LZ77/LZBase.cpp @@ -23,18 +23,18 @@ void LZBase::setReadAheadBuffer(atInt32 readAheadBuffer) m_readAheadBuffer = readAheadBuffer; } -atInt32 LZBase::readAheadBuffer(){return m_readAheadBuffer;} +atInt32 LZBase::readAheadBuffer() {return m_readAheadBuffer;} -void LZBase::setMinMatch(atInt32 minimumMatch) { m_minMatch =minimumMatch;} +void LZBase::setMinMatch(atInt32 minimumMatch) { m_minMatch = minimumMatch;} -atInt32 LZBase::minMatch(){return m_minMatch;} +atInt32 LZBase::minMatch() {return m_minMatch;} void LZBase::setBlockSize(atInt32 blockSize) { m_blockSize = blockSize ; } -atInt32 LZBase::blockSize(){return m_blockSize;} +atInt32 LZBase::blockSize() {return m_blockSize;} void LZBase::setMinimumOffset(atUint32 minimumOffset) { m_minOffset = minimumOffset;} @@ -56,39 +56,41 @@ atUint32 LZBase::minimumOffset() */ LZLengthOffset LZBase::search(atUint8* posPtr, atUint8* dataBegin, atUint8* dataEnd) { - LZLengthOffset results={0,0}; + LZLengthOffset results = {0, 0}; //Returns negative 1 for Search failures since the current position is passed the size to be compressed - if(posPtr >=dataEnd) + if (posPtr >= dataEnd) { - results.length=-1; + results.length = -1; return results; } atUint8* searchWindow; //LookAheadBuffer is ReadAheadBuffer Size if there are more bytes than ReadAheadBufferSize waiting //to be compressed else the number of remaining bytes is the LookAheadBuffer - int lookAheadBuffer_len=((int)(dataEnd-posPtr) 0) - searchWindow=dataBegin+slidingBuffer; + int lookAheadBuffer_len = ((int)(dataEnd - posPtr) < m_readAheadBuffer) ? (int)(dataEnd - posPtr) : m_readAheadBuffer; + int slidingBuffer = (int)(posPtr - dataBegin) - m_slidingWindow; + + if (slidingBuffer > 0) + searchWindow = dataBegin + slidingBuffer; else - searchWindow=dataBegin; + searchWindow = dataBegin; - atUint8* endPos=posPtr+lookAheadBuffer_len; + atUint8* endPos = posPtr + lookAheadBuffer_len; + + if (!((posPtr - dataBegin < 1) || (dataEnd - posPtr < m_minMatch))) + results = windowSearch(searchWindow, posPtr, endPos, posPtr - m_minOffset); - if(!( (posPtr-dataBegin < 1)||( dataEnd-posPtr < m_minMatch) )) - results=windowSearch(searchWindow,posPtr,endPos,posPtr-m_minOffset); return results; } //Returns the full length of string2 if they are equal else //Return the number of characters that were equal before they weren't equal -int LZBase::subMatch(const uint8_t* str1,const uint8_t* str2,const int len) +int LZBase::subMatch(const uint8_t* str1, const uint8_t* str2, const int len) { - for(int i=0;i size)//If the string that is being looked for is bigger than the string that is being searched + atInt32 size = (atUint32)(endLABufferPtr - beginSearchPtr); //Size of the entire sliding window + atInt32 n = (atUint32)(endLABufferPtr - searchPosPtr); + LZLengthOffset result = {0, 0}; + atInt32 temp = 0; + + if (n > size) //If the string that is being looked for is bigger than the string that is being searched return result; /*This makes sure that search for the searchPosPtr can be searched if an invalid position is given @@ -126,19 +129,22 @@ LZLengthOffset LZBase::windowSearch(atUint8* beginSearchPtr, atUint8* searchPosP do { - temp=subMatch(startLBPtr,searchPosPtr,n); - if(result.length<(atUint32)temp) + temp = subMatch(startLBPtr, searchPosPtr, n); + + if (result.length < (atUint32)temp) { - result.length=temp; - result.offset=(atInt32)(searchPosPtr-startLBPtr); + result.length = temp; + result.offset = (atInt32)(searchPosPtr - startLBPtr); } - if(result.length==(atUint32)n) + + if (result.length == (atUint32)n) return result; //ReadAheadBuffer is the maximum size of a character match } - while((startLBPtr--) > beginSearchPtr); + while ((startLBPtr--) > beginSearchPtr); + return result; } diff --git a/src/LZ77/LZLookupTable.cpp b/src/LZ77/LZLookupTable.cpp index 75878eb..b1f5e2b 100644 --- a/src/LZ77/LZLookupTable.cpp +++ b/src/LZ77/LZLookupTable.cpp @@ -11,18 +11,21 @@ LZLookupTable::LZLookupTable() LZLookupTable::LZLookupTable(atInt32 minimumMatch, atInt32 slidingWindow, atInt32 lookAheadWindow) { - if(minimumMatch > 0 ) + if (minimumMatch > 0) m_minimumMatch = minimumMatch; else m_minimumMatch = 3; - if(slidingWindow > 0) + + if (slidingWindow > 0) m_slidingWindow = slidingWindow; else m_slidingWindow = 4096; - if(lookAheadWindow > 0) + + if (lookAheadWindow > 0) m_lookAheadWindow = lookAheadWindow; else m_lookAheadWindow = 18; + m_buffer.reserve(m_minimumMatch); } @@ -31,7 +34,7 @@ LZLookupTable::~LZLookupTable() void LZLookupTable::setLookAheadWindow(atInt32 lookAheadWindow) { - if(lookAheadWindow > 0) + if (lookAheadWindow > 0) m_lookAheadWindow = lookAheadWindow; else m_lookAheadWindow = 18; @@ -39,65 +42,78 @@ void LZLookupTable::setLookAheadWindow(atInt32 lookAheadWindow) LZLengthOffset LZLookupTable::search(atUint8* curPos, const atUint8* dataBegin, const atUint8* dataEnd) { - LZLengthOffset loPair = {0,0}; + LZLengthOffset loPair = {0, 0}; + //Returns negative 1 for search failures since the current position is passed the size to be compressed - if(curPos >=dataEnd) + if (curPos >= dataEnd) { - loPair.length=-1; + loPair.length = -1; return loPair; } + std::copy(curPos, curPos + m_minimumMatch, m_buffer.begin()); int32_t currentOffset = static_cast(curPos - dataBegin); + //Find code - if(currentOffset > 0 && (dataEnd - curPos) >= m_minimumMatch) + if (currentOffset > 0 && (dataEnd - curPos) >= m_minimumMatch) { auto elements = table.equal_range(m_buffer); elements.second--; elements.first--; + //Iterate over keys in reverse order. C++11 guarantees that the relative order of elements is maintained for the same key - for(auto iter = elements.second; iter != elements.first; iter--) + for (auto iter = elements.second; iter != elements.first; iter--) { int32_t matchLength = m_minimumMatch; int32_t lookAheadBufferLength = ((dataEnd - curPos) < m_lookAheadWindow) ? static_cast(dataEnd - curPos) : m_lookAheadWindow; - for(; matchLength < lookAheadBufferLength; ++matchLength) + + for (; matchLength < lookAheadBufferLength; ++matchLength) { - if(*(dataBegin + iter->second + matchLength) != *(curPos + matchLength)) + if (*(dataBegin + iter->second + matchLength) != *(curPos + matchLength)) break; } + //Store the longest match found so far into length_offset struct. //When lengths are the same the closer offset to the lookahead buffer wins - if(loPair.length < (atUint32)matchLength) + if (loPair.length < (atUint32)matchLength) { loPair.length = matchLength; loPair.offset = currentOffset - iter->second; } + //Found the longest match so break out of loop - if(loPair.length == (atUint32)m_lookAheadWindow) + if (loPair.length == (atUint32)m_lookAheadWindow) break; } } + //end find code //Insert code table.insert(std::make_pair(m_buffer, currentOffset)); - for(atUint32 i = 1; i < loPair.length; i++) + + for (atUint32 i = 1; i < loPair.length; i++) { - if(dataEnd - (curPos + i) < m_minimumMatch) + if (dataEnd - (curPos + i) < m_minimumMatch) break; + std::copy(curPos + i, curPos + m_minimumMatch + i, m_buffer.begin()); table.insert(std::make_pair(m_buffer, currentOffset + i)); } + //end insert code //Delete code int32_t slidingWindowOffset = std::max(0, currentOffset - m_slidingWindow);//Absolute offset - int32_t tablesize=static_cast(table.size()); - for(int32_t i = 0; i < tablesize - m_slidingWindow; ++i) + int32_t tablesize = static_cast(table.size()); + + for (int32_t i = 0; i < tablesize - m_slidingWindow; ++i) { std::copy(dataBegin + slidingWindowOffset + i, dataBegin + slidingWindowOffset + m_minimumMatch + i, m_buffer.begin()); auto elements = table.equal_range(m_buffer); - for(auto iter = elements.first; iter != elements.second; iter++) + + for (auto iter = elements.first; iter != elements.second; iter++) { - if(slidingWindowOffset + i == iter->second) + if (slidingWindowOffset + i == iter->second) { table.erase(iter); //There should no occurance of the map with the same value @@ -105,6 +121,7 @@ LZLengthOffset LZLookupTable::search(atUint8* curPos, const atUint8* dataBegin, } } } + //end delete code return loPair; //break lookupTable.cpp:109 if table.size()> 4096 diff --git a/src/LZ77/LZType10.cpp b/src/LZ77/LZType10.cpp index bcabf96..0b49e5f 100644 --- a/src/LZ77/LZType10.cpp +++ b/src/LZ77/LZType10.cpp @@ -4,7 +4,7 @@ #include LZType10::LZType10(atInt32 MinimumOffset, atInt32 SlidingWindow, atInt32 MinimumMatch, atInt32 BlockSize) - : LZBase(MinimumOffset,SlidingWindow,MinimumMatch,BlockSize) + : LZBase(MinimumOffset, SlidingWindow, MinimumMatch, BlockSize) { //ReadAheadBuffer is normalize between (minumum match) and(minimum match + 15) so that matches fit within //4-bits. @@ -13,56 +13,61 @@ LZType10::LZType10(atInt32 MinimumOffset, atInt32 SlidingWindow, atInt32 Minimum atUint32 LZType10::compress(const atUint8* src, atUint8** dstBuf, atUint32 srcLength) { - atUint32 encodeSize=(srcLength<<8)|(0x10); + atUint32 encodeSize = (srcLength << 8) | (0x10); encodeSize = Athena::utility::LittleUint32(encodeSize); //File size needs to be written as little endian always Athena::io::MemoryWriter outbuf("tmp"); outbuf.writeUint32(encodeSize); - atUint8* ptrStart=(atUint8*)src; - atUint8* ptrEnd=(atUint8*)(src+srcLength); + atUint8* ptrStart = (atUint8*)src; + atUint8* ptrEnd = (atUint8*)(src + srcLength); //At most their will be two bytes written if the bytes can be compressed. So if all bytes in the block can be compressed it would take blockSize*2 bytes - atUint8* compressedBytes= new atUint8[m_blockSize *2];//Holds the compressed bytes yet to be written - while( ptrStart < ptrEnd ) + atUint8* compressedBytes = new atUint8[m_blockSize * 2]; //Holds the compressed bytes yet to be written + + while (ptrStart < ptrEnd) { - atUint8 blockLen=0; + atUint8 blockLen = 0; //In Binary represents 1 if byte is compressed or 0 if not compressed //For example 01001000 means that the second and fifth byte in the blockSize from the left is compressed - atUint8 *ptrBytes=compressedBytes; - for(atInt32 i=0; i < m_blockSize; i++) + atUint8* ptrBytes = compressedBytes; + + for (atInt32 i = 0; i < m_blockSize; i++) { //length_offset searchResult=Search(ptrStart, filedata, ptrEnd); LZLengthOffset searchResult = m_lookupTable.search(ptrStart, src, ptrEnd); //If the number of bytes to be compressed is at least the size of the Minimum match - if(searchResult.length >= (atUint32)m_minMatch) - { //Gotta swap the bytes since system is wii is big endian and most computers are little endian + if (searchResult.length >= (atUint32)m_minMatch) + { + //Gotta swap the bytes since system is wii is big endian and most computers are little endian atUint16 lenOff = (((searchResult.length - m_minMatch) & 0xF) << 12) | ((searchResult.offset - 1) & 0xFFF); Athena::utility::BigUint16(lenOff); - memcpy(ptrBytes,&lenOff,sizeof(atUint16)); + memcpy(ptrBytes, &lenOff, sizeof(atUint16)); - ptrBytes+= sizeof(atUint16); + ptrBytes += sizeof(atUint16); - ptrStart+=searchResult.length; + ptrStart += searchResult.length; - blockLen |=(1 << (7-i)); + blockLen |= (1 << (7 - i)); //Stores which of the next 8 bytes is compressed //bit 1 for compress and bit 0 for not compressed } else - *ptrBytes++=*ptrStart++; + *ptrBytes++ = *ptrStart++; } + outbuf.writeByte(blockLen); - outbuf.writeUBytes(compressedBytes,(atUint64)(ptrBytes-compressedBytes)); + outbuf.writeUBytes(compressedBytes, (atUint64)(ptrBytes - compressedBytes)); } + delete[] compressedBytes; compressedBytes = nullptr; //Add zeros until the file is a multiple of 4 - while ((outbuf.position()%4) !=0 ) + while ((outbuf.position() % 4) != 0) outbuf.writeByte(0); *dstBuf = outbuf.data(); @@ -79,49 +84,52 @@ atUint32 LZType10::decompress(const atUint8* src, atUint8** dst, atUint32 srcLen Athena::utility::LittleUint32(uncompressedSize); //The compressed file has the filesize encoded in little endian uncompressedSize = uncompressedSize >> 8;//first byte is the encode flag - atUint8* uncompressedData=new atUint8[uncompressedSize]; - atUint8* outputPtr=uncompressedData; - atUint8* outputEndPtr=uncompressedData+uncompressedSize; - atUint8* inputPtr=(atUint8*)src + 4; - atUint8* inputEndPtr=(atUint8*)src + srcLength; - while(inputPtr>(7-i)) & 0x1) + if ((isCompressed >> (7 - i)) & 0x1) { atUint16 lenOff; - memcpy(&lenOff,inputPtr,sizeof(atUint16)); + memcpy(&lenOff, inputPtr, sizeof(atUint16)); Athena::utility::BigUint16(lenOff); - inputPtr+=sizeof(atUint16);//Move forward two bytes + inputPtr += sizeof(atUint16); //Move forward two bytes //length offset pair has been decoded. LZLengthOffset decoding; - decoding.length = (lenOff>>12)+m_minMatch; + decoding.length = (lenOff >> 12) + m_minMatch; decoding.offset = static_cast((lenOff & 0xFFF) + 1); - if((outputPtr - decoding.offset) < uncompressedData) - {//If the offset to look for uncompressed is passed the current uncompresed data then the data is not compressed + if ((outputPtr - decoding.offset) < uncompressedData) + { + //If the offset to look for uncompressed is passed the current uncompresed data then the data is not compressed delete[] uncompressedData; - uncompressedData=nullptr; + uncompressedData = nullptr; dst = nullptr; return 0; } - for(atUint32 j=0;j0xFFFFFF){// If length is greater than 24 bits or 16 Megs - atUint32 encodeFlag=0x11; + + if (srcLength > 0xFFFFFF) // If length is greater than 24 bits or 16 Megs + { + atUint32 encodeFlag = 0x11; Athena::utility::LittleUint32(encodeFlag); Athena::utility::LittleUint32(srcLength);//Filesize data is little endian outbuff.writeUint32(encodeFlag); outbuff.writeUint32(srcLength); } - else{ - atUint32 encodeSize=(srcLength<<8)|(0x11); + else + { + atUint32 encodeSize = (srcLength << 8) | (0x11); Athena::utility::LittleUint32(encodeSize); outbuff.writeUint32(encodeSize); } - atUint8 *ptrStart=(atUint8*)src; - atUint8 *ptrEnd=(atUint8*)(src+srcLength); + atUint8* ptrStart = (atUint8*)src; + atUint8* ptrEnd = (atUint8*)(src + srcLength); //At most their will be two bytes written if the bytes can be compressed. So if all bytes in the block can be compressed it would take blockSize*2 bytes - atUint8 *compressedBytes=new atUint8[m_blockSize *2];//Holds the compressed bytes yet to be written + atUint8* compressedBytes = new atUint8[m_blockSize * 2]; //Holds the compressed bytes yet to be written + + atUint8 maxTwoByteMatch = 0xF + 1; + atUint8 minThreeByteMatch = maxTwoByteMatch + 1; //Minimum Three byte match is maximum TwoByte match + 1 + atUint16 maxThreeByteMatch = 0xFF + minThreeByteMatch; + atUint16 minFourByteMatch = maxThreeByteMatch + 1; //Minimum Four byte match is maximum Three Byte match + 1 + atInt32 maxFourByteMatch = 0xFFFF + minFourByteMatch; - atUint8 maxTwoByteMatch= 0xF+1; - atUint8 minThreeByteMatch=maxTwoByteMatch+1;//Minimum Three byte match is maximum TwoByte match + 1 - atUint16 maxThreeByteMatch= 0xFF+minThreeByteMatch; - atUint16 minFourByteMatch=maxThreeByteMatch+1;//Minimum Four byte match is maximum Three Byte match + 1 - atInt32 maxFourByteMatch=0xFFFF+minFourByteMatch; /* Normaliazation Example: If MIN_MATCH is 3 then 3 gets mapped to 2 and 16 gets mapped to 15. 17 gets mapped to 1 and 272 gets mapped to 255 @@ -53,64 +57,73 @@ atUint32 LZType11::compress(const atUint8* src, atUint8** dst, atUint32 srcLengt In the three byte case the first 4 bits are 0000 In the four byte case the first 4 bits a 0001 */ - while( ptrStart < ptrEnd ) + while (ptrStart < ptrEnd) { - atUint8 blockSize=0; + atUint8 blockSize = 0; //In Binary represents 1 if byte is compressed or 0 if not compressed //For example 01001000 means that the second and fifth byte in the blockSize from the left is compressed - atUint8 *ptrBytes=compressedBytes; - for(atInt32 i=0;i < m_blockSize;i++) + atUint8* ptrBytes = compressedBytes; + + for (atInt32 i = 0; i < m_blockSize; i++) { //length_offset searchResult=Search(filedata,ptrStart,ptrEnd); - LZLengthOffset searchResult=m_lookupTable.search(ptrStart, src, ptrEnd); - //If the number of bytes to be compressed is at least the size of the Minimum match - if(searchResult.length >= (atUint32)m_minMatch) - { //Gotta swap the bytes since system is wii is big endian and most computers are little endian + LZLengthOffset searchResult = m_lookupTable.search(ptrStart, src, ptrEnd); - if(searchResult.length <= maxTwoByteMatch){ - atUint16 lenOff=((((searchResult.length - 1) & 0xF) << 12) | //Bits 15-12 - ((searchResult.offset - 1) & 0xFFF) //Bits 11-0 - ); + //If the number of bytes to be compressed is at least the size of the Minimum match + if (searchResult.length >= (atUint32)m_minMatch) + { + //Gotta swap the bytes since system is wii is big endian and most computers are little endian + + if (searchResult.length <= maxTwoByteMatch) + { + atUint16 lenOff = ((((searchResult.length - 1) & 0xF) << 12) | //Bits 15-12 + ((searchResult.offset - 1) & 0xFFF) //Bits 11-0 + ); Athena::utility::BigUint16(lenOff); - memcpy(ptrBytes,&lenOff,2); - ptrBytes+=2; + memcpy(ptrBytes, &lenOff, 2); + ptrBytes += 2; } - else if(searchResult.length <= maxThreeByteMatch){ - atUint32 lenOff=((((searchResult.length - minThreeByteMatch) & 0xFF)<< 12) | //Bits 20-12 - ((searchResult.offset - 1) & 0xFFF) //Bits 11-0 - ); - Athena::utility::BigUint32(lenOff); - memcpy(ptrBytes,(atUint8*)&lenOff+1,3); //Make sure to copy the lower 24 bits. 0x12345678- This statement copies 0x123456 - ptrBytes+=3; - } - else if(searchResult.length <= (atUint32)maxFourByteMatch){ - atUint32 lenOff=((1<<28) | //Bits 31-28 Flag to say that this is four bytes - (((searchResult.length - minFourByteMatch) & 0xFFFF)<< 12) | //Bits 28-12 - ((searchResult.offset - 1) & 0xFFF) //Bits 11-0 + else if (searchResult.length <= maxThreeByteMatch) + { + atUint32 lenOff = ((((searchResult.length - minThreeByteMatch) & 0xFF) << 12) | //Bits 20-12 + ((searchResult.offset - 1) & 0xFFF) //Bits 11-0 ); Athena::utility::BigUint32(lenOff); - memcpy(ptrBytes,&lenOff,4); - ptrBytes+=4; + memcpy(ptrBytes, (atUint8*)&lenOff + 1, 3); //Make sure to copy the lower 24 bits. 0x12345678- This statement copies 0x123456 + ptrBytes += 3; + } + else if (searchResult.length <= (atUint32)maxFourByteMatch) + { + atUint32 lenOff = ((1 << 28) | //Bits 31-28 Flag to say that this is four bytes + (((searchResult.length - minFourByteMatch) & 0xFFFF) << 12) | //Bits 28-12 + ((searchResult.offset - 1) & 0xFFF) //Bits 11-0 + ); + Athena::utility::BigUint32(lenOff); + memcpy(ptrBytes, &lenOff, 4); + ptrBytes += 4; } - ptrStart+=searchResult.length; - blockSize |=(1 << (7-i)); + ptrStart += searchResult.length; + + blockSize |= (1 << (7 - i)); //Stores which of the next 8 bytes is compressed //bit 1 for compress and bit 0 for not compressed } else - *ptrBytes++=*ptrStart++; + *ptrBytes++ = *ptrStart++; } + outbuff.writeByte(blockSize); - outbuff.writeUBytes(compressedBytes,(atUint64)(ptrBytes-compressedBytes)); + outbuff.writeUBytes(compressedBytes, (atUint64)(ptrBytes - compressedBytes)); } + delete []compressedBytes; - compressedBytes=NULL; + compressedBytes = NULL; //Add zeros until the file is a multiple of 4 - while((outbuff.position()%4) !=0 ) + while ((outbuff.position() % 4) != 0) outbuff.writeByte(0); *dst = outbuff.data(); @@ -119,88 +132,97 @@ atUint32 LZType11::compress(const atUint8* src, atUint8** dst, atUint32 srcLengt atUint32 LZType11::decompress(const atUint8* src, atUint8** dst, atUint32 srcLength) { - if(*(atUint8*)(src) != 0x11) + if (*(atUint8*)(src) != 0x11) return 0; atUint32 uncompressedLen = *(atUint32*)(src); Athena::utility::LittleUint32(uncompressedLen);//The compressed file has the filesize encoded in little endian uncompressedLen = uncompressedLen >> 8; //First byte is the encode flag atUint32 currentOffset = 4; - if(uncompressedLen==0)//If the filesize var is zero then the true filesize is over 14MB and must be read in from the next 4 bytes + + if (uncompressedLen == 0) //If the filesize var is zero then the true filesize is over 14MB and must be read in from the next 4 bytes { atUint32 filesize = *(atUint32*)(src + 4); filesize = Athena::utility::LittleUint32(filesize); currentOffset += 4; } - atUint8 *uncompressedData=new atUint8[uncompressedLen]; - atUint8 *outputPtr=uncompressedData; - atUint8 *outputEndPtr=uncompressedData+uncompressedLen; - atUint8 *inputPtr=(atUint8*)src + currentOffset; - atUint8 *inputEndPtr=(atUint8*)src+srcLength; + atUint8* uncompressedData = new atUint8[uncompressedLen]; + atUint8* outputPtr = uncompressedData; + atUint8* outputEndPtr = uncompressedData + uncompressedLen; + atUint8* inputPtr = (atUint8*)src + currentOffset; + atUint8* inputEndPtr = (atUint8*)src + srcLength; LZLengthOffset decoding; - atUint8 maxTwoByteMatch= 0xF+1; - atUint8 threeByteDenorm=maxTwoByteMatch+1;//Amount to add to length when compression is 3 bytes - atUint16 maxThreeByteMatch=0xFF+threeByteDenorm; - atUint16 fourByteDenorm=maxThreeByteMatch+1; + atUint8 maxTwoByteMatch = 0xF + 1; + atUint8 threeByteDenorm = maxTwoByteMatch + 1; //Amount to add to length when compression is 3 bytes + atUint16 maxThreeByteMatch = 0xFF + threeByteDenorm; + atUint16 fourByteDenorm = maxThreeByteMatch + 1; - while(inputPtr>(7-i)) & 0x1) + if ((isCompressed >> (7 - i)) & 0x1) { - atUint8 metaDataSize=*inputPtr >> 4;//Look at the top 4 bits - if(metaDataSize >= 2){ //Two Bytes of Length/Offset MetaData - atUint16 lenOff=0; - memcpy(&lenOff,inputPtr,2); - inputPtr+=2; + atUint8 metaDataSize = *inputPtr >> 4; //Look at the top 4 bits + + if (metaDataSize >= 2) //Two Bytes of Length/Offset MetaData + { + atUint16 lenOff = 0; + memcpy(&lenOff, inputPtr, 2); + inputPtr += 2; Athena::utility::BigUint16(lenOff); - decoding.length=(lenOff>>12)+1; - decoding.offset=(lenOff & 0xFFF) + 1; + decoding.length = (lenOff >> 12) + 1; + decoding.offset = (lenOff & 0xFFF) + 1; } - else if (metaDataSize==0){ //Three Bytes of Length/Offset MetaData - atUint32 lenOff=0; - memcpy((atUint8*)&lenOff+1,inputPtr,3); - inputPtr+=3; + else if (metaDataSize == 0) //Three Bytes of Length/Offset MetaData + { + atUint32 lenOff = 0; + memcpy((atUint8*)&lenOff + 1, inputPtr, 3); + inputPtr += 3; Athena::utility::BigUint32(lenOff); - decoding.length=(lenOff>>12)+threeByteDenorm; - decoding.offset=(lenOff & 0xFFF) + 1; + decoding.length = (lenOff >> 12) + threeByteDenorm; + decoding.offset = (lenOff & 0xFFF) + 1; } - else if(metaDataSize==1){ //Four Bytes of Length/Offset MetaData - atUint32 lenOff=0; - memcpy(&lenOff,inputPtr,4); - inputPtr+=4; + else if (metaDataSize == 1) //Four Bytes of Length/Offset MetaData + { + atUint32 lenOff = 0; + memcpy(&lenOff, inputPtr, 4); + inputPtr += 4; Athena::utility::BigUint32(lenOff); - decoding.length=((lenOff>>12) & 0xFFFF)+fourByteDenorm; //Gets rid of the Four byte flag - decoding.offset=(lenOff & 0xFFF) + 1; + decoding.length = ((lenOff >> 12) & 0xFFFF) + fourByteDenorm; //Gets rid of the Four byte flag + decoding.offset = (lenOff & 0xFFF) + 1; } - else{ + else + { delete[] uncompressedData; uncompressedData = nullptr; return 0; } - if((outputPtr - decoding.offset) < uncompressedData){//If the offset to look for uncompressed is passed the current uncompresed data then the data is not compressed + if ((outputPtr - decoding.offset) < uncompressedData) //If the offset to look for uncompressed is passed the current uncompresed data then the data is not compressed + { delete []uncompressedData; return 0; } - for(atUint32 j=0;j>8); - b[2]=(atUint8)(a>>16); - b[3]=(atUint8)(a>>24); +static void unpack(atUint32 a, atUint8* b) +{ + /* unpack bytes from a word */ + b[0] = (atUint8)a; + b[1] = (atUint8)(a >> 8); + b[2] = (atUint8)(a >> 16); + b[3] = (atUint8)(a >> 24); } static atUint8 xtime(atUint8 a) { atUint8 b; - if (a&0x80) b=0x1B; - else b=0; - a<<=1; - a^=b; + + if (a & 0x80) b = 0x1B; + else b = 0; + + a <<= 1; + a ^= b; return a; } -static atUint8 bmul(atUint8 x,atUint8 y) -{ /* x.y= AntiLog(Log(x) + Log(y)) */ - if (x && y) return ptab[(ltab[x]+ltab[y])%255]; +static atUint8 bmul(atUint8 x, atUint8 y) +{ + /* x.y= AntiLog(Log(x) + Log(y)) */ + if (x && y) return ptab[(ltab[x] + ltab[y]) % 255]; else return 0; } static atUint32 SubByte(atUint32 a) { atUint8 b[4]; - unpack(a,b); - b[0]=fbsub[b[0]]; - b[1]=fbsub[b[1]]; - b[2]=fbsub[b[2]]; - b[3]=fbsub[b[3]]; + unpack(a, b); + b[0] = fbsub[b[0]]; + b[1] = fbsub[b[1]]; + b[2] = fbsub[b[2]]; + b[3] = fbsub[b[3]]; return pack(b); } -static atUint8 product(atUint32 x,atUint32 y) -{ /* dot product of two 4-byte arrays */ - atUint8 xb[4],yb[4]; - unpack(x,xb); - unpack(y,yb); - return bmul(xb[0],yb[0])^bmul(xb[1],yb[1])^bmul(xb[2],yb[2])^bmul(xb[3],yb[3]); +static atUint8 product(atUint32 x, atUint32 y) +{ + /* dot product of two 4-byte arrays */ + atUint8 xb[4], yb[4]; + unpack(x, xb); + unpack(y, yb); + return bmul(xb[0], yb[0])^bmul(xb[1], yb[1])^bmul(xb[2], yb[2])^bmul(xb[3], yb[3]); } static atUint32 InvMixCol(atUint32 x) -{ /* matrix Multiplication */ - atUint32 y,m; +{ + /* matrix Multiplication */ + atUint32 y, m; atUint8 b[4]; - m=pack(InCo); - b[3]=product(m,x); - m=ROTL24(m); - b[2]=product(m,x); - m=ROTL24(m); - b[1]=product(m,x); - m=ROTL24(m); - b[0]=product(m,x); - y=pack(b); + m = pack(InCo); + b[3] = product(m, x); + m = ROTL24(m); + b[2] = product(m, x); + m = ROTL24(m); + b[1] = product(m, x); + m = ROTL24(m); + b[0] = product(m, x); + y = pack(b); return y; } atUint8 ByteSub(atUint8 x) { - atUint8 y=ptab[255-ltab[x]]; /* multiplicative inverse */ - x=y; x=ROTL(x); - y^=x; x=ROTL(x); - y^=x; x=ROTL(x); - y^=x; x=ROTL(x); - y^=x; y^=0x63; + atUint8 y = ptab[255 - ltab[x]]; /* multiplicative inverse */ + x = y; + x = ROTL(x); + y ^= x; + x = ROTL(x); + y ^= x; + x = ROTL(x); + y ^= x; + x = ROTL(x); + y ^= x; + y ^= 0x63; return y; } void gentables(void) -{ /* generate tables */ +{ + /* generate tables */ int i; - atUint8 y,b[4]; + atUint8 y, b[4]; /* use 3 as primitive root to generate power and log tables */ - ltab[0]=0; - ptab[0]=1; ltab[1]=0; - ptab[1]=3; ltab[3]=1; - for (i=2;i<256;i++) + ltab[0] = 0; + ptab[0] = 1; + ltab[1] = 0; + ptab[1] = 3; + ltab[3] = 1; + + for (i = 2; i < 256; i++) { - ptab[i]=ptab[i-1]^xtime(ptab[i-1]); - ltab[ptab[i]]=i; + ptab[i] = ptab[i - 1] ^ xtime(ptab[i - 1]); + ltab[ptab[i]] = i; } /* affine transformation:- each bit is xored with itself shifted one bit */ - fbsub[0]=0x63; - rbsub[0x63]=0; - for (i=1;i<256;i++) + fbsub[0] = 0x63; + rbsub[0x63] = 0; + + for (i = 1; i < 256; i++) { - y=ByteSub((atUint8)i); - fbsub[i]=y; rbsub[y]=i; + y = ByteSub((atUint8)i); + fbsub[i] = y; + rbsub[y] = i; } - for (i=0,y=1;i<30;i++) + for (i = 0, y = 1; i < 30; i++) { - rco[i]=y; - y=xtime(y); + rco[i] = y; + y = xtime(y); } /* calculate forward and reverse tables */ - for (i=0;i<256;i++) + for (i = 0; i < 256; i++) { - y=fbsub[i]; - b[3]=y^xtime(y); b[2]=y; - b[1]=y; b[0]=xtime(y); - ftable[i]=pack(b); + y = fbsub[i]; + b[3] = y ^ xtime(y); + b[2] = y; + b[1] = y; + b[0] = xtime(y); + ftable[i] = pack(b); - y=rbsub[i]; - b[3]=bmul(InCo[0],y); b[2]=bmul(InCo[1],y); - b[1]=bmul(InCo[2],y); b[0]=bmul(InCo[3],y); - rtable[i]=pack(b); + y = rbsub[i]; + b[3] = bmul(InCo[0], y); + b[2] = bmul(InCo[1], y); + b[1] = bmul(InCo[2], y); + b[0] = bmul(InCo[3], y); + rtable[i] = pack(b); } } -void gkey(int nb,int nk, const atUint8 *key) -{ /* blocksize=32*nb bits. Key=32*nk bits */ +void gkey(int nb, int nk, const atUint8* key) +{ + /* blocksize=32*nb bits. Key=32*nk bits */ /* currently nb,bk = 4, 6 or 8 */ /* key comes as 4*Nk bytes */ /* Key Scheduler. Create expanded encryption key */ - int i,j,k,m,N; - int C1,C2,C3; + int i, j, k, m, N; + int C1, C2, C3; atUint32 CipherKey[8]; - Nb=nb; Nk=nk; + Nb = nb; + Nk = nk; /* Nr is number of rounds */ - if (Nb>=Nk) Nr=6+Nb; - else Nr=6+Nk; + if (Nb >= Nk) Nr = 6 + Nb; + else Nr = 6 + Nk; - C1=1; - if (Nb<8) { C2=2; C3=3; } - else { C2=3; C3=4; } + C1 = 1; + + if (Nb < 8) { C2 = 2; C3 = 3; } + else { C2 = 3; C3 = 4; } /* pre-calculate forward and reverse increments */ - for (m=j=0;j>8)])^ - ROTL16(ftable[(atUint8)(x[fi[m+1]]>>16)])^ - ROTL24(ftable[(atUint8)(x[fi[m+2]]>>24)]); + y[j] = fkey[k++] ^ ftable[(atUint8)x[j]] ^ + ROTL8(ftable[(atUint8)(x[fi[m]] >> 8)])^ + ROTL16(ftable[(atUint8)(x[fi[m + 1]] >> 16)])^ + ROTL24(ftable[(atUint8)(x[fi[m + 2]] >> 24)]); } - t=x; x=y; y=t; /* swap pointers */ + + t = x; + x = y; + y = t; /* swap pointers */ } /* Last Round - unroll if possible */ - for (m=j=0;j>8)])^ - ROTL16((atUint32)fbsub[(atUint8)(x[fi[m+1]]>>16)])^ - ROTL24((atUint32)fbsub[(atUint8)(x[fi[m+2]]>>24)]); + y[j] = fkey[k++] ^ (atUint32)fbsub[(atUint8)x[j]] ^ + ROTL8((atUint32)fbsub[(atUint8)(x[fi[m]] >> 8)])^ + ROTL16((atUint32)fbsub[(atUint8)(x[fi[m + 1]] >> 16)])^ + ROTL24((atUint32)fbsub[(atUint8)(x[fi[m + 2]] >> 24)]); } - for (i=j=0;i>8)])^ - ROTL16(rtable[(atUint8)(x[ri[m+1]]>>16)])^ - ROTL24(rtable[(atUint8)(x[ri[m+2]]>>24)]); + for (m = j = 0; j < Nb; j++, m += 3) + { + /* This is the time-critical bit */ + y[j] = rkey[k++] ^ rtable[(atUint8)x[j]] ^ + ROTL8(rtable[(atUint8)(x[ri[m]] >> 8)])^ + ROTL16(rtable[(atUint8)(x[ri[m + 1]] >> 16)])^ + ROTL24(rtable[(atUint8)(x[ri[m + 2]] >> 24)]); } - t=x; x=y; y=t; /* swap pointers */ + + t = x; + x = y; + y = t; /* swap pointers */ } /* Last Round - unroll if possible */ - for (m=j=0;j>8)])^ - ROTL16((atUint32)rbsub[(atUint8)(x[ri[m+1]]>>16)])^ - ROTL24((atUint32)rbsub[(atUint8)(x[ri[m+2]]>>24)]); + y[j] = rkey[k++] ^ (atUint32)rbsub[(atUint8)x[j]] ^ + ROTL8((atUint32)rbsub[(atUint8)(x[ri[m]] >> 8)])^ + ROTL16((atUint32)rbsub[(atUint8)(x[ri[m + 1]] >> 16)])^ + ROTL24((atUint32)rbsub[(atUint8)(x[ri[m + 2]] >> 24)]); } - for (i=j=0;i b[i]) return 1; } @@ -31,28 +33,32 @@ int bn_compare(atUint8 *a, atUint8 *b, atUint32 n) return 0; } -void bn_sub_modulus(atUint8 *a, atUint8 *N, atUint32 n) +void bn_sub_modulus(atUint8* a, atUint8* N, atUint32 n) { atUint32 i; atUint32 dig; atUint8 c; c = 0; - for (i = n - 1; i < n; i--) { + + for (i = n - 1; i < n; i--) + { dig = N[i] + c; c = (a[i] < dig); a[i] -= dig; } } -void bn_add(atUint8 *d, atUint8 *a, atUint8 *b, atUint8 *N, atUint32 n) +void bn_add(atUint8* d, atUint8* a, atUint8* b, atUint8* N, atUint32 n) { atUint32 i; atUint32 dig; atUint8 c; c = 0; - for (i = n - 1; i < n; i--) { + + for (i = n - 1; i < n; i--) + { dig = a[i] + b[i] + c; c = (dig >= 0x100); d[i] = dig; @@ -65,7 +71,7 @@ void bn_add(atUint8 *d, atUint8 *a, atUint8 *b, atUint8 *N, atUint32 n) bn_sub_modulus(d, N, n); } -void bn_mul(atUint8 *d, atUint8 *a, atUint8 *b, atUint8 *N, atUint32 n) +void bn_mul(atUint8* d, atUint8* a, atUint8* b, atUint8* N, atUint32 n) { atUint32 i; atUint8 mask; @@ -73,24 +79,29 @@ void bn_mul(atUint8 *d, atUint8 *a, atUint8 *b, atUint8 *N, atUint32 n) bn_zero(d, n); for (i = 0; i < n; i++) - for (mask = 0x80; mask != 0; mask >>= 1) { + for (mask = 0x80; mask != 0; mask >>= 1) + { bn_add(d, d, d, N, n); + if ((a[i] & mask) != 0) bn_add(d, d, b, N, n); } } -void bn_exp(atUint8 *d, atUint8 *a, atUint8 *N, atUint32 n, atUint8 *e, atUint32 en) +void bn_exp(atUint8* d, atUint8* a, atUint8* N, atUint32 n, atUint8* e, atUint32 en) { atUint8 t[512]; atUint32 i; atUint8 mask; bn_zero(d, n); - d[n-1] = 1; + d[n - 1] = 1; + for (i = 0; i < en; i++) - for (mask = 0x80; mask != 0; mask >>= 1) { + for (mask = 0x80; mask != 0; mask >>= 1) + { bn_mul(t, d, d, N, n); + if ((e[i] & mask) != 0) bn_mul(d, t, a, N, n); else @@ -99,13 +110,13 @@ void bn_exp(atUint8 *d, atUint8 *a, atUint8 *N, atUint32 n, atUint8 *e, atUint32 } // only for prime N -- stupid but lazy, see if I care -void bn_inv(atUint8 *d, atUint8 *a, atUint8 *N, atUint32 n) +void bn_inv(atUint8* d, atUint8* a, atUint8* N, atUint32 n) { atUint8 t[512], s[512]; bn_copy(t, N, n); bn_zero(s, n); - s[n-1] = 2; + s[n - 1] = 2; bn_sub_modulus(t, s, n); bn_exp(d, a, N, n, t, n); } diff --git a/src/ec.cpp b/src/ec.cpp index ffe4b07..0258d6b 100644 --- a/src/ec.cpp +++ b/src/ec.cpp @@ -20,13 +20,15 @@ */ // order of the addition group of points static atUint8 ec_N[30] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x13, 0xe9, 0x74, 0xe7, 0x2f, 0x8a, 0x69, 0x22, 0x03, 0x1d, 0x26, 0x03, 0xcf, 0xe0, 0xd7 }; + 0x13, 0xe9, 0x74, 0xe7, 0x2f, 0x8a, 0x69, 0x22, 0x03, 0x1d, 0x26, 0x03, 0xcf, 0xe0, 0xd7 + }; // base point static atUint8 ec_G[60] = { 0x00, 0xfa, 0xc9, 0xdf, 0xcb, 0xac, 0x83, 0x13, 0xbb, 0x21, 0x39, 0xf1, 0xbb, 0x75, 0x5f, - 0xef, 0x65, 0xbc, 0x39, 0x1f, 0x8b, 0x36, 0xf8, 0xf8, 0xeb, 0x73, 0x71, 0xfd, 0x55, 0x8b, - 0x01, 0x00, 0x6a, 0x08, 0xa4, 0x19, 0x03, 0x35, 0x06, 0x78, 0xe5, 0x85, 0x28, 0xbe, 0xbf, - 0x8a, 0x0b, 0xef, 0xf8, 0x67, 0xa7, 0xca, 0x36, 0x71, 0x6f, 0x7e, 0x01, 0xf8, 0x10, 0x52 }; + 0xef, 0x65, 0xbc, 0x39, 0x1f, 0x8b, 0x36, 0xf8, 0xf8, 0xeb, 0x73, 0x71, 0xfd, 0x55, 0x8b, + 0x01, 0x00, 0x6a, 0x08, 0xa4, 0x19, 0x03, 0x35, 0x06, 0x78, 0xe5, 0x85, 0x28, 0xbe, 0xbf, + 0x8a, 0x0b, 0xef, 0xf8, 0x67, 0xa7, 0xca, 0x36, 0x71, 0x6f, 0x7e, 0x01, 0xf8, 0x10, 0x52 + }; /* static void elt_print(char *name, u8 *a) { @@ -40,17 +42,17 @@ static void elt_print(char *name, u8 *a) printf("\n"); } */ -static void elt_copy(atUint8 *d, atUint8 *a) +static void elt_copy(atUint8* d, atUint8* a) { memcpy(d, a, 30); } -static void elt_zero(atUint8 *d) +static void elt_zero(atUint8* d) { memset(d, 0, 30); } -static int elt_is_zero(atUint8 *d) +static int elt_is_zero(atUint8* d) { atUint32 i; @@ -61,7 +63,7 @@ static int elt_is_zero(atUint8 *d) return 1; } -static void elt_add(atUint8 *d, atUint8 *a, atUint8 *b) +static void elt_add(atUint8* d, atUint8* a, atUint8* b) { atUint32 i; @@ -69,7 +71,7 @@ static void elt_add(atUint8 *d, atUint8 *a, atUint8 *b) d[i] = a[i] ^ b[i]; } -static void elt_mul_x(atUint8 *d, atUint8 *a) +static void elt_mul_x(atUint8* d, atUint8* a) { atUint8 carry, x, y; atUint32 i; @@ -77,17 +79,20 @@ static void elt_mul_x(atUint8 *d, atUint8 *a) carry = a[0] & 1; x = 0; - for (i = 0; i < 29; i++) { + + for (i = 0; i < 29; i++) + { y = a[i + 1]; d[i] = x ^ (y >> 7); x = y << 1; } + d[29] = x ^ carry; d[20] ^= carry << 2; } -static void elt_mul(atUint8 *d, atUint8 *a, atUint8 *b) +static void elt_mul(atUint8* d, atUint8* a, atUint8* b) { atUint32 i, n; atUint8 mask; @@ -96,14 +101,18 @@ static void elt_mul(atUint8 *d, atUint8 *a, atUint8 *b) i = 0; mask = 1; - for (n = 0; n < 233; n++) { + + for (n = 0; n < 233; n++) + { elt_mul_x(d, d); if ((a[i] & mask) != 0) elt_add(d, d, b); mask >>= 1; - if (mask == 0) { + + if (mask == 0) + { mask = 0x80; i++; } @@ -112,22 +121,24 @@ static void elt_mul(atUint8 *d, atUint8 *a, atUint8 *b) static const atUint8 square[16] = { 0x00, 0x01, 0x04, 0x05, 0x10, 0x11, 0x14, 0x15, 0x40, 0x41, 0x44, 0x45, 0x50, 0x51, 0x54, 0x55 }; -static void elt_square_to_wide(atUint8 *d, atUint8 *a) +static void elt_square_to_wide(atUint8* d, atUint8* a) { atUint32 i; - for (i = 0; i < 30; i++) { - d[2*i] = square[a[i] >> 4]; - d[2*i + 1] = square[a[i] & 15]; + for (i = 0; i < 30; i++) + { + d[2 * i] = square[a[i] >> 4]; + d[2 * i + 1] = square[a[i] & 15]; } } -static void wide_reduce(atUint8 *d) +static void wide_reduce(atUint8* d) { atUint32 i; atUint8 x; - for (i = 0; i < 30; i++) { + for (i = 0; i < 30; i++) + { x = d[i]; d[i + 19] ^= x >> 7; @@ -147,7 +158,7 @@ static void wide_reduce(atUint8 *d) d[30] &= 1; } -static void elt_square(atUint8 *d, atUint8 *a) +static void elt_square(atUint8* d, atUint8* a) { atUint8 wide[60]; @@ -157,12 +168,14 @@ static void elt_square(atUint8 *d, atUint8 *a) elt_copy(d, wide + 30); } -static void itoh_tsujii(atUint8 *d, atUint8 *a, atUint8 *b, atUint32 j) +static void itoh_tsujii(atUint8* d, atUint8* a, atUint8* b, atUint32 j) { atUint8 t[30]; elt_copy(t, a); - while (j--) { + + while (j--) + { elt_square(d, t); elt_copy(t, d); } @@ -170,7 +183,7 @@ static void itoh_tsujii(atUint8 *d, atUint8 *a, atUint8 *b, atUint32 j) elt_mul(d, t, b); } -static void elt_inv(atUint8 *d, atUint8 *a) +static void elt_inv(atUint8* d, atUint8* a) { atUint8 t[30]; atUint8 s[30]; @@ -212,22 +225,23 @@ static int point_is_on_curve(u8 *p) return elt_is_zero(s); } */ -static int point_is_zero(atUint8 *p) +static int point_is_zero(atUint8* p) { return elt_is_zero(p) && elt_is_zero(p + 30); } -static void point_double(atUint8 *r, atUint8 *p) +static void point_double(atUint8* r, atUint8* p) { atUint8 s[30], t[30]; - atUint8 *px, *py, *rx, *ry; + atUint8* px, *py, *rx, *ry; px = p; py = p + 30; rx = r; ry = r + 30; - if (elt_is_zero(px)) { + if (elt_is_zero(px)) + { elt_zero(rx); elt_zero(ry); @@ -249,10 +263,10 @@ static void point_double(atUint8 *r, atUint8 *p) elt_add(ry, ry, t); } -static void point_add(atUint8 *r, atUint8 *p, atUint8 *q) +static void point_add(atUint8* r, atUint8* p, atUint8* q) { atUint8 s[30], t[30], u[30]; - atUint8 *px, *py, *qx, *qy, *rx, *ry; + atUint8* px, *py, *qx, *qy, *rx, *ry; px = p; py = p + 30; @@ -261,13 +275,15 @@ static void point_add(atUint8 *r, atUint8 *p, atUint8 *q) rx = r; ry = r + 30; - if (point_is_zero(p)) { + if (point_is_zero(p)) + { elt_copy(rx, qx); elt_copy(ry, qy); return; } - if (point_is_zero(q)) { + if (point_is_zero(q)) + { elt_copy(rx, px); elt_copy(ry, py); return; @@ -275,11 +291,14 @@ static void point_add(atUint8 *r, atUint8 *p, atUint8 *q) elt_add(u, px, qx); - if (elt_is_zero(u)) { + if (elt_is_zero(u)) + { elt_add(u, py, qy); + if (elt_is_zero(u)) point_double(r, p); - else { + else + { elt_zero(rx); elt_zero(ry); } @@ -302,7 +321,7 @@ static void point_add(atUint8 *r, atUint8 *p, atUint8 *q) elt_add(ry, s, rx); } -static void point_mul(atUint8 *d, atUint8 *a, atUint8 *b) // a is bignum +static void point_mul(atUint8* d, atUint8* a, atUint8* b) // a is bignum { atUint32 i; atUint8 mask; @@ -311,14 +330,16 @@ static void point_mul(atUint8 *d, atUint8 *a, atUint8 *b) // a is bignum elt_zero(d + 30); for (i = 0; i < 30; i++) - for (mask = 0x80; mask != 0; mask >>= 1) { + for (mask = 0x80; mask != 0; mask >>= 1) + { point_double(d, d); + if ((a[i] & mask) != 0) point_add(d, d, b); } } -void generate_ecdsa(atUint8 *R, atUint8 *S, atUint8 *k, atUint8 *hash) +void generate_ecdsa(atUint8* R, atUint8* S, atUint8* k, atUint8* hash) { atUint8 e[30]; atUint8 kk[30]; @@ -333,25 +354,28 @@ void generate_ecdsa(atUint8 *R, atUint8 *S, atUint8 *k, atUint8 *hash) Athena::utility::fillRandom(m, sizeof(m)); m[0] = 0; - // R = (mG).x + // R = (mG).x point_mul(mG, m, ec_G); elt_copy(R, mG); + if (bn_compare(R, ec_N, 30) >= 0) bn_sub_modulus(R, ec_N, 30); - // S = m**-1*(e + Rk) (mod N) + // S = m**-1*(e + Rk) (mod N) elt_copy(kk, k); + if (bn_compare(kk, ec_N, 30) >= 0) bn_sub_modulus(kk, ec_N, 30); + bn_mul(S, R, kk, ec_N, 30); bn_add(kk, S, e, ec_N, 30); bn_inv(minv, m, ec_N, 30); bn_mul(S, minv, kk, ec_N, 30); } -bool check_ecdsa(atUint8 *Q, atUint8 *R, atUint8 *S, atUint8 *hash) +bool check_ecdsa(atUint8* Q, atUint8* R, atUint8* S, atUint8* hash) { atUint8 Sinv[30]; atUint8 e[30]; @@ -377,44 +401,49 @@ bool check_ecdsa(atUint8 *Q, atUint8 *R, atUint8 *S, atUint8 *hash) return (bn_compare(r1, R, 30) == 0); } -void ec_priv_to_pub(atUint8 *k, atUint8 *Q) +void ec_priv_to_pub(atUint8* k, atUint8* Q) { point_mul(Q, k, ec_G); } -bool check_ec(atUint8 *ng, atUint8 *ap, atUint8 *sig, atUint8 *sig_hash) +bool check_ec(atUint8* ng, atUint8* ap, atUint8* sig, atUint8* sig_hash) { atUint8* ap_hash; - atUint8 *ng_Q, *ap_R, *ap_S; - atUint8 *ap_Q, *sig_R, *sig_S; + atUint8* ng_Q, *ap_R, *ap_S; + atUint8* ap_Q, *sig_R, *sig_S; ng_Q = ng + 0x0108; ap_R = ap + 0x04; ap_S = ap + 0x22; - ap_hash = getSha1(ap+0x80, 0x100); + ap_hash = getSha1(ap + 0x80, 0x100); ap_Q = ap + 0x0108; sig_R = sig; sig_S = sig + 30; return check_ecdsa(ng_Q, ap_R, ap_S, ap_hash) - && check_ecdsa(ap_Q, sig_R, sig_S, sig_hash); + && check_ecdsa(ap_Q, sig_R, sig_S, sig_hash); } -void make_ec_cert(atUint8 *cert, atUint8 *sig, char *signer, char *name, atUint8 *priv, atUint32 key_id ) +void make_ec_cert(atUint8* cert, atUint8* sig, char* signer, char* name, atUint8* priv, atUint32 key_id) { memset(cert, 0, 0x180); *(atUint32*)(cert) = 0x10002; + if (!Athena::utility::isSystemBigEndian()) *(atUint32*)(cert) = Athena::utility::swapU32(*(atUint32*)(cert)); + memcpy((char*)cert + 4, sig, 60); strcpy((char*)cert + 0x80, signer); *(atUint32*)(cert + 0xc0) = 2; + if (!Athena::utility::isSystemBigEndian()) *(atUint32*)(cert + 0xc0) = Athena::utility::swapU32(*(atUint32*)(cert + 0xc0)); + strcpy((char*)cert + 0xc4, name); *(atUint32*)(cert + 0x104) = key_id; + if (!Athena::utility::isSystemBigEndian()) *(atUint32*)(cert + 0x104) = Athena::utility::swapU32(*(atUint32*)(cert + 0x104)); diff --git a/src/md5.cpp b/src/md5.cpp index 4597cd5..213c647 100644 --- a/src/md5.cpp +++ b/src/md5.cpp @@ -1,6 +1,6 @@ /* ========================================================================== ** * - * MD5.c + * MD5.c * * Copyright: * Copyright (C) 2003-2005 by Christopher R. Hertel @@ -50,15 +50,15 @@ * * There are three primary motivations for this particular implementation. * 1) Programmer's pride. I wanted to be able to say I'd done it, and I - * wanted to learn from the experience. + * wanted to learn from the experience. * 2) Portability. I wanted an implementation that I knew to be portable - * to a reasonable number of platforms. In particular, the algorithm is - * designed with little-endian platforms in mind, but I wanted an - * endian-agnostic implementation. + * to a reasonable number of platforms. In particular, the algorithm is + * designed with little-endian platforms in mind, but I wanted an + * endian-agnostic implementation. * 3) Compactness. While not an overriding goal, I thought it worth-while - * to see if I could reduce the overall size of the result. This is in - * keeping with my hopes that this library will be suitable for use in - * some embedded environments. + * to see if I could reduce the overall size of the result. This is in + * keeping with my hopes that this library will be suitable for use in + * some embedded environments. * Beyond that, cleanliness and clarity are always worth pursuing. * * As mentioned above, the code really only makes sense if you are familiar @@ -71,7 +71,7 @@ * * References: * IETF RFC 1321: The MD5 Message-Digest Algorithm - * Ron Rivest. IETF, April, 1992 + * Ron Rivest. IETF, April, 1992 * * ========================================================================== ** */ @@ -98,26 +98,27 @@ namespace MD5Hash * Static Constants: * * K[][] - In round one, the values of k (which are used to index - * particular four-byte sequences in the input) are simply - * sequential. In later rounds, however, they are a bit more - * varied. Rather than calculate the values of k (which may - * or may not be possible--I haven't though about it) the - * values are stored in this array. + * particular four-byte sequences in the input) are simply + * sequential. In later rounds, however, they are a bit more + * varied. Rather than calculate the values of k (which may + * or may not be possible--I haven't though about it) the + * values are stored in this array. * * S[][] - In each round there is a left rotate operation performed as - * part of the 16 permutations. The number of bits varies in - * a repeating patter. This array keeps track of the patterns - * used in each round. + * part of the 16 permutations. The number of bits varies in + * a repeating patter. This array keeps track of the patterns + * used in each round. * * T[][] - There are four rounds of 16 permutations for a total of 64. - * In each of these 64 permutation operations, a different - * constant value is added to the mix. The constants are - * based on the sine function...read RFC 1321 for more detail. - * In any case, the correct constants are stored in the T[][] - * array. They're divided up into four groups of 16. + * In each of these 64 permutation operations, a different + * constant value is added to the mix. The constants are + * based on the sine function...read RFC 1321 for more detail. + * In any case, the correct constants are stored in the T[][] + * array. They're divided up into four groups of 16. */ -static const uint8_t K[3][16] = { +static const uint8_t K[3][16] = +{ /* Round 1: skipped (since it is simply sequential). */ { 1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12 }, /* R2 */ { 5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2 }, /* R3 */ @@ -125,26 +126,35 @@ static const uint8_t K[3][16] = { }; static const uint8_t S[4][4] = { { 7, 12, 17, 22 }, /* Round 1 */ - { 5, 9, 14, 20 }, /* Round 2 */ - { 4, 11, 16, 23 }, /* Round 3 */ - { 6, 10, 15, 21 } /* Round 4 */ - }; + { 5, 9, 14, 20 }, /* Round 2 */ + { 4, 11, 16, 23 }, /* Round 3 */ + { 6, 10, 15, 21 } /* Round 4 */ +}; -static const uint32_t T[4][16] = { { 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, /* Round 1 */ - 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, - 0xa679438e, 0x49b40821 }, +static const uint32_t T[4][16] = { { + 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, /* Round 1 */ + 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, + 0xa679438e, 0x49b40821 + }, - { 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, /* Round 2 */ - 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, - 0x676f02d9, 0x8d2a4c8a }, + { + 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, /* Round 2 */ + 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, + 0x676f02d9, 0x8d2a4c8a + }, - { 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, /* Round 3 */ - 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, - 0x1fa27cf8, 0xc4ac5665 }, + { + 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, /* Round 3 */ + 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, + 0x1fa27cf8, 0xc4ac5665 + }, - { 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, /* Round 4 */ - 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, - 0x2ad7d2bb, 0xeb86d391 }, }; + { + 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, /* Round 4 */ + 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, + 0x2ad7d2bb, 0xeb86d391 + }, +}; /* -------------------------------------------------------------------------- ** * Macros: @@ -152,9 +162,9 @@ static const uint32_t T[4][16] = { { 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdc * All of these operations are bitwise, and so not impacted by endian-ness. * * GetLongByte() - * Extract one byte from a (32-bit) longword. A value of 0 for - * indicates the lowest order byte, while 3 indicates the highest order - * byte. + * Extract one byte from a (32-bit) longword. A value of 0 for + * indicates the lowest order byte, while 3 indicates the highest order + * byte. * */ @@ -176,31 +186,31 @@ static void Permute(uint32_t ABCD[4], const unsigned char block[64]) * Permute the ABCD "registers" using the 64-byte as a driver. * * Input: ABCD - Pointer to an array of four unsigned longwords. - * block - An array of bytes, 64 bytes in size. + * block - An array of bytes, 64 bytes in size. * * Output: none. * * Notes: The MD5 algorithm operates on a set of four longwords stored - * (conceptually) in four "registers". It is easy to imagine a - * simple MD4/5 chip that would operate this way. In any case, - * the mangling of the contents of those registers is driven by - * the input message. The message is chopped and finally padded - * into 64-byte chunks and each chunk is used to manipulate the - * contents of the registers. + * (conceptually) in four "registers". It is easy to imagine a + * simple MD4/5 chip that would operate this way. In any case, + * the mangling of the contents of those registers is driven by + * the input message. The message is chopped and finally padded + * into 64-byte chunks and each chunk is used to manipulate the + * contents of the registers. * - * The MD5 Algorithm calls for padding the input to ensure that - * it is a multiple of 64 bytes in length. The last 16 bytes - * of the padding space are used to store the message length - * (the length of the original message, before padding, expressed - * in terms of bits). If there is not enough room for 16 bytes - * worth of bitcount (eg., if the original message was 122 bytes - * long) then the block is padded to the end with zeros and - * passed to this function. Then *another* block is filled with - * zeros except for the last 16 bytes which contain the length. + * The MD5 Algorithm calls for padding the input to ensure that + * it is a multiple of 64 bytes in length. The last 16 bytes + * of the padding space are used to store the message length + * (the length of the original message, before padding, expressed + * in terms of bits). If there is not enough room for 16 bytes + * worth of bitcount (eg., if the original message was 122 bytes + * long) then the block is padded to the end with zeros and + * passed to this function. Then *another* block is filled with + * zeros except for the last 16 bytes which contain the length. * - * Oh... and the algorithm requires that there be at least one - * padding byte. The first padding byte has a value of 0x80, - * and any others are 0x00. + * Oh... and the algorithm requires that there be at least one + * padding byte. The first padding byte has a value of 0x80, + * and any others are 0x00. * * ------------------------------------------------------------------------ ** */ @@ -232,7 +242,7 @@ static void Permute(uint32_t ABCD[4], const unsigned char block[64]) /* This loop performs the four rounds of permutations. * The rounds are each very similar. The differences are in three areas: * - The function (F, G, H, or I) used to perform bitwise permutations - * on the registers, + * on the registers, * - The order in which values from X[] are chosen. * - Changes to the number of bits by which the registers are rotated. * This implementation uses a switch statement to deal with some of the @@ -247,7 +257,7 @@ static void Permute(uint32_t ABCD[4], const unsigned char block[64]) { for (i = 0; i < 16; i++) { - j = (4 - (i % 4)) & 0x3; /* handles the rotation of ABCD. */ + j = (4 - (i % 4)) & 0x3; /* handles the rotation of ABCD. */ s = S[round][i % 4]; /* is the bit shift for this iteration. */ b = ABCD[(j + 1) & 0x3]; /* Copy the b,c,d values per ABCD rotation. */ @@ -261,21 +271,25 @@ static void Permute(uint32_t ABCD[4], const unsigned char block[64]) { case 0: /* round 1 */ - a = md5F( b, c, d ) + X[i]; + a = md5F(b, c, d) + X[i]; break; + case 1: /* round 2 */ - a = md5G( b, c, d ) + X[K[0][i]]; + a = md5G(b, c, d) + X[K[0][i]]; break; + case 2: /* round 3 */ - a = md5H( b, c, d ) + X[K[1][i]]; + a = md5H(b, c, d) + X[K[1][i]]; break; + default: /* round 4 */ - a = md5I( b, c, d ) + X[K[2][i]]; + a = md5I(b, c, d) + X[K[2][i]]; break; } + a = 0xFFFFFFFF & (ABCD[j] + a + T[round][i]); ABCD[j] = b + (0xFFFFFFFF & ((a << s) | (a >> (32 - s)))); } @@ -293,29 +307,29 @@ static void Permute(uint32_t ABCD[4], const unsigned char block[64]) * Functions: */ -auth_md5Ctx *auth_md5InitCtx(auth_md5Ctx *ctx) +auth_md5Ctx* auth_md5InitCtx(auth_md5Ctx* ctx) /* ------------------------------------------------------------------------ ** * Initialize an MD5 context. * * Input: ctx - A pointer to the MD5 context structure to be initialized. - * Contexts are typically created thusly: - * ctx = (auth_md5Ctx *)malloc( sizeof(auth_md5Ctx) ); + * Contexts are typically created thusly: + * ctx = (auth_md5Ctx *)malloc( sizeof(auth_md5Ctx) ); * * Output: A pointer to the initialized context (same as ). * * Notes: The purpose of the context is to make it possible to generate - * an MD5 Message Digest in stages, rather than having to pass a - * single large block to a single MD5 function. The context - * structure keeps track of various bits of state information. + * an MD5 Message Digest in stages, rather than having to pass a + * single large block to a single MD5 function. The context + * structure keeps track of various bits of state information. * - * Once the context is initialized, the blocks of message data - * are passed to the function. Once the - * final bit of data has been handed to the - * context can be closed out by calling , - * which also calculates the final MD5 result. + * Once the context is initialized, the blocks of message data + * are passed to the function. Once the + * final bit of data has been handed to the + * context can be closed out by calling , + * which also calculates the final MD5 result. * - * Don't forget to free an allocated context structure when - * you've finished using it. + * Don't forget to free an allocated context structure when + * you've finished using it. * * See Also: , * @@ -326,29 +340,29 @@ auth_md5Ctx *auth_md5InitCtx(auth_md5Ctx *ctx) ctx->b_used = 0; ctx->ABCD[0] = 0x67452301; /* The array ABCD[] contains the four 4-byte */ - ctx->ABCD[1] = 0xefcdab89; /* "registers" that are manipulated to */ - ctx->ABCD[2] = 0x98badcfe; /* produce the MD5 digest. The input acts */ - ctx->ABCD[3] = 0x10325476; /* upon the registers, not the other way */ - /* 'round. The initial values are those */ + ctx->ABCD[1] = 0xefcdab89; /* "registers" that are manipulated to */ + ctx->ABCD[2] = 0x98badcfe; /* produce the MD5 digest. The input acts */ + ctx->ABCD[3] = 0x10325476; /* upon the registers, not the other way */ + /* 'round. The initial values are those */ /* given in RFC 1321 (pg. 4). Note, however, that RFC 1321 */ /* provides these values as bytes, not as longwords, and the */ /* bytes are arranged in little-endian order as if they were */ - /* the bytes of (little endian) 32-bit ints. That's */ + /* the bytes of (little endian) 32-bit ints. That's */ /* confusing as all getout (to me, anyway). The values given */ /* here are provided as 32-bit values in C language format, */ /* so they are endian-agnostic. */ return (ctx); } /* auth_md5InitCtx */ -auth_md5Ctx *auth_md5SumCtx(auth_md5Ctx *ctx, const unsigned char *src, const int len) +auth_md5Ctx* auth_md5SumCtx(auth_md5Ctx* ctx, const unsigned char* src, const int len) /* ------------------------------------------------------------------------ ** * Build an MD5 Message Digest within the given context. * * Input: ctx - Pointer to the context in which the MD5 sum is being - * built. - * src - A chunk of source data. This will be used to drive - * the MD5 algorithm. - * len - The number of bytes in . + * built. + * src - A chunk of source data. This will be used to drive + * the MD5 algorithm. + * len - The number of bytes in . * * Output: A pointer to the updated context (same as ). * @@ -370,6 +384,7 @@ auth_md5Ctx *auth_md5SumCtx(auth_md5Ctx *ctx, const unsigned char *src, const in { ctx->block[ctx->b_used] = src[i]; (ctx->b_used)++; + if (64 == ctx->b_used) { Permute(ctx->ABCD, ctx->block); @@ -382,20 +397,20 @@ auth_md5Ctx *auth_md5SumCtx(auth_md5Ctx *ctx, const unsigned char *src, const in return (ctx); } /* auth_md5SumCtx */ -auth_md5Ctx *auth_md5CloseCtx(auth_md5Ctx *ctx, unsigned char *dst) +auth_md5Ctx* auth_md5CloseCtx(auth_md5Ctx* ctx, unsigned char* dst) /* ------------------------------------------------------------------------ ** * Close an MD5 Message Digest context and generate the final MD5 sum. * * Input: ctx - Pointer to the context in which the MD5 sum is being - * built. - * dst - A pointer to at least 16 bytes of memory, which will - * receive the finished MD5 sum. + * built. + * dst - A pointer to at least 16 bytes of memory, which will + * receive the finished MD5 sum. * * Output: A pointer to the closed context (same as ). - * You might use this to free a malloc'd context structure. :) + * You might use this to free a malloc'd context structure. :) * * Notes: The context () is returned in an undefined state. - * It must be re-initialized before re-use. + * It must be re-initialized before re-use. * * See Also: , * @@ -424,29 +439,32 @@ auth_md5Ctx *auth_md5CloseCtx(auth_md5Ctx *ctx, unsigned char *dst) if (56 < ctx->b_used) { Permute(ctx->ABCD, ctx->block); + for (i = 0; i < 64; i++) ctx->block[i] = 0; } /* Add the total length and perform the final perumation. * Note: The 60'th byte is read from the *original* len> value - * and shifted to the correct position. This neatly avoids - * any MAXINT numeric overflow issues. + * and shifted to the correct position. This neatly avoids + * any MAXINT numeric overflow issues. */ l = ctx->len << 3; + for (i = 0; i < 4; i++) - ctx->block[56 + i] |= GetLongByte( l, i ); - ctx->block[60] = ((GetLongByte( ctx->len, 3 ) & 0xE0) >> 5); /* See Above! */ + ctx->block[56 + i] |= GetLongByte(l, i); + + ctx->block[60] = ((GetLongByte(ctx->len, 3) & 0xE0) >> 5); /* See Above! */ Permute(ctx->ABCD, ctx->block); /* Now copy the result into the output buffer and we're done. */ for (i = 0; i < 4; i++) { - dst[0 + i] = GetLongByte( ctx->ABCD[0], i ); - dst[4 + i] = GetLongByte( ctx->ABCD[1], i ); - dst[8 + i] = GetLongByte( ctx->ABCD[2], i ); - dst[12 + i] = GetLongByte( ctx->ABCD[3], i ); + dst[0 + i] = GetLongByte(ctx->ABCD[0], i); + dst[4 + i] = GetLongByte(ctx->ABCD[1], i); + dst[8 + i] = GetLongByte(ctx->ABCD[2], i); + dst[12 + i] = GetLongByte(ctx->ABCD[3], i); } /* Return the context. @@ -455,34 +473,34 @@ auth_md5Ctx *auth_md5CloseCtx(auth_md5Ctx *ctx, unsigned char *dst) return (ctx); } /* auth_md5CloseCtx */ -unsigned char * MD5(unsigned char *dst, const unsigned char *src, const int len) +unsigned char* MD5(unsigned char* dst, const unsigned char* src, const int len) /* ------------------------------------------------------------------------ ** * Compute an MD5 message digest. * * Input: dst - Destination buffer into which the result will be written. - * Must be 16 bytes, minimum. - * src - Source data block to be MD5'd. - * len - The length, in bytes, of the source block. - * (Note that the length is given in bytes, not bits.) + * Must be 16 bytes, minimum. + * src - Source data block to be MD5'd. + * len - The length, in bytes, of the source block. + * (Note that the length is given in bytes, not bits.) * * Output: A pointer to , which will contain the calculated 16-byte - * MD5 message digest. + * MD5 message digest. * * Notes: This function is a shortcut. It takes a single input block. - * For more drawn-out operations, see . + * For more drawn-out operations, see . * - * This function is interface-compatible with the - * function in the MD4 module. + * This function is interface-compatible with the + * function in the MD4 module. * - * The MD5 algorithm is designed to work on data with an - * arbitrary *bit* length. Most implementations, this one - * included, handle the input data in byte-sized chunks. + * The MD5 algorithm is designed to work on data with an + * arbitrary *bit* length. Most implementations, this one + * included, handle the input data in byte-sized chunks. * - * The MD5 algorithm does much of its work using four-byte - * words, and so can be tuned for speed based on the endian-ness - * of the host. This implementation is intended to be - * endian-neutral, which may make it a teeny bit slower than - * others. ...maybe. + * The MD5 algorithm does much of its work using four-byte + * words, and so can be tuned for speed based on the endian-ness + * of the host. This implementation is intended to be + * endian-neutral, which may make it a teeny bit slower than + * others. ...maybe. * * See Also: * @@ -491,39 +509,39 @@ unsigned char * MD5(unsigned char *dst, const unsigned char *src, const int len) { auth_md5Ctx ctx[1]; - (void) auth_md5InitCtx(ctx); /* Open a context. */ + (void) auth_md5InitCtx(ctx); /* Open a context. */ (void) auth_md5SumCtx(ctx, src, len); /* Pass only one block. */ (void) auth_md5CloseCtx(ctx, dst); /* Close the context. */ - return (dst); /* Makes life easy. */ + return (dst); /* Makes life easy. */ } /* auth_md5Sum */ -unsigned char * MD5fromFile(unsigned char *dst, const char *src) +unsigned char* MD5fromFile(unsigned char* dst, const char* src) /* ------------------------------------------------------------------------ ** * Compute an MD5 message digest. * * Input: dst - Destination buffer into which the result will be written. - * Must be 16 bytes, minimum. - * src - filepath of the file to be checked + * Must be 16 bytes, minimum. + * src - filepath of the file to be checked * * Output: A pointer to , which will contain the calculated 16-byte - * MD5 message digest. + * MD5 message digest. * * Notes: This function is a shortcut. It takes a single input block. - * For more drawn-out operations, see . + * For more drawn-out operations, see . * - * This function is interface-compatible with the - * function in the MD4 module. + * This function is interface-compatible with the + * function in the MD4 module. * - * The MD5 algorithm is designed to work on data with an - * arbitrary *bit* length. Most implementations, this one - * included, handle the input data in byte-sized chunks. + * The MD5 algorithm is designed to work on data with an + * arbitrary *bit* length. Most implementations, this one + * included, handle the input data in byte-sized chunks. * - * The MD5 algorithm does much of its work using four-byte - * words, and so can be tuned for speed based on the endian-ness - * of the host. This implementation is intended to be - * endian-neutral, which may make it a teeny bit slower than - * others. ...maybe. + * The MD5 algorithm does much of its work using four-byte + * words, and so can be tuned for speed based on the endian-ness + * of the host. This implementation is intended to be + * endian-neutral, which may make it a teeny bit slower than + * others. ...maybe. * * See Also: * @@ -532,7 +550,7 @@ unsigned char * MD5fromFile(unsigned char *dst, const char *src) { auth_md5Ctx ctx[1]; - FILE * file; + FILE* file; unsigned int blksize = 0; unsigned int read = 0; unsigned int filesize; @@ -545,7 +563,7 @@ unsigned char * MD5fromFile(unsigned char *dst, const char *src) return NULL; } - (void) auth_md5InitCtx(ctx); /* Open a context. */ + (void) auth_md5InitCtx(ctx); /* Open a context. */ fseek(file, 0, SEEK_END); filesize = ftell(file); @@ -569,17 +587,18 @@ unsigned char * MD5fromFile(unsigned char *dst, const char *src) read = (int)fread(buffer, 1, blksize, file); (void) auth_md5SumCtx(ctx, buffer, read); /* Pass only one block. */ - } while (read > 0); + } + while (read > 0); fclose(file); free(buffer); (void) auth_md5CloseCtx(ctx, dst); /* Close the context. */ - return (dst); /* Makes life easy. */ + return (dst); /* Makes life easy. */ } /* auth_md5Sum */ -const char * MD5ToString(const unsigned char * hash, char * dst) +const char* MD5ToString(const unsigned char* hash, char* dst) { char hexchar[3]; short i = 0, n = 0; @@ -597,7 +616,7 @@ const char * MD5ToString(const unsigned char * hash, char * dst) return dst; } -unsigned char * StringToMD5(const char * hash, unsigned char * dst) +unsigned char* StringToMD5(const char* hash, unsigned char* dst) { char hexchar[2]; short i = 0, n = 0; @@ -607,9 +626,9 @@ unsigned char * StringToMD5(const char * hash, unsigned char * dst) hexchar[0] = hash[n++]; hexchar[1] = hash[n++]; - dst[i] = STR2HEX( hexchar[0] ); + dst[i] = STR2HEX(hexchar[0]); dst[i] <<= 4; - dst[i] += STR2HEX( hexchar[1] ); + dst[i] += STR2HEX(hexchar[1]); } return dst; diff --git a/src/sha1.cpp b/src/sha1.cpp index dca61be..b6b6ef2 100644 --- a/src/sha1.cpp +++ b/src/sha1.cpp @@ -50,8 +50,8 @@ ((word) >> (32-(bits)))) /* Function prototypes */ -void SHA1ProcessMessageBlock(SHA1Context *); -void SHA1PadMessage(SHA1Context *); +void SHA1ProcessMessageBlock(SHA1Context*); +void SHA1PadMessage(SHA1Context*); /* * SHA1Reset @@ -70,7 +70,7 @@ void SHA1PadMessage(SHA1Context *); * Comments: * */ -void SHA1Reset(SHA1Context *context) +void SHA1Reset(SHA1Context* context) { context->Length_Low = 0; context->Length_High = 0; @@ -103,7 +103,7 @@ void SHA1Reset(SHA1Context *context) * Comments: * */ -int SHA1Result(SHA1Context *context) +int SHA1Result(SHA1Context* context) { if (context->Corrupted) @@ -142,9 +142,9 @@ int SHA1Result(SHA1Context *context) * Comments: * */ -void SHA1Input( SHA1Context *context, - const unsigned char *message_array, - unsigned length) +void SHA1Input(SHA1Context* context, + const unsigned char* message_array, + unsigned length) { if (!length) { @@ -157,19 +157,21 @@ void SHA1Input( SHA1Context *context, return; } - while(length-- && !context->Corrupted) + while (length-- && !context->Corrupted) { context->Message_Block[context->Message_Block_Index++] = - (*message_array & 0xFF); + (*message_array & 0xFF); context->Length_Low += 8; /* Force it to 32 bits */ context->Length_Low &= 0xFFFFFFFF; + if (context->Length_Low == 0) { context->Length_High++; /* Force it to 32 bits */ context->Length_High &= 0xFFFFFFFF; + if (context->Length_High == 0) { /* Message is too long */ @@ -206,15 +208,15 @@ void SHA1Input( SHA1Context *context, * * */ -void SHA1ProcessMessageBlock(SHA1Context *context) +void SHA1ProcessMessageBlock(SHA1Context* context) { const unsigned K[] = /* Constants defined in SHA-1 */ { - 0x5A827999, - 0x6ED9EBA1, - 0x8F1BBCDC, - 0xCA62C1D6 -}; + 0x5A827999, + 0x6ED9EBA1, + 0x8F1BBCDC, + 0xCA62C1D6 + }; int t; /* Loop counter */ unsigned temp; /* Temporary word value */ unsigned W[80]; /* Word sequence */ @@ -223,7 +225,7 @@ void SHA1ProcessMessageBlock(SHA1Context *context) /* * Initialize the first 16 words in the array W */ - for(t = 0; t < 16; t++) + for (t = 0; t < 16; t++) { W[t] = ((unsigned) context->Message_Block[t * 4]) << 24; W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16; @@ -231,9 +233,9 @@ void SHA1ProcessMessageBlock(SHA1Context *context) W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]); } - for(t = 16; t < 80; t++) + for (t = 16; t < 80; t++) { - W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]); + W[t] = SHA1CircularShift(1, W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16]); } A = context->Message_Digest[0]; @@ -242,62 +244,62 @@ void SHA1ProcessMessageBlock(SHA1Context *context) D = context->Message_Digest[3]; E = context->Message_Digest[4]; - for(t = 0; t < 20; t++) + for (t = 0; t < 20; t++) { - temp = SHA1CircularShift(5,A) + + temp = SHA1CircularShift(5, A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0]; temp &= 0xFFFFFFFF; E = D; D = C; - C = SHA1CircularShift(30,B); + C = SHA1CircularShift(30, B); B = A; A = temp; } - for(t = 20; t < 40; t++) + for (t = 20; t < 40; t++) { - temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1]; + temp = SHA1CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[1]; temp &= 0xFFFFFFFF; E = D; D = C; - C = SHA1CircularShift(30,B); + C = SHA1CircularShift(30, B); B = A; A = temp; } - for(t = 40; t < 60; t++) + for (t = 40; t < 60; t++) { - temp = SHA1CircularShift(5,A) + + temp = SHA1CircularShift(5, A) + ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2]; temp &= 0xFFFFFFFF; E = D; D = C; - C = SHA1CircularShift(30,B); + C = SHA1CircularShift(30, B); B = A; A = temp; } - for(t = 60; t < 80; t++) + for (t = 60; t < 80; t++) { - temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3]; + temp = SHA1CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[3]; temp &= 0xFFFFFFFF; E = D; D = C; - C = SHA1CircularShift(30,B); + C = SHA1CircularShift(30, B); B = A; A = temp; } context->Message_Digest[0] = - (context->Message_Digest[0] + A) & 0xFFFFFFFF; + (context->Message_Digest[0] + A) & 0xFFFFFFFF; context->Message_Digest[1] = - (context->Message_Digest[1] + B) & 0xFFFFFFFF; + (context->Message_Digest[1] + B) & 0xFFFFFFFF; context->Message_Digest[2] = - (context->Message_Digest[2] + C) & 0xFFFFFFFF; + (context->Message_Digest[2] + C) & 0xFFFFFFFF; context->Message_Digest[3] = - (context->Message_Digest[3] + D) & 0xFFFFFFFF; + (context->Message_Digest[3] + D) & 0xFFFFFFFF; context->Message_Digest[4] = - (context->Message_Digest[4] + E) & 0xFFFFFFFF; + (context->Message_Digest[4] + E) & 0xFFFFFFFF; context->Message_Block_Index = 0; } @@ -325,7 +327,7 @@ void SHA1ProcessMessageBlock(SHA1Context *context) * Comments: * */ -void SHA1PadMessage(SHA1Context *context) +void SHA1PadMessage(SHA1Context* context) { /* * Check to see if the current message block is too small to hold @@ -336,14 +338,15 @@ void SHA1PadMessage(SHA1Context *context) if (context->Message_Block_Index > 55) { context->Message_Block[context->Message_Block_Index++] = 0x80; - while(context->Message_Block_Index < 64) + + while (context->Message_Block_Index < 64) { context->Message_Block[context->Message_Block_Index++] = 0; } SHA1ProcessMessageBlock(context); - while(context->Message_Block_Index < 56) + while (context->Message_Block_Index < 56) { context->Message_Block[context->Message_Block_Index++] = 0; } @@ -351,7 +354,8 @@ void SHA1PadMessage(SHA1Context *context) else { context->Message_Block[context->Message_Block_Index++] = 0x80; - while(context->Message_Block_Index < 56) + + while (context->Message_Block_Index < 56) { context->Message_Block[context->Message_Block_Index++] = 0; } @@ -372,24 +376,26 @@ void SHA1PadMessage(SHA1Context *context) SHA1ProcessMessageBlock(context); } -atUint8* getSha1( atUint8 * stuff, atUint32 stuff_size ) +atUint8* getSha1(atUint8* stuff, atUint32 stuff_size) { SHA1Context sha; - SHA1Reset( &sha ); - SHA1Input( &sha, (const atUint8*)stuff, stuff_size ); - if( !SHA1Result( &sha ) ) + SHA1Reset(&sha); + SHA1Input(&sha, (const atUint8*)stuff, stuff_size); + + if (!SHA1Result(&sha)) return 0; atUint8* ret = new atUint8[20]; memset(ret, 0, 20); - for( int i = 0; i < 5 ; i++ ) + for (int i = 0; i < 5 ; i++) { int val = sha.Message_Digest[ i ]; + if (!Athena::utility::isSystemBigEndian()) val = Athena::utility::swap32(val); - memcpy( (char*)ret + ( i * 4 ), &val, 4 ); + memcpy((char*)ret + (i * 4), &val, 4); } return ret;