summaryrefslogtreecommitdiff
path: root/utils/zenutils/libraries/zlib123/zlib/deflate.c
diff options
context:
space:
mode:
Diffstat (limited to 'utils/zenutils/libraries/zlib123/zlib/deflate.c')
-rw-r--r--[-rwxr-xr-x]utils/zenutils/libraries/zlib123/zlib/deflate.c3472
1 files changed, 1736 insertions, 1736 deletions
diff --git a/utils/zenutils/libraries/zlib123/zlib/deflate.c b/utils/zenutils/libraries/zlib123/zlib/deflate.c
index 529f716b7a..29ce1f64a5 100755..100644
--- a/utils/zenutils/libraries/zlib123/zlib/deflate.c
+++ b/utils/zenutils/libraries/zlib123/zlib/deflate.c
@@ -1,1736 +1,1736 @@
1/* deflate.c -- compress data using the deflation algorithm 1/* deflate.c -- compress data using the deflation algorithm
2 * Copyright (C) 1995-2005 Jean-loup Gailly. 2 * Copyright (C) 1995-2005 Jean-loup Gailly.
3 * For conditions of distribution and use, see copyright notice in zlib.h 3 * For conditions of distribution and use, see copyright notice in zlib.h
4 */ 4 */
5 5
6/* 6/*
7 * ALGORITHM 7 * ALGORITHM
8 * 8 *
9 * The "deflation" process depends on being able to identify portions 9 * The "deflation" process depends on being able to identify portions
10 * of the input text which are identical to earlier input (within a 10 * of the input text which are identical to earlier input (within a
11 * sliding window trailing behind the input currently being processed). 11 * sliding window trailing behind the input currently being processed).
12 * 12 *
13 * The most straightforward technique turns out to be the fastest for 13 * The most straightforward technique turns out to be the fastest for
14 * most input files: try all possible matches and select the longest. 14 * most input files: try all possible matches and select the longest.
15 * The key feature of this algorithm is that insertions into the string 15 * The key feature of this algorithm is that insertions into the string
16 * dictionary are very simple and thus fast, and deletions are avoided 16 * dictionary are very simple and thus fast, and deletions are avoided
17 * completely. Insertions are performed at each input character, whereas 17 * completely. Insertions are performed at each input character, whereas
18 * string matches are performed only when the previous match ends. So it 18 * string matches are performed only when the previous match ends. So it
19 * is preferable to spend more time in matches to allow very fast string 19 * is preferable to spend more time in matches to allow very fast string
20 * insertions and avoid deletions. The matching algorithm for small 20 * insertions and avoid deletions. The matching algorithm for small
21 * strings is inspired from that of Rabin & Karp. A brute force approach 21 * strings is inspired from that of Rabin & Karp. A brute force approach
22 * is used to find longer strings when a small match has been found. 22 * is used to find longer strings when a small match has been found.
23 * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze 23 * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
24 * (by Leonid Broukhis). 24 * (by Leonid Broukhis).
25 * A previous version of this file used a more sophisticated algorithm 25 * A previous version of this file used a more sophisticated algorithm
26 * (by Fiala and Greene) which is guaranteed to run in linear amortized 26 * (by Fiala and Greene) which is guaranteed to run in linear amortized
27 * time, but has a larger average cost, uses more memory and is patented. 27 * time, but has a larger average cost, uses more memory and is patented.
28 * However the F&G algorithm may be faster for some highly redundant 28 * However the F&G algorithm may be faster for some highly redundant
29 * files if the parameter max_chain_length (described below) is too large. 29 * files if the parameter max_chain_length (described below) is too large.
30 * 30 *
31 * ACKNOWLEDGEMENTS 31 * ACKNOWLEDGEMENTS
32 * 32 *
33 * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and 33 * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
34 * I found it in 'freeze' written by Leonid Broukhis. 34 * I found it in 'freeze' written by Leonid Broukhis.
35 * Thanks to many people for bug reports and testing. 35 * Thanks to many people for bug reports and testing.
36 * 36 *
37 * REFERENCES 37 * REFERENCES
38 * 38 *
39 * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". 39 * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
40 * Available in http://www.ietf.org/rfc/rfc1951.txt 40 * Available in http://www.ietf.org/rfc/rfc1951.txt
41 * 41 *
42 * A description of the Rabin and Karp algorithm is given in the book 42 * A description of the Rabin and Karp algorithm is given in the book
43 * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. 43 * "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
44 * 44 *
45 * Fiala,E.R., and Greene,D.H. 45 * Fiala,E.R., and Greene,D.H.
46 * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 46 * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
47 * 47 *
48 */ 48 */
49 49
50/* @(#) $Id$ */ 50/* @(#) $Id$ */
51 51
52#include "deflate.h" 52#include "deflate.h"
53 53
54const char deflate_copyright[] = 54const char deflate_copyright[] =
55 " deflate 1.2.3 Copyright 1995-2005 Jean-loup Gailly "; 55 " deflate 1.2.3 Copyright 1995-2005 Jean-loup Gailly ";
56/* 56/*
57 If you use the zlib library in a product, an acknowledgment is welcome 57 If you use the zlib library in a product, an acknowledgment is welcome
58 in the documentation of your product. If for some reason you cannot 58 in the documentation of your product. If for some reason you cannot
59 include such an acknowledgment, I would appreciate that you keep this 59 include such an acknowledgment, I would appreciate that you keep this
60 copyright string in the executable of your product. 60 copyright string in the executable of your product.
61 */ 61 */
62 62
63/* =========================================================================== 63/* ===========================================================================
64 * Function prototypes. 64 * Function prototypes.
65 */ 65 */
66typedef enum { 66typedef enum {
67 need_more, /* block not completed, need more input or more output */ 67 need_more, /* block not completed, need more input or more output */
68 block_done, /* block flush performed */ 68 block_done, /* block flush performed */
69 finish_started, /* finish started, need only more output at next deflate */ 69 finish_started, /* finish started, need only more output at next deflate */
70 finish_done /* finish done, accept no more input or output */ 70 finish_done /* finish done, accept no more input or output */
71} block_state; 71} block_state;
72 72
73typedef block_state (*compress_func) OF((deflate_state *s, int flush)); 73typedef block_state (*compress_func) OF((deflate_state *s, int flush));
74/* Compression function. Returns the block state after the call. */ 74/* Compression function. Returns the block state after the call. */
75 75
76local void fill_window OF((deflate_state *s)); 76local void fill_window OF((deflate_state *s));
77local block_state deflate_stored OF((deflate_state *s, int flush)); 77local block_state deflate_stored OF((deflate_state *s, int flush));
78local block_state deflate_fast OF((deflate_state *s, int flush)); 78local block_state deflate_fast OF((deflate_state *s, int flush));
79#ifndef FASTEST 79#ifndef FASTEST
80local block_state deflate_slow OF((deflate_state *s, int flush)); 80local block_state deflate_slow OF((deflate_state *s, int flush));
81#endif 81#endif
82local void lm_init OF((deflate_state *s)); 82local void lm_init OF((deflate_state *s));
83local void putShortMSB OF((deflate_state *s, uInt b)); 83local void putShortMSB OF((deflate_state *s, uInt b));
84local void flush_pending OF((z_streamp strm)); 84local void flush_pending OF((z_streamp strm));
85local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); 85local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
86#ifndef FASTEST 86#ifndef FASTEST
87#ifdef ASMV 87#ifdef ASMV
88 void match_init OF((void)); /* asm code initialization */ 88 void match_init OF((void)); /* asm code initialization */
89 uInt longest_match OF((deflate_state *s, IPos cur_match)); 89 uInt longest_match OF((deflate_state *s, IPos cur_match));
90#else 90#else
91local uInt longest_match OF((deflate_state *s, IPos cur_match)); 91local uInt longest_match OF((deflate_state *s, IPos cur_match));
92#endif 92#endif
93#endif 93#endif
94local uInt longest_match_fast OF((deflate_state *s, IPos cur_match)); 94local uInt longest_match_fast OF((deflate_state *s, IPos cur_match));
95 95
96#ifdef DEBUG 96#ifdef DEBUG
97local void check_match OF((deflate_state *s, IPos start, IPos match, 97local void check_match OF((deflate_state *s, IPos start, IPos match,
98 int length)); 98 int length));
99#endif 99#endif
100 100
101/* =========================================================================== 101/* ===========================================================================
102 * Local data 102 * Local data
103 */ 103 */
104 104
105#define NIL 0 105#define NIL 0
106/* Tail of hash chains */ 106/* Tail of hash chains */
107 107
108#ifndef TOO_FAR 108#ifndef TOO_FAR
109# define TOO_FAR 4096 109# define TOO_FAR 4096
110#endif 110#endif
111/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ 111/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
112 112
113#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) 113#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
114/* Minimum amount of lookahead, except at the end of the input file. 114/* Minimum amount of lookahead, except at the end of the input file.
115 * See deflate.c for comments about the MIN_MATCH+1. 115 * See deflate.c for comments about the MIN_MATCH+1.
116 */ 116 */
117 117
118/* Values for max_lazy_match, good_match and max_chain_length, depending on 118/* Values for max_lazy_match, good_match and max_chain_length, depending on
119 * the desired pack level (0..9). The values given below have been tuned to 119 * the desired pack level (0..9). The values given below have been tuned to
120 * exclude worst case performance for pathological files. Better values may be 120 * exclude worst case performance for pathological files. Better values may be
121 * found for specific files. 121 * found for specific files.
122 */ 122 */
123typedef struct config_s { 123typedef struct config_s {
124 ush good_length; /* reduce lazy search above this match length */ 124 ush good_length; /* reduce lazy search above this match length */
125 ush max_lazy; /* do not perform lazy search above this match length */ 125 ush max_lazy; /* do not perform lazy search above this match length */
126 ush nice_length; /* quit search above this match length */ 126 ush nice_length; /* quit search above this match length */
127 ush max_chain; 127 ush max_chain;
128 compress_func func; 128 compress_func func;
129} config; 129} config;
130 130
131#ifdef FASTEST 131#ifdef FASTEST
132local const config configuration_table[2] = { 132local const config configuration_table[2] = {
133/* good lazy nice chain */ 133/* good lazy nice chain */
134/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ 134/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */
135/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */ 135/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */
136#else 136#else
137local const config configuration_table[10] = { 137local const config configuration_table[10] = {
138/* good lazy nice chain */ 138/* good lazy nice chain */
139/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ 139/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */
140/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ 140/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */
141/* 2 */ {4, 5, 16, 8, deflate_fast}, 141/* 2 */ {4, 5, 16, 8, deflate_fast},
142/* 3 */ {4, 6, 32, 32, deflate_fast}, 142/* 3 */ {4, 6, 32, 32, deflate_fast},
143 143
144/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ 144/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */
145/* 5 */ {8, 16, 32, 32, deflate_slow}, 145/* 5 */ {8, 16, 32, 32, deflate_slow},
146/* 6 */ {8, 16, 128, 128, deflate_slow}, 146/* 6 */ {8, 16, 128, 128, deflate_slow},
147/* 7 */ {8, 32, 128, 256, deflate_slow}, 147/* 7 */ {8, 32, 128, 256, deflate_slow},
148/* 8 */ {32, 128, 258, 1024, deflate_slow}, 148/* 8 */ {32, 128, 258, 1024, deflate_slow},
149/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */ 149/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */
150#endif 150#endif
151 151
152/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 152/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
153 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different 153 * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
154 * meaning. 154 * meaning.
155 */ 155 */
156 156
157#define EQUAL 0 157#define EQUAL 0
158/* result of memcmp for equal strings */ 158/* result of memcmp for equal strings */
159 159
160#ifndef NO_DUMMY_DECL 160#ifndef NO_DUMMY_DECL
161struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ 161struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
162#endif 162#endif
163 163
164/* =========================================================================== 164/* ===========================================================================
165 * Update a hash value with the given input byte 165 * Update a hash value with the given input byte
166 * IN assertion: all calls to to UPDATE_HASH are made with consecutive 166 * IN assertion: all calls to to UPDATE_HASH are made with consecutive
167 * input characters, so that a running hash key can be computed from the 167 * input characters, so that a running hash key can be computed from the
168 * previous key instead of complete recalculation each time. 168 * previous key instead of complete recalculation each time.
169 */ 169 */
170#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask) 170#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
171 171
172 172
173/* =========================================================================== 173/* ===========================================================================
174 * Insert string str in the dictionary and set match_head to the previous head 174 * Insert string str in the dictionary and set match_head to the previous head
175 * of the hash chain (the most recent string with same hash key). Return 175 * of the hash chain (the most recent string with same hash key). Return
176 * the previous length of the hash chain. 176 * the previous length of the hash chain.
177 * If this file is compiled with -DFASTEST, the compression level is forced 177 * If this file is compiled with -DFASTEST, the compression level is forced
178 * to 1, and no hash chains are maintained. 178 * to 1, and no hash chains are maintained.
179 * IN assertion: all calls to to INSERT_STRING are made with consecutive 179 * IN assertion: all calls to to INSERT_STRING are made with consecutive
180 * input characters and the first MIN_MATCH bytes of str are valid 180 * input characters and the first MIN_MATCH bytes of str are valid
181 * (except for the last MIN_MATCH-1 bytes of the input file). 181 * (except for the last MIN_MATCH-1 bytes of the input file).
182 */ 182 */
183#ifdef FASTEST 183#ifdef FASTEST
184#define INSERT_STRING(s, str, match_head) \ 184#define INSERT_STRING(s, str, match_head) \
185 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ 185 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
186 match_head = s->head[s->ins_h], \ 186 match_head = s->head[s->ins_h], \
187 s->head[s->ins_h] = (Pos)(str)) 187 s->head[s->ins_h] = (Pos)(str))
188#else 188#else
189#define INSERT_STRING(s, str, match_head) \ 189#define INSERT_STRING(s, str, match_head) \
190 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ 190 (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
191 match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ 191 match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \
192 s->head[s->ins_h] = (Pos)(str)) 192 s->head[s->ins_h] = (Pos)(str))
193#endif 193#endif
194 194
195/* =========================================================================== 195/* ===========================================================================
196 * Initialize the hash table (avoiding 64K overflow for 16 bit systems). 196 * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
197 * prev[] will be initialized on the fly. 197 * prev[] will be initialized on the fly.
198 */ 198 */
199#define CLEAR_HASH(s) \ 199#define CLEAR_HASH(s) \
200 s->head[s->hash_size-1] = NIL; \ 200 s->head[s->hash_size-1] = NIL; \
201 zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); 201 zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
202 202
203/* ========================================================================= */ 203/* ========================================================================= */
204int ZEXPORT deflateInit_(strm, level, version, stream_size) 204int ZEXPORT deflateInit_(strm, level, version, stream_size)
205 z_streamp strm; 205 z_streamp strm;
206 int level; 206 int level;
207 const char *version; 207 const char *version;
208 int stream_size; 208 int stream_size;
209{ 209{
210 return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, 210 return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
211 Z_DEFAULT_STRATEGY, version, stream_size); 211 Z_DEFAULT_STRATEGY, version, stream_size);
212 /* To do: ignore strm->next_in if we use it as window */ 212 /* To do: ignore strm->next_in if we use it as window */
213} 213}
214 214
215/* ========================================================================= */ 215/* ========================================================================= */
216int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, 216int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
217 version, stream_size) 217 version, stream_size)
218 z_streamp strm; 218 z_streamp strm;
219 int level; 219 int level;
220 int method; 220 int method;
221 int windowBits; 221 int windowBits;
222 int memLevel; 222 int memLevel;
223 int strategy; 223 int strategy;
224 const char *version; 224 const char *version;
225 int stream_size; 225 int stream_size;
226{ 226{
227 deflate_state *s; 227 deflate_state *s;
228 int wrap = 1; 228 int wrap = 1;
229 static const char my_version[] = ZLIB_VERSION; 229 static const char my_version[] = ZLIB_VERSION;
230 230
231 ushf *overlay; 231 ushf *overlay;
232 /* We overlay pending_buf and d_buf+l_buf. This works since the average 232 /* We overlay pending_buf and d_buf+l_buf. This works since the average
233 * output size for (length,distance) codes is <= 24 bits. 233 * output size for (length,distance) codes is <= 24 bits.
234 */ 234 */
235 235
236 if (version == Z_NULL || version[0] != my_version[0] || 236 if (version == Z_NULL || version[0] != my_version[0] ||
237 stream_size != sizeof(z_stream)) { 237 stream_size != sizeof(z_stream)) {
238 return Z_VERSION_ERROR; 238 return Z_VERSION_ERROR;
239 } 239 }
240 if (strm == Z_NULL) return Z_STREAM_ERROR; 240 if (strm == Z_NULL) return Z_STREAM_ERROR;
241 241
242 strm->msg = Z_NULL; 242 strm->msg = Z_NULL;
243 if (strm->zalloc == (alloc_func)0) { 243 if (strm->zalloc == (alloc_func)0) {
244 strm->zalloc = zcalloc; 244 strm->zalloc = zcalloc;
245 strm->opaque = (voidpf)0; 245 strm->opaque = (voidpf)0;
246 } 246 }
247 if (strm->zfree == (free_func)0) strm->zfree = zcfree; 247 if (strm->zfree == (free_func)0) strm->zfree = zcfree;
248 248
249#ifdef FASTEST 249#ifdef FASTEST
250 if (level != 0) level = 1; 250 if (level != 0) level = 1;
251#else 251#else
252 if (level == Z_DEFAULT_COMPRESSION) level = 6; 252 if (level == Z_DEFAULT_COMPRESSION) level = 6;
253#endif 253#endif
254 254
255 if (windowBits < 0) { /* suppress zlib wrapper */ 255 if (windowBits < 0) { /* suppress zlib wrapper */
256 wrap = 0; 256 wrap = 0;
257 windowBits = -windowBits; 257 windowBits = -windowBits;
258 } 258 }
259#ifdef GZIP 259#ifdef GZIP
260 else if (windowBits > 15) { 260 else if (windowBits > 15) {
261 wrap = 2; /* write gzip wrapper instead */ 261 wrap = 2; /* write gzip wrapper instead */
262 windowBits -= 16; 262 windowBits -= 16;
263 } 263 }
264#endif 264#endif
265 if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || 265 if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
266 windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || 266 windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
267 strategy < 0 || strategy > Z_FIXED) { 267 strategy < 0 || strategy > Z_FIXED) {
268 return Z_STREAM_ERROR; 268 return Z_STREAM_ERROR;
269 } 269 }
270 if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ 270 if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */
271 s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); 271 s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
272 if (s == Z_NULL) return Z_MEM_ERROR; 272 if (s == Z_NULL) return Z_MEM_ERROR;
273 strm->state = (struct internal_state FAR *)s; 273 strm->state = (struct internal_state FAR *)s;
274 s->strm = strm; 274 s->strm = strm;
275 275
276 s->wrap = wrap; 276 s->wrap = wrap;
277 s->gzhead = Z_NULL; 277 s->gzhead = Z_NULL;
278 s->w_bits = windowBits; 278 s->w_bits = windowBits;
279 s->w_size = 1 << s->w_bits; 279 s->w_size = 1 << s->w_bits;
280 s->w_mask = s->w_size - 1; 280 s->w_mask = s->w_size - 1;
281 281
282 s->hash_bits = memLevel + 7; 282 s->hash_bits = memLevel + 7;
283 s->hash_size = 1 << s->hash_bits; 283 s->hash_size = 1 << s->hash_bits;
284 s->hash_mask = s->hash_size - 1; 284 s->hash_mask = s->hash_size - 1;
285 s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); 285 s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
286 286
287 s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); 287 s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
288 s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); 288 s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
289 s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); 289 s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos));
290 290
291 s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ 291 s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
292 292
293 overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); 293 overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
294 s->pending_buf = (uchf *) overlay; 294 s->pending_buf = (uchf *) overlay;
295 s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); 295 s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
296 296
297 if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || 297 if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
298 s->pending_buf == Z_NULL) { 298 s->pending_buf == Z_NULL) {
299 s->status = FINISH_STATE; 299 s->status = FINISH_STATE;
300 strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); 300 strm->msg = (char*)ERR_MSG(Z_MEM_ERROR);
301 deflateEnd (strm); 301 deflateEnd (strm);
302 return Z_MEM_ERROR; 302 return Z_MEM_ERROR;
303 } 303 }
304 s->d_buf = overlay + s->lit_bufsize/sizeof(ush); 304 s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
305 s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; 305 s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
306 306
307 s->level = level; 307 s->level = level;
308 s->strategy = strategy; 308 s->strategy = strategy;
309 s->method = (Byte)method; 309 s->method = (Byte)method;
310 310
311 return deflateReset(strm); 311 return deflateReset(strm);
312} 312}
313 313
314/* ========================================================================= */ 314/* ========================================================================= */
315int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) 315int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
316 z_streamp strm; 316 z_streamp strm;
317 const Bytef *dictionary; 317 const Bytef *dictionary;
318 uInt dictLength; 318 uInt dictLength;
319{ 319{
320 deflate_state *s; 320 deflate_state *s;
321 uInt length = dictLength; 321 uInt length = dictLength;
322 uInt n; 322 uInt n;
323 IPos hash_head = 0; 323 IPos hash_head = 0;
324 324
325 if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || 325 if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL ||
326 strm->state->wrap == 2 || 326 strm->state->wrap == 2 ||
327 (strm->state->wrap == 1 && strm->state->status != INIT_STATE)) 327 (strm->state->wrap == 1 && strm->state->status != INIT_STATE))
328 return Z_STREAM_ERROR; 328 return Z_STREAM_ERROR;
329 329
330 s = strm->state; 330 s = strm->state;
331 if (s->wrap) 331 if (s->wrap)
332 strm->adler = adler32(strm->adler, dictionary, dictLength); 332 strm->adler = adler32(strm->adler, dictionary, dictLength);
333 333
334 if (length < MIN_MATCH) return Z_OK; 334 if (length < MIN_MATCH) return Z_OK;
335 if (length > MAX_DIST(s)) { 335 if (length > MAX_DIST(s)) {
336 length = MAX_DIST(s); 336 length = MAX_DIST(s);
337 dictionary += dictLength - length; /* use the tail of the dictionary */ 337 dictionary += dictLength - length; /* use the tail of the dictionary */
338 } 338 }
339 zmemcpy(s->window, dictionary, length); 339 zmemcpy(s->window, dictionary, length);
340 s->strstart = length; 340 s->strstart = length;
341 s->block_start = (long)length; 341 s->block_start = (long)length;
342 342
343 /* Insert all strings in the hash table (except for the last two bytes). 343 /* Insert all strings in the hash table (except for the last two bytes).
344 * s->lookahead stays null, so s->ins_h will be recomputed at the next 344 * s->lookahead stays null, so s->ins_h will be recomputed at the next
345 * call of fill_window. 345 * call of fill_window.
346 */ 346 */
347 s->ins_h = s->window[0]; 347 s->ins_h = s->window[0];
348 UPDATE_HASH(s, s->ins_h, s->window[1]); 348 UPDATE_HASH(s, s->ins_h, s->window[1]);
349 for (n = 0; n <= length - MIN_MATCH; n++) { 349 for (n = 0; n <= length - MIN_MATCH; n++) {
350 INSERT_STRING(s, n, hash_head); 350 INSERT_STRING(s, n, hash_head);
351 } 351 }
352 if (hash_head) hash_head = 0; /* to make compiler happy */ 352 if (hash_head) hash_head = 0; /* to make compiler happy */
353 return Z_OK; 353 return Z_OK;
354} 354}
355 355
356/* ========================================================================= */ 356/* ========================================================================= */
357int ZEXPORT deflateReset (strm) 357int ZEXPORT deflateReset (strm)
358 z_streamp strm; 358 z_streamp strm;
359{ 359{
360 deflate_state *s; 360 deflate_state *s;
361 361
362 if (strm == Z_NULL || strm->state == Z_NULL || 362 if (strm == Z_NULL || strm->state == Z_NULL ||
363 strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { 363 strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) {
364 return Z_STREAM_ERROR; 364 return Z_STREAM_ERROR;
365 } 365 }
366 366
367 strm->total_in = strm->total_out = 0; 367 strm->total_in = strm->total_out = 0;
368 strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ 368 strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
369 strm->data_type = Z_UNKNOWN; 369 strm->data_type = Z_UNKNOWN;
370 370
371 s = (deflate_state *)strm->state; 371 s = (deflate_state *)strm->state;
372 s->pending = 0; 372 s->pending = 0;
373 s->pending_out = s->pending_buf; 373 s->pending_out = s->pending_buf;
374 374
375 if (s->wrap < 0) { 375 if (s->wrap < 0) {
376 s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ 376 s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
377 } 377 }
378 s->status = s->wrap ? INIT_STATE : BUSY_STATE; 378 s->status = s->wrap ? INIT_STATE : BUSY_STATE;
379 strm->adler = 379 strm->adler =
380#ifdef GZIP 380#ifdef GZIP
381 s->wrap == 2 ? crc32(0L, Z_NULL, 0) : 381 s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
382#endif 382#endif
383 adler32(0L, Z_NULL, 0); 383 adler32(0L, Z_NULL, 0);
384 s->last_flush = Z_NO_FLUSH; 384 s->last_flush = Z_NO_FLUSH;
385 385
386 _tr_init(s); 386 _tr_init(s);
387 lm_init(s); 387 lm_init(s);
388 388
389 return Z_OK; 389 return Z_OK;
390} 390}
391 391
392/* ========================================================================= */ 392/* ========================================================================= */
393int ZEXPORT deflateSetHeader (strm, head) 393int ZEXPORT deflateSetHeader (strm, head)
394 z_streamp strm; 394 z_streamp strm;
395 gz_headerp head; 395 gz_headerp head;
396{ 396{
397 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 397 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
398 if (strm->state->wrap != 2) return Z_STREAM_ERROR; 398 if (strm->state->wrap != 2) return Z_STREAM_ERROR;
399 strm->state->gzhead = head; 399 strm->state->gzhead = head;
400 return Z_OK; 400 return Z_OK;
401} 401}
402 402
403/* ========================================================================= */ 403/* ========================================================================= */
404int ZEXPORT deflatePrime (strm, bits, value) 404int ZEXPORT deflatePrime (strm, bits, value)
405 z_streamp strm; 405 z_streamp strm;
406 int bits; 406 int bits;
407 int value; 407 int value;
408{ 408{
409 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 409 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
410 strm->state->bi_valid = bits; 410 strm->state->bi_valid = bits;
411 strm->state->bi_buf = (ush)(value & ((1 << bits) - 1)); 411 strm->state->bi_buf = (ush)(value & ((1 << bits) - 1));
412 return Z_OK; 412 return Z_OK;
413} 413}
414 414
415/* ========================================================================= */ 415/* ========================================================================= */
416int ZEXPORT deflateParams(strm, level, strategy) 416int ZEXPORT deflateParams(strm, level, strategy)
417 z_streamp strm; 417 z_streamp strm;
418 int level; 418 int level;
419 int strategy; 419 int strategy;
420{ 420{
421 deflate_state *s; 421 deflate_state *s;
422 compress_func func; 422 compress_func func;
423 int err = Z_OK; 423 int err = Z_OK;
424 424
425 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 425 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
426 s = strm->state; 426 s = strm->state;
427 427
428#ifdef FASTEST 428#ifdef FASTEST
429 if (level != 0) level = 1; 429 if (level != 0) level = 1;
430#else 430#else
431 if (level == Z_DEFAULT_COMPRESSION) level = 6; 431 if (level == Z_DEFAULT_COMPRESSION) level = 6;
432#endif 432#endif
433 if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { 433 if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
434 return Z_STREAM_ERROR; 434 return Z_STREAM_ERROR;
435 } 435 }
436 func = configuration_table[s->level].func; 436 func = configuration_table[s->level].func;
437 437
438 if (func != configuration_table[level].func && strm->total_in != 0) { 438 if (func != configuration_table[level].func && strm->total_in != 0) {
439 /* Flush the last buffer: */ 439 /* Flush the last buffer: */
440 err = deflate(strm, Z_PARTIAL_FLUSH); 440 err = deflate(strm, Z_PARTIAL_FLUSH);
441 } 441 }
442 if (s->level != level) { 442 if (s->level != level) {
443 s->level = level; 443 s->level = level;
444 s->max_lazy_match = configuration_table[level].max_lazy; 444 s->max_lazy_match = configuration_table[level].max_lazy;
445 s->good_match = configuration_table[level].good_length; 445 s->good_match = configuration_table[level].good_length;
446 s->nice_match = configuration_table[level].nice_length; 446 s->nice_match = configuration_table[level].nice_length;
447 s->max_chain_length = configuration_table[level].max_chain; 447 s->max_chain_length = configuration_table[level].max_chain;
448 } 448 }
449 s->strategy = strategy; 449 s->strategy = strategy;
450 return err; 450 return err;
451} 451}
452 452
453/* ========================================================================= */ 453/* ========================================================================= */
454int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) 454int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
455 z_streamp strm; 455 z_streamp strm;
456 int good_length; 456 int good_length;
457 int max_lazy; 457 int max_lazy;
458 int nice_length; 458 int nice_length;
459 int max_chain; 459 int max_chain;
460{ 460{
461 deflate_state *s; 461 deflate_state *s;
462 462
463 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 463 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
464 s = strm->state; 464 s = strm->state;
465 s->good_match = good_length; 465 s->good_match = good_length;
466 s->max_lazy_match = max_lazy; 466 s->max_lazy_match = max_lazy;
467 s->nice_match = nice_length; 467 s->nice_match = nice_length;
468 s->max_chain_length = max_chain; 468 s->max_chain_length = max_chain;
469 return Z_OK; 469 return Z_OK;
470} 470}
471 471
472/* ========================================================================= 472/* =========================================================================
473 * For the default windowBits of 15 and memLevel of 8, this function returns 473 * For the default windowBits of 15 and memLevel of 8, this function returns
474 * a close to exact, as well as small, upper bound on the compressed size. 474 * a close to exact, as well as small, upper bound on the compressed size.
475 * They are coded as constants here for a reason--if the #define's are 475 * They are coded as constants here for a reason--if the #define's are
476 * changed, then this function needs to be changed as well. The return 476 * changed, then this function needs to be changed as well. The return
477 * value for 15 and 8 only works for those exact settings. 477 * value for 15 and 8 only works for those exact settings.
478 * 478 *
479 * For any setting other than those defaults for windowBits and memLevel, 479 * For any setting other than those defaults for windowBits and memLevel,
480 * the value returned is a conservative worst case for the maximum expansion 480 * the value returned is a conservative worst case for the maximum expansion
481 * resulting from using fixed blocks instead of stored blocks, which deflate 481 * resulting from using fixed blocks instead of stored blocks, which deflate
482 * can emit on compressed data for some combinations of the parameters. 482 * can emit on compressed data for some combinations of the parameters.
483 * 483 *
484 * This function could be more sophisticated to provide closer upper bounds 484 * This function could be more sophisticated to provide closer upper bounds
485 * for every combination of windowBits and memLevel, as well as wrap. 485 * for every combination of windowBits and memLevel, as well as wrap.
486 * But even the conservative upper bound of about 14% expansion does not 486 * But even the conservative upper bound of about 14% expansion does not
487 * seem onerous for output buffer allocation. 487 * seem onerous for output buffer allocation.
488 */ 488 */
489uLong ZEXPORT deflateBound(strm, sourceLen) 489uLong ZEXPORT deflateBound(strm, sourceLen)
490 z_streamp strm; 490 z_streamp strm;
491 uLong sourceLen; 491 uLong sourceLen;
492{ 492{
493 deflate_state *s; 493 deflate_state *s;
494 uLong destLen; 494 uLong destLen;
495 495
496 /* conservative upper bound */ 496 /* conservative upper bound */
497 destLen = sourceLen + 497 destLen = sourceLen +
498 ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 11; 498 ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 11;
499 499
500 /* if can't get parameters, return conservative bound */ 500 /* if can't get parameters, return conservative bound */
501 if (strm == Z_NULL || strm->state == Z_NULL) 501 if (strm == Z_NULL || strm->state == Z_NULL)
502 return destLen; 502 return destLen;
503 503
504 /* if not default parameters, return conservative bound */ 504 /* if not default parameters, return conservative bound */
505 s = strm->state; 505 s = strm->state;
506 if (s->w_bits != 15 || s->hash_bits != 8 + 7) 506 if (s->w_bits != 15 || s->hash_bits != 8 + 7)
507 return destLen; 507 return destLen;
508 508
509 /* default settings: return tight bound for that case */ 509 /* default settings: return tight bound for that case */
510 return compressBound(sourceLen); 510 return compressBound(sourceLen);
511} 511}
512 512
513/* ========================================================================= 513/* =========================================================================
514 * Put a short in the pending buffer. The 16-bit value is put in MSB order. 514 * Put a short in the pending buffer. The 16-bit value is put in MSB order.
515 * IN assertion: the stream state is correct and there is enough room in 515 * IN assertion: the stream state is correct and there is enough room in
516 * pending_buf. 516 * pending_buf.
517 */ 517 */
518local void putShortMSB (s, b) 518local void putShortMSB (s, b)
519 deflate_state *s; 519 deflate_state *s;
520 uInt b; 520 uInt b;
521{ 521{
522 put_byte(s, (Byte)(b >> 8)); 522 put_byte(s, (Byte)(b >> 8));
523 put_byte(s, (Byte)(b & 0xff)); 523 put_byte(s, (Byte)(b & 0xff));
524} 524}
525 525
526/* ========================================================================= 526/* =========================================================================
527 * Flush as much pending output as possible. All deflate() output goes 527 * Flush as much pending output as possible. All deflate() output goes
528 * through this function so some applications may wish to modify it 528 * through this function so some applications may wish to modify it
529 * to avoid allocating a large strm->next_out buffer and copying into it. 529 * to avoid allocating a large strm->next_out buffer and copying into it.
530 * (See also read_buf()). 530 * (See also read_buf()).
531 */ 531 */
532local void flush_pending(strm) 532local void flush_pending(strm)
533 z_streamp strm; 533 z_streamp strm;
534{ 534{
535 unsigned len = strm->state->pending; 535 unsigned len = strm->state->pending;
536 536
537 if (len > strm->avail_out) len = strm->avail_out; 537 if (len > strm->avail_out) len = strm->avail_out;
538 if (len == 0) return; 538 if (len == 0) return;
539 539
540 zmemcpy(strm->next_out, strm->state->pending_out, len); 540 zmemcpy(strm->next_out, strm->state->pending_out, len);
541 strm->next_out += len; 541 strm->next_out += len;
542 strm->state->pending_out += len; 542 strm->state->pending_out += len;
543 strm->total_out += len; 543 strm->total_out += len;
544 strm->avail_out -= len; 544 strm->avail_out -= len;
545 strm->state->pending -= len; 545 strm->state->pending -= len;
546 if (strm->state->pending == 0) { 546 if (strm->state->pending == 0) {
547 strm->state->pending_out = strm->state->pending_buf; 547 strm->state->pending_out = strm->state->pending_buf;
548 } 548 }
549} 549}
550 550
551/* ========================================================================= */ 551/* ========================================================================= */
552int ZEXPORT deflate (strm, flush) 552int ZEXPORT deflate (strm, flush)
553 z_streamp strm; 553 z_streamp strm;
554 int flush; 554 int flush;
555{ 555{
556 int old_flush; /* value of flush param for previous deflate call */ 556 int old_flush; /* value of flush param for previous deflate call */
557 deflate_state *s; 557 deflate_state *s;
558 558
559 if (strm == Z_NULL || strm->state == Z_NULL || 559 if (strm == Z_NULL || strm->state == Z_NULL ||
560 flush > Z_FINISH || flush < 0) { 560 flush > Z_FINISH || flush < 0) {
561 return Z_STREAM_ERROR; 561 return Z_STREAM_ERROR;
562 } 562 }
563 s = strm->state; 563 s = strm->state;
564 564
565 if (strm->next_out == Z_NULL || 565 if (strm->next_out == Z_NULL ||
566 (strm->next_in == Z_NULL && strm->avail_in != 0) || 566 (strm->next_in == Z_NULL && strm->avail_in != 0) ||
567 (s->status == FINISH_STATE && flush != Z_FINISH)) { 567 (s->status == FINISH_STATE && flush != Z_FINISH)) {
568 ERR_RETURN(strm, Z_STREAM_ERROR); 568 ERR_RETURN(strm, Z_STREAM_ERROR);
569 } 569 }
570 if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); 570 if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
571 571
572 s->strm = strm; /* just in case */ 572 s->strm = strm; /* just in case */
573 old_flush = s->last_flush; 573 old_flush = s->last_flush;
574 s->last_flush = flush; 574 s->last_flush = flush;
575 575
576 /* Write the header */ 576 /* Write the header */
577 if (s->status == INIT_STATE) { 577 if (s->status == INIT_STATE) {
578#ifdef GZIP 578#ifdef GZIP
579 if (s->wrap == 2) { 579 if (s->wrap == 2) {
580 strm->adler = crc32(0L, Z_NULL, 0); 580 strm->adler = crc32(0L, Z_NULL, 0);
581 put_byte(s, 31); 581 put_byte(s, 31);
582 put_byte(s, 139); 582 put_byte(s, 139);
583 put_byte(s, 8); 583 put_byte(s, 8);
584 if (s->gzhead == NULL) { 584 if (s->gzhead == NULL) {
585 put_byte(s, 0); 585 put_byte(s, 0);
586 put_byte(s, 0); 586 put_byte(s, 0);
587 put_byte(s, 0); 587 put_byte(s, 0);
588 put_byte(s, 0); 588 put_byte(s, 0);
589 put_byte(s, 0); 589 put_byte(s, 0);
590 put_byte(s, s->level == 9 ? 2 : 590 put_byte(s, s->level == 9 ? 2 :
591 (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? 591 (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
592 4 : 0)); 592 4 : 0));
593 put_byte(s, OS_CODE); 593 put_byte(s, OS_CODE);
594 s->status = BUSY_STATE; 594 s->status = BUSY_STATE;
595 } 595 }
596 else { 596 else {
597 put_byte(s, (s->gzhead->text ? 1 : 0) + 597 put_byte(s, (s->gzhead->text ? 1 : 0) +
598 (s->gzhead->hcrc ? 2 : 0) + 598 (s->gzhead->hcrc ? 2 : 0) +
599 (s->gzhead->extra == Z_NULL ? 0 : 4) + 599 (s->gzhead->extra == Z_NULL ? 0 : 4) +
600 (s->gzhead->name == Z_NULL ? 0 : 8) + 600 (s->gzhead->name == Z_NULL ? 0 : 8) +
601 (s->gzhead->comment == Z_NULL ? 0 : 16) 601 (s->gzhead->comment == Z_NULL ? 0 : 16)
602 ); 602 );
603 put_byte(s, (Byte)(s->gzhead->time & 0xff)); 603 put_byte(s, (Byte)(s->gzhead->time & 0xff));
604 put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); 604 put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
605 put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); 605 put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
606 put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); 606 put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
607 put_byte(s, s->level == 9 ? 2 : 607 put_byte(s, s->level == 9 ? 2 :
608 (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? 608 (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
609 4 : 0)); 609 4 : 0));
610 put_byte(s, s->gzhead->os & 0xff); 610 put_byte(s, s->gzhead->os & 0xff);
611 if (s->gzhead->extra != NULL) { 611 if (s->gzhead->extra != NULL) {
612 put_byte(s, s->gzhead->extra_len & 0xff); 612 put_byte(s, s->gzhead->extra_len & 0xff);
613 put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); 613 put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
614 } 614 }
615 if (s->gzhead->hcrc) 615 if (s->gzhead->hcrc)
616 strm->adler = crc32(strm->adler, s->pending_buf, 616 strm->adler = crc32(strm->adler, s->pending_buf,
617 s->pending); 617 s->pending);
618 s->gzindex = 0; 618 s->gzindex = 0;
619 s->status = EXTRA_STATE; 619 s->status = EXTRA_STATE;
620 } 620 }
621 } 621 }
622 else 622 else
623#endif 623#endif
624 { 624 {
625 uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; 625 uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
626 uInt level_flags; 626 uInt level_flags;
627 627
628 if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) 628 if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
629 level_flags = 0; 629 level_flags = 0;
630 else if (s->level < 6) 630 else if (s->level < 6)
631 level_flags = 1; 631 level_flags = 1;
632 else if (s->level == 6) 632 else if (s->level == 6)
633 level_flags = 2; 633 level_flags = 2;
634 else 634 else
635 level_flags = 3; 635 level_flags = 3;
636 header |= (level_flags << 6); 636 header |= (level_flags << 6);
637 if (s->strstart != 0) header |= PRESET_DICT; 637 if (s->strstart != 0) header |= PRESET_DICT;
638 header += 31 - (header % 31); 638 header += 31 - (header % 31);
639 639
640 s->status = BUSY_STATE; 640 s->status = BUSY_STATE;
641 putShortMSB(s, header); 641 putShortMSB(s, header);
642 642
643 /* Save the adler32 of the preset dictionary: */ 643 /* Save the adler32 of the preset dictionary: */
644 if (s->strstart != 0) { 644 if (s->strstart != 0) {
645 putShortMSB(s, (uInt)(strm->adler >> 16)); 645 putShortMSB(s, (uInt)(strm->adler >> 16));
646 putShortMSB(s, (uInt)(strm->adler & 0xffff)); 646 putShortMSB(s, (uInt)(strm->adler & 0xffff));
647 } 647 }
648 strm->adler = adler32(0L, Z_NULL, 0); 648 strm->adler = adler32(0L, Z_NULL, 0);
649 } 649 }
650 } 650 }
651#ifdef GZIP 651#ifdef GZIP
652 if (s->status == EXTRA_STATE) { 652 if (s->status == EXTRA_STATE) {
653 if (s->gzhead->extra != NULL) { 653 if (s->gzhead->extra != NULL) {
654 uInt beg = s->pending; /* start of bytes to update crc */ 654 uInt beg = s->pending; /* start of bytes to update crc */
655 655
656 while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { 656 while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
657 if (s->pending == s->pending_buf_size) { 657 if (s->pending == s->pending_buf_size) {
658 if (s->gzhead->hcrc && s->pending > beg) 658 if (s->gzhead->hcrc && s->pending > beg)
659 strm->adler = crc32(strm->adler, s->pending_buf + beg, 659 strm->adler = crc32(strm->adler, s->pending_buf + beg,
660 s->pending - beg); 660 s->pending - beg);
661 flush_pending(strm); 661 flush_pending(strm);
662 beg = s->pending; 662 beg = s->pending;
663 if (s->pending == s->pending_buf_size) 663 if (s->pending == s->pending_buf_size)
664 break; 664 break;
665 } 665 }
666 put_byte(s, s->gzhead->extra[s->gzindex]); 666 put_byte(s, s->gzhead->extra[s->gzindex]);
667 s->gzindex++; 667 s->gzindex++;
668 } 668 }
669 if (s->gzhead->hcrc && s->pending > beg) 669 if (s->gzhead->hcrc && s->pending > beg)
670 strm->adler = crc32(strm->adler, s->pending_buf + beg, 670 strm->adler = crc32(strm->adler, s->pending_buf + beg,
671 s->pending - beg); 671 s->pending - beg);
672 if (s->gzindex == s->gzhead->extra_len) { 672 if (s->gzindex == s->gzhead->extra_len) {
673 s->gzindex = 0; 673 s->gzindex = 0;
674 s->status = NAME_STATE; 674 s->status = NAME_STATE;
675 } 675 }
676 } 676 }
677 else 677 else
678 s->status = NAME_STATE; 678 s->status = NAME_STATE;
679 } 679 }
680 if (s->status == NAME_STATE) { 680 if (s->status == NAME_STATE) {
681 if (s->gzhead->name != NULL) { 681 if (s->gzhead->name != NULL) {
682 uInt beg = s->pending; /* start of bytes to update crc */ 682 uInt beg = s->pending; /* start of bytes to update crc */
683 int val; 683 int val;
684 684
685 do { 685 do {
686 if (s->pending == s->pending_buf_size) { 686 if (s->pending == s->pending_buf_size) {
687 if (s->gzhead->hcrc && s->pending > beg) 687 if (s->gzhead->hcrc && s->pending > beg)
688 strm->adler = crc32(strm->adler, s->pending_buf + beg, 688 strm->adler = crc32(strm->adler, s->pending_buf + beg,
689 s->pending - beg); 689 s->pending - beg);
690 flush_pending(strm); 690 flush_pending(strm);
691 beg = s->pending; 691 beg = s->pending;
692 if (s->pending == s->pending_buf_size) { 692 if (s->pending == s->pending_buf_size) {
693 val = 1; 693 val = 1;
694 break; 694 break;
695 } 695 }
696 } 696 }
697 val = s->gzhead->name[s->gzindex++]; 697 val = s->gzhead->name[s->gzindex++];
698 put_byte(s, val); 698 put_byte(s, val);
699 } while (val != 0); 699 } while (val != 0);
700 if (s->gzhead->hcrc && s->pending > beg) 700 if (s->gzhead->hcrc && s->pending > beg)
701 strm->adler = crc32(strm->adler, s->pending_buf + beg, 701 strm->adler = crc32(strm->adler, s->pending_buf + beg,
702 s->pending - beg); 702 s->pending - beg);
703 if (val == 0) { 703 if (val == 0) {
704 s->gzindex = 0; 704 s->gzindex = 0;
705 s->status = COMMENT_STATE; 705 s->status = COMMENT_STATE;
706 } 706 }
707 } 707 }
708 else 708 else
709 s->status = COMMENT_STATE; 709 s->status = COMMENT_STATE;
710 } 710 }
711 if (s->status == COMMENT_STATE) { 711 if (s->status == COMMENT_STATE) {
712 if (s->gzhead->comment != NULL) { 712 if (s->gzhead->comment != NULL) {
713 uInt beg = s->pending; /* start of bytes to update crc */ 713 uInt beg = s->pending; /* start of bytes to update crc */
714 int val; 714 int val;
715 715
716 do { 716 do {
717 if (s->pending == s->pending_buf_size) { 717 if (s->pending == s->pending_buf_size) {
718 if (s->gzhead->hcrc && s->pending > beg) 718 if (s->gzhead->hcrc && s->pending > beg)
719 strm->adler = crc32(strm->adler, s->pending_buf + beg, 719 strm->adler = crc32(strm->adler, s->pending_buf + beg,
720 s->pending - beg); 720 s->pending - beg);
721 flush_pending(strm); 721 flush_pending(strm);
722 beg = s->pending; 722 beg = s->pending;
723 if (s->pending == s->pending_buf_size) { 723 if (s->pending == s->pending_buf_size) {
724 val = 1; 724 val = 1;
725 break; 725 break;
726 } 726 }
727 } 727 }
728 val = s->gzhead->comment[s->gzindex++]; 728 val = s->gzhead->comment[s->gzindex++];
729 put_byte(s, val); 729 put_byte(s, val);
730 } while (val != 0); 730 } while (val != 0);
731 if (s->gzhead->hcrc && s->pending > beg) 731 if (s->gzhead->hcrc && s->pending > beg)
732 strm->adler = crc32(strm->adler, s->pending_buf + beg, 732 strm->adler = crc32(strm->adler, s->pending_buf + beg,
733 s->pending - beg); 733 s->pending - beg);
734 if (val == 0) 734 if (val == 0)
735 s->status = HCRC_STATE; 735 s->status = HCRC_STATE;
736 } 736 }
737 else 737 else
738 s->status = HCRC_STATE; 738 s->status = HCRC_STATE;
739 } 739 }
740 if (s->status == HCRC_STATE) { 740 if (s->status == HCRC_STATE) {
741 if (s->gzhead->hcrc) { 741 if (s->gzhead->hcrc) {
742 if (s->pending + 2 > s->pending_buf_size) 742 if (s->pending + 2 > s->pending_buf_size)
743 flush_pending(strm); 743 flush_pending(strm);
744 if (s->pending + 2 <= s->pending_buf_size) { 744 if (s->pending + 2 <= s->pending_buf_size) {
745 put_byte(s, (Byte)(strm->adler & 0xff)); 745 put_byte(s, (Byte)(strm->adler & 0xff));
746 put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); 746 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
747 strm->adler = crc32(0L, Z_NULL, 0); 747 strm->adler = crc32(0L, Z_NULL, 0);
748 s->status = BUSY_STATE; 748 s->status = BUSY_STATE;
749 } 749 }
750 } 750 }
751 else 751 else
752 s->status = BUSY_STATE; 752 s->status = BUSY_STATE;
753 } 753 }
754#endif 754#endif
755 755
756 /* Flush as much pending output as possible */ 756 /* Flush as much pending output as possible */
757 if (s->pending != 0) { 757 if (s->pending != 0) {
758 flush_pending(strm); 758 flush_pending(strm);
759 if (strm->avail_out == 0) { 759 if (strm->avail_out == 0) {
760 /* Since avail_out is 0, deflate will be called again with 760 /* Since avail_out is 0, deflate will be called again with
761 * more output space, but possibly with both pending and 761 * more output space, but possibly with both pending and
762 * avail_in equal to zero. There won't be anything to do, 762 * avail_in equal to zero. There won't be anything to do,
763 * but this is not an error situation so make sure we 763 * but this is not an error situation so make sure we
764 * return OK instead of BUF_ERROR at next call of deflate: 764 * return OK instead of BUF_ERROR at next call of deflate:
765 */ 765 */
766 s->last_flush = -1; 766 s->last_flush = -1;
767 return Z_OK; 767 return Z_OK;
768 } 768 }
769 769
770 /* Make sure there is something to do and avoid duplicate consecutive 770 /* Make sure there is something to do and avoid duplicate consecutive
771 * flushes. For repeated and useless calls with Z_FINISH, we keep 771 * flushes. For repeated and useless calls with Z_FINISH, we keep
772 * returning Z_STREAM_END instead of Z_BUF_ERROR. 772 * returning Z_STREAM_END instead of Z_BUF_ERROR.
773 */ 773 */
774 } else if (strm->avail_in == 0 && flush <= old_flush && 774 } else if (strm->avail_in == 0 && flush <= old_flush &&
775 flush != Z_FINISH) { 775 flush != Z_FINISH) {
776 ERR_RETURN(strm, Z_BUF_ERROR); 776 ERR_RETURN(strm, Z_BUF_ERROR);
777 } 777 }
778 778
779 /* User must not provide more input after the first FINISH: */ 779 /* User must not provide more input after the first FINISH: */
780 if (s->status == FINISH_STATE && strm->avail_in != 0) { 780 if (s->status == FINISH_STATE && strm->avail_in != 0) {
781 ERR_RETURN(strm, Z_BUF_ERROR); 781 ERR_RETURN(strm, Z_BUF_ERROR);
782 } 782 }
783 783
784 /* Start a new block or continue the current one. 784 /* Start a new block or continue the current one.
785 */ 785 */
786 if (strm->avail_in != 0 || s->lookahead != 0 || 786 if (strm->avail_in != 0 || s->lookahead != 0 ||
787 (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { 787 (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
788 block_state bstate; 788 block_state bstate;
789 789
790 bstate = (*(configuration_table[s->level].func))(s, flush); 790 bstate = (*(configuration_table[s->level].func))(s, flush);
791 791
792 if (bstate == finish_started || bstate == finish_done) { 792 if (bstate == finish_started || bstate == finish_done) {
793 s->status = FINISH_STATE; 793 s->status = FINISH_STATE;
794 } 794 }
795 if (bstate == need_more || bstate == finish_started) { 795 if (bstate == need_more || bstate == finish_started) {
796 if (strm->avail_out == 0) { 796 if (strm->avail_out == 0) {
797 s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ 797 s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
798 } 798 }
799 return Z_OK; 799 return Z_OK;
800 /* If flush != Z_NO_FLUSH && avail_out == 0, the next call 800 /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
801 * of deflate should use the same flush parameter to make sure 801 * of deflate should use the same flush parameter to make sure
802 * that the flush is complete. So we don't have to output an 802 * that the flush is complete. So we don't have to output an
803 * empty block here, this will be done at next call. This also 803 * empty block here, this will be done at next call. This also
804 * ensures that for a very small output buffer, we emit at most 804 * ensures that for a very small output buffer, we emit at most
805 * one empty block. 805 * one empty block.
806 */ 806 */
807 } 807 }
808 if (bstate == block_done) { 808 if (bstate == block_done) {
809 if (flush == Z_PARTIAL_FLUSH) { 809 if (flush == Z_PARTIAL_FLUSH) {
810 _tr_align(s); 810 _tr_align(s);
811 } else { /* FULL_FLUSH or SYNC_FLUSH */ 811 } else { /* FULL_FLUSH or SYNC_FLUSH */
812 _tr_stored_block(s, (char*)0, 0L, 0); 812 _tr_stored_block(s, (char*)0, 0L, 0);
813 /* For a full flush, this empty block will be recognized 813 /* For a full flush, this empty block will be recognized
814 * as a special marker by inflate_sync(). 814 * as a special marker by inflate_sync().
815 */ 815 */
816 if (flush == Z_FULL_FLUSH) { 816 if (flush == Z_FULL_FLUSH) {
817 CLEAR_HASH(s); /* forget history */ 817 CLEAR_HASH(s); /* forget history */
818 } 818 }
819 } 819 }
820 flush_pending(strm); 820 flush_pending(strm);
821 if (strm->avail_out == 0) { 821 if (strm->avail_out == 0) {
822 s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ 822 s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
823 return Z_OK; 823 return Z_OK;
824 } 824 }
825 } 825 }
826 } 826 }
827 Assert(strm->avail_out > 0, "bug2"); 827 Assert(strm->avail_out > 0, "bug2");
828 828
829 if (flush != Z_FINISH) return Z_OK; 829 if (flush != Z_FINISH) return Z_OK;
830 if (s->wrap <= 0) return Z_STREAM_END; 830 if (s->wrap <= 0) return Z_STREAM_END;
831 831
832 /* Write the trailer */ 832 /* Write the trailer */
833#ifdef GZIP 833#ifdef GZIP
834 if (s->wrap == 2) { 834 if (s->wrap == 2) {
835 put_byte(s, (Byte)(strm->adler & 0xff)); 835 put_byte(s, (Byte)(strm->adler & 0xff));
836 put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); 836 put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
837 put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); 837 put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
838 put_byte(s, (Byte)((strm->adler >> 24) & 0xff)); 838 put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
839 put_byte(s, (Byte)(strm->total_in & 0xff)); 839 put_byte(s, (Byte)(strm->total_in & 0xff));
840 put_byte(s, (Byte)((strm->total_in >> 8) & 0xff)); 840 put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
841 put_byte(s, (Byte)((strm->total_in >> 16) & 0xff)); 841 put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
842 put_byte(s, (Byte)((strm->total_in >> 24) & 0xff)); 842 put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
843 } 843 }
844 else 844 else
845#endif 845#endif
846 { 846 {
847 putShortMSB(s, (uInt)(strm->adler >> 16)); 847 putShortMSB(s, (uInt)(strm->adler >> 16));
848 putShortMSB(s, (uInt)(strm->adler & 0xffff)); 848 putShortMSB(s, (uInt)(strm->adler & 0xffff));
849 } 849 }
850 flush_pending(strm); 850 flush_pending(strm);
851 /* If avail_out is zero, the application will call deflate again 851 /* If avail_out is zero, the application will call deflate again
852 * to flush the rest. 852 * to flush the rest.
853 */ 853 */
854 if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ 854 if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
855 return s->pending != 0 ? Z_OK : Z_STREAM_END; 855 return s->pending != 0 ? Z_OK : Z_STREAM_END;
856} 856}
857 857
858/* ========================================================================= */ 858/* ========================================================================= */
859int ZEXPORT deflateEnd (strm) 859int ZEXPORT deflateEnd (strm)
860 z_streamp strm; 860 z_streamp strm;
861{ 861{
862 int status; 862 int status;
863 863
864 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; 864 if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
865 865
866 status = strm->state->status; 866 status = strm->state->status;
867 if (status != INIT_STATE && 867 if (status != INIT_STATE &&
868 status != EXTRA_STATE && 868 status != EXTRA_STATE &&
869 status != NAME_STATE && 869 status != NAME_STATE &&
870 status != COMMENT_STATE && 870 status != COMMENT_STATE &&
871 status != HCRC_STATE && 871 status != HCRC_STATE &&
872 status != BUSY_STATE && 872 status != BUSY_STATE &&
873 status != FINISH_STATE) { 873 status != FINISH_STATE) {
874 return Z_STREAM_ERROR; 874 return Z_STREAM_ERROR;
875 } 875 }
876 876
877 /* Deallocate in reverse order of allocations: */ 877 /* Deallocate in reverse order of allocations: */
878 TRY_FREE(strm, strm->state->pending_buf); 878 TRY_FREE(strm, strm->state->pending_buf);
879 TRY_FREE(strm, strm->state->head); 879 TRY_FREE(strm, strm->state->head);
880 TRY_FREE(strm, strm->state->prev); 880 TRY_FREE(strm, strm->state->prev);
881 TRY_FREE(strm, strm->state->window); 881 TRY_FREE(strm, strm->state->window);
882 882
883 ZFREE(strm, strm->state); 883 ZFREE(strm, strm->state);
884 strm->state = Z_NULL; 884 strm->state = Z_NULL;
885 885
886 return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; 886 return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
887} 887}
888 888
889/* ========================================================================= 889/* =========================================================================
890 * Copy the source state to the destination state. 890 * Copy the source state to the destination state.
891 * To simplify the source, this is not supported for 16-bit MSDOS (which 891 * To simplify the source, this is not supported for 16-bit MSDOS (which
892 * doesn't have enough memory anyway to duplicate compression states). 892 * doesn't have enough memory anyway to duplicate compression states).
893 */ 893 */
894int ZEXPORT deflateCopy (dest, source) 894int ZEXPORT deflateCopy (dest, source)
895 z_streamp dest; 895 z_streamp dest;
896 z_streamp source; 896 z_streamp source;
897{ 897{
898#ifdef MAXSEG_64K 898#ifdef MAXSEG_64K
899 return Z_STREAM_ERROR; 899 return Z_STREAM_ERROR;
900#else 900#else
901 deflate_state *ds; 901 deflate_state *ds;
902 deflate_state *ss; 902 deflate_state *ss;
903 ushf *overlay; 903 ushf *overlay;
904 904
905 905
906 if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { 906 if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
907 return Z_STREAM_ERROR; 907 return Z_STREAM_ERROR;
908 } 908 }
909 909
910 ss = source->state; 910 ss = source->state;
911 911
912 zmemcpy(dest, source, sizeof(z_stream)); 912 zmemcpy(dest, source, sizeof(z_stream));
913 913
914 ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); 914 ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
915 if (ds == Z_NULL) return Z_MEM_ERROR; 915 if (ds == Z_NULL) return Z_MEM_ERROR;
916 dest->state = (struct internal_state FAR *) ds; 916 dest->state = (struct internal_state FAR *) ds;
917 zmemcpy(ds, ss, sizeof(deflate_state)); 917 zmemcpy(ds, ss, sizeof(deflate_state));
918 ds->strm = dest; 918 ds->strm = dest;
919 919
920 ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); 920 ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
921 ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); 921 ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos));
922 ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); 922 ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos));
923 overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); 923 overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
924 ds->pending_buf = (uchf *) overlay; 924 ds->pending_buf = (uchf *) overlay;
925 925
926 if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || 926 if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
927 ds->pending_buf == Z_NULL) { 927 ds->pending_buf == Z_NULL) {
928 deflateEnd (dest); 928 deflateEnd (dest);
929 return Z_MEM_ERROR; 929 return Z_MEM_ERROR;
930 } 930 }
931 /* following zmemcpy do not work for 16-bit MSDOS */ 931 /* following zmemcpy do not work for 16-bit MSDOS */
932 zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); 932 zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
933 zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos)); 933 zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos));
934 zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos)); 934 zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos));
935 zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); 935 zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
936 936
937 ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); 937 ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
938 ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); 938 ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
939 ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; 939 ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
940 940
941 ds->l_desc.dyn_tree = ds->dyn_ltree; 941 ds->l_desc.dyn_tree = ds->dyn_ltree;
942 ds->d_desc.dyn_tree = ds->dyn_dtree; 942 ds->d_desc.dyn_tree = ds->dyn_dtree;
943 ds->bl_desc.dyn_tree = ds->bl_tree; 943 ds->bl_desc.dyn_tree = ds->bl_tree;
944 944
945 return Z_OK; 945 return Z_OK;
946#endif /* MAXSEG_64K */ 946#endif /* MAXSEG_64K */
947} 947}
948 948
949/* =========================================================================== 949/* ===========================================================================
950 * Read a new buffer from the current input stream, update the adler32 950 * Read a new buffer from the current input stream, update the adler32
951 * and total number of bytes read. All deflate() input goes through 951 * and total number of bytes read. All deflate() input goes through
952 * this function so some applications may wish to modify it to avoid 952 * this function so some applications may wish to modify it to avoid
953 * allocating a large strm->next_in buffer and copying from it. 953 * allocating a large strm->next_in buffer and copying from it.
954 * (See also flush_pending()). 954 * (See also flush_pending()).
955 */ 955 */
956local int read_buf(strm, buf, size) 956local int read_buf(strm, buf, size)
957 z_streamp strm; 957 z_streamp strm;
958 Bytef *buf; 958 Bytef *buf;
959 unsigned size; 959 unsigned size;
960{ 960{
961 unsigned len = strm->avail_in; 961 unsigned len = strm->avail_in;
962 962
963 if (len > size) len = size; 963 if (len > size) len = size;
964 if (len == 0) return 0; 964 if (len == 0) return 0;
965 965
966 strm->avail_in -= len; 966 strm->avail_in -= len;
967 967
968 if (strm->state->wrap == 1) { 968 if (strm->state->wrap == 1) {
969 strm->adler = adler32(strm->adler, strm->next_in, len); 969 strm->adler = adler32(strm->adler, strm->next_in, len);
970 } 970 }
971#ifdef GZIP 971#ifdef GZIP
972 else if (strm->state->wrap == 2) { 972 else if (strm->state->wrap == 2) {
973 strm->adler = crc32(strm->adler, strm->next_in, len); 973 strm->adler = crc32(strm->adler, strm->next_in, len);
974 } 974 }
975#endif 975#endif
976 zmemcpy(buf, strm->next_in, len); 976 zmemcpy(buf, strm->next_in, len);
977 strm->next_in += len; 977 strm->next_in += len;
978 strm->total_in += len; 978 strm->total_in += len;
979 979
980 return (int)len; 980 return (int)len;
981} 981}
982 982
983/* =========================================================================== 983/* ===========================================================================
984 * Initialize the "longest match" routines for a new zlib stream 984 * Initialize the "longest match" routines for a new zlib stream
985 */ 985 */
986local void lm_init (s) 986local void lm_init (s)
987 deflate_state *s; 987 deflate_state *s;
988{ 988{
989 s->window_size = (ulg)2L*s->w_size; 989 s->window_size = (ulg)2L*s->w_size;
990 990
991 CLEAR_HASH(s); 991 CLEAR_HASH(s);
992 992
993 /* Set the default configuration parameters: 993 /* Set the default configuration parameters:
994 */ 994 */
995 s->max_lazy_match = configuration_table[s->level].max_lazy; 995 s->max_lazy_match = configuration_table[s->level].max_lazy;
996 s->good_match = configuration_table[s->level].good_length; 996 s->good_match = configuration_table[s->level].good_length;
997 s->nice_match = configuration_table[s->level].nice_length; 997 s->nice_match = configuration_table[s->level].nice_length;
998 s->max_chain_length = configuration_table[s->level].max_chain; 998 s->max_chain_length = configuration_table[s->level].max_chain;
999 999
1000 s->strstart = 0; 1000 s->strstart = 0;
1001 s->block_start = 0L; 1001 s->block_start = 0L;
1002 s->lookahead = 0; 1002 s->lookahead = 0;
1003 s->match_length = s->prev_length = MIN_MATCH-1; 1003 s->match_length = s->prev_length = MIN_MATCH-1;
1004 s->match_available = 0; 1004 s->match_available = 0;
1005 s->ins_h = 0; 1005 s->ins_h = 0;
1006#ifndef FASTEST 1006#ifndef FASTEST
1007#ifdef ASMV 1007#ifdef ASMV
1008 match_init(); /* initialize the asm code */ 1008 match_init(); /* initialize the asm code */
1009#endif 1009#endif
1010#endif 1010#endif
1011} 1011}
1012 1012
1013#ifndef FASTEST 1013#ifndef FASTEST
1014/* =========================================================================== 1014/* ===========================================================================
1015 * Set match_start to the longest match starting at the given string and 1015 * Set match_start to the longest match starting at the given string and
1016 * return its length. Matches shorter or equal to prev_length are discarded, 1016 * return its length. Matches shorter or equal to prev_length are discarded,
1017 * in which case the result is equal to prev_length and match_start is 1017 * in which case the result is equal to prev_length and match_start is
1018 * garbage. 1018 * garbage.
1019 * IN assertions: cur_match is the head of the hash chain for the current 1019 * IN assertions: cur_match is the head of the hash chain for the current
1020 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 1020 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
1021 * OUT assertion: the match length is not greater than s->lookahead. 1021 * OUT assertion: the match length is not greater than s->lookahead.
1022 */ 1022 */
1023#ifndef ASMV 1023#ifndef ASMV
1024/* For 80x86 and 680x0, an optimized version will be provided in match.asm or 1024/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
1025 * match.S. The code will be functionally equivalent. 1025 * match.S. The code will be functionally equivalent.
1026 */ 1026 */
1027local uInt longest_match(s, cur_match) 1027local uInt longest_match(s, cur_match)
1028 deflate_state *s; 1028 deflate_state *s;
1029 IPos cur_match; /* current match */ 1029 IPos cur_match; /* current match */
1030{ 1030{
1031 unsigned chain_length = s->max_chain_length;/* max hash chain length */ 1031 unsigned chain_length = s->max_chain_length;/* max hash chain length */
1032 register Bytef *scan = s->window + s->strstart; /* current string */ 1032 register Bytef *scan = s->window + s->strstart; /* current string */
1033 register Bytef *match; /* matched string */ 1033 register Bytef *match; /* matched string */
1034 register int len; /* length of current match */ 1034 register int len; /* length of current match */
1035 int best_len = s->prev_length; /* best match length so far */ 1035 int best_len = s->prev_length; /* best match length so far */
1036 int nice_match = s->nice_match; /* stop if match long enough */ 1036 int nice_match = s->nice_match; /* stop if match long enough */
1037 IPos limit = s->strstart > (IPos)MAX_DIST(s) ? 1037 IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
1038 s->strstart - (IPos)MAX_DIST(s) : NIL; 1038 s->strstart - (IPos)MAX_DIST(s) : NIL;
1039 /* Stop when cur_match becomes <= limit. To simplify the code, 1039 /* Stop when cur_match becomes <= limit. To simplify the code,
1040 * we prevent matches with the string of window index 0. 1040 * we prevent matches with the string of window index 0.
1041 */ 1041 */
1042 Posf *prev = s->prev; 1042 Posf *prev = s->prev;
1043 uInt wmask = s->w_mask; 1043 uInt wmask = s->w_mask;
1044 1044
1045#ifdef UNALIGNED_OK 1045#ifdef UNALIGNED_OK
1046 /* Compare two bytes at a time. Note: this is not always beneficial. 1046 /* Compare two bytes at a time. Note: this is not always beneficial.
1047 * Try with and without -DUNALIGNED_OK to check. 1047 * Try with and without -DUNALIGNED_OK to check.
1048 */ 1048 */
1049 register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; 1049 register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
1050 register ush scan_start = *(ushf*)scan; 1050 register ush scan_start = *(ushf*)scan;
1051 register ush scan_end = *(ushf*)(scan+best_len-1); 1051 register ush scan_end = *(ushf*)(scan+best_len-1);
1052#else 1052#else
1053 register Bytef *strend = s->window + s->strstart + MAX_MATCH; 1053 register Bytef *strend = s->window + s->strstart + MAX_MATCH;
1054 register Byte scan_end1 = scan[best_len-1]; 1054 register Byte scan_end1 = scan[best_len-1];
1055 register Byte scan_end = scan[best_len]; 1055 register Byte scan_end = scan[best_len];
1056#endif 1056#endif
1057 1057
1058 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. 1058 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
1059 * It is easy to get rid of this optimization if necessary. 1059 * It is easy to get rid of this optimization if necessary.
1060 */ 1060 */
1061 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); 1061 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
1062 1062
1063 /* Do not waste too much time if we already have a good match: */ 1063 /* Do not waste too much time if we already have a good match: */
1064 if (s->prev_length >= s->good_match) { 1064 if (s->prev_length >= s->good_match) {
1065 chain_length >>= 2; 1065 chain_length >>= 2;
1066 } 1066 }
1067 /* Do not look for matches beyond the end of the input. This is necessary 1067 /* Do not look for matches beyond the end of the input. This is necessary
1068 * to make deflate deterministic. 1068 * to make deflate deterministic.
1069 */ 1069 */
1070 if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; 1070 if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
1071 1071
1072 Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); 1072 Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
1073 1073
1074 do { 1074 do {
1075 Assert(cur_match < s->strstart, "no future"); 1075 Assert(cur_match < s->strstart, "no future");
1076 match = s->window + cur_match; 1076 match = s->window + cur_match;
1077 1077
1078 /* Skip to next match if the match length cannot increase 1078 /* Skip to next match if the match length cannot increase
1079 * or if the match length is less than 2. Note that the checks below 1079 * or if the match length is less than 2. Note that the checks below
1080 * for insufficient lookahead only occur occasionally for performance 1080 * for insufficient lookahead only occur occasionally for performance
1081 * reasons. Therefore uninitialized memory will be accessed, and 1081 * reasons. Therefore uninitialized memory will be accessed, and
1082 * conditional jumps will be made that depend on those values. 1082 * conditional jumps will be made that depend on those values.
1083 * However the length of the match is limited to the lookahead, so 1083 * However the length of the match is limited to the lookahead, so
1084 * the output of deflate is not affected by the uninitialized values. 1084 * the output of deflate is not affected by the uninitialized values.
1085 */ 1085 */
1086#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) 1086#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
1087 /* This code assumes sizeof(unsigned short) == 2. Do not use 1087 /* This code assumes sizeof(unsigned short) == 2. Do not use
1088 * UNALIGNED_OK if your compiler uses a different size. 1088 * UNALIGNED_OK if your compiler uses a different size.
1089 */ 1089 */
1090 if (*(ushf*)(match+best_len-1) != scan_end || 1090 if (*(ushf*)(match+best_len-1) != scan_end ||
1091 *(ushf*)match != scan_start) continue; 1091 *(ushf*)match != scan_start) continue;
1092 1092
1093 /* It is not necessary to compare scan[2] and match[2] since they are 1093 /* It is not necessary to compare scan[2] and match[2] since they are
1094 * always equal when the other bytes match, given that the hash keys 1094 * always equal when the other bytes match, given that the hash keys
1095 * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at 1095 * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
1096 * strstart+3, +5, ... up to strstart+257. We check for insufficient 1096 * strstart+3, +5, ... up to strstart+257. We check for insufficient
1097 * lookahead only every 4th comparison; the 128th check will be made 1097 * lookahead only every 4th comparison; the 128th check will be made
1098 * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is 1098 * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
1099 * necessary to put more guard bytes at the end of the window, or 1099 * necessary to put more guard bytes at the end of the window, or
1100 * to check more often for insufficient lookahead. 1100 * to check more often for insufficient lookahead.
1101 */ 1101 */
1102 Assert(scan[2] == match[2], "scan[2]?"); 1102 Assert(scan[2] == match[2], "scan[2]?");
1103 scan++, match++; 1103 scan++, match++;
1104 do { 1104 do {
1105 } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && 1105 } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
1106 *(ushf*)(scan+=2) == *(ushf*)(match+=2) && 1106 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
1107 *(ushf*)(scan+=2) == *(ushf*)(match+=2) && 1107 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
1108 *(ushf*)(scan+=2) == *(ushf*)(match+=2) && 1108 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
1109 scan < strend); 1109 scan < strend);
1110 /* The funny "do {}" generates better code on most compilers */ 1110 /* The funny "do {}" generates better code on most compilers */
1111 1111
1112 /* Here, scan <= window+strstart+257 */ 1112 /* Here, scan <= window+strstart+257 */
1113 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); 1113 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
1114 if (*scan == *match) scan++; 1114 if (*scan == *match) scan++;
1115 1115
1116 len = (MAX_MATCH - 1) - (int)(strend-scan); 1116 len = (MAX_MATCH - 1) - (int)(strend-scan);
1117 scan = strend - (MAX_MATCH-1); 1117 scan = strend - (MAX_MATCH-1);
1118 1118
1119#else /* UNALIGNED_OK */ 1119#else /* UNALIGNED_OK */
1120 1120
1121 if (match[best_len] != scan_end || 1121 if (match[best_len] != scan_end ||
1122 match[best_len-1] != scan_end1 || 1122 match[best_len-1] != scan_end1 ||
1123 *match != *scan || 1123 *match != *scan ||
1124 *++match != scan[1]) continue; 1124 *++match != scan[1]) continue;
1125 1125
1126 /* The check at best_len-1 can be removed because it will be made 1126 /* The check at best_len-1 can be removed because it will be made
1127 * again later. (This heuristic is not always a win.) 1127 * again later. (This heuristic is not always a win.)
1128 * It is not necessary to compare scan[2] and match[2] since they 1128 * It is not necessary to compare scan[2] and match[2] since they
1129 * are always equal when the other bytes match, given that 1129 * are always equal when the other bytes match, given that
1130 * the hash keys are equal and that HASH_BITS >= 8. 1130 * the hash keys are equal and that HASH_BITS >= 8.
1131 */ 1131 */
1132 scan += 2, match++; 1132 scan += 2, match++;
1133 Assert(*scan == *match, "match[2]?"); 1133 Assert(*scan == *match, "match[2]?");
1134 1134
1135 /* We check for insufficient lookahead only every 8th comparison; 1135 /* We check for insufficient lookahead only every 8th comparison;
1136 * the 256th check will be made at strstart+258. 1136 * the 256th check will be made at strstart+258.
1137 */ 1137 */
1138 do { 1138 do {
1139 } while (*++scan == *++match && *++scan == *++match && 1139 } while (*++scan == *++match && *++scan == *++match &&
1140 *++scan == *++match && *++scan == *++match && 1140 *++scan == *++match && *++scan == *++match &&
1141 *++scan == *++match && *++scan == *++match && 1141 *++scan == *++match && *++scan == *++match &&
1142 *++scan == *++match && *++scan == *++match && 1142 *++scan == *++match && *++scan == *++match &&
1143 scan < strend); 1143 scan < strend);
1144 1144
1145 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); 1145 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
1146 1146
1147 len = MAX_MATCH - (int)(strend - scan); 1147 len = MAX_MATCH - (int)(strend - scan);
1148 scan = strend - MAX_MATCH; 1148 scan = strend - MAX_MATCH;
1149 1149
1150#endif /* UNALIGNED_OK */ 1150#endif /* UNALIGNED_OK */
1151 1151
1152 if (len > best_len) { 1152 if (len > best_len) {
1153 s->match_start = cur_match; 1153 s->match_start = cur_match;
1154 best_len = len; 1154 best_len = len;
1155 if (len >= nice_match) break; 1155 if (len >= nice_match) break;
1156#ifdef UNALIGNED_OK 1156#ifdef UNALIGNED_OK
1157 scan_end = *(ushf*)(scan+best_len-1); 1157 scan_end = *(ushf*)(scan+best_len-1);
1158#else 1158#else
1159 scan_end1 = scan[best_len-1]; 1159 scan_end1 = scan[best_len-1];
1160 scan_end = scan[best_len]; 1160 scan_end = scan[best_len];
1161#endif 1161#endif
1162 } 1162 }
1163 } while ((cur_match = prev[cur_match & wmask]) > limit 1163 } while ((cur_match = prev[cur_match & wmask]) > limit
1164 && --chain_length != 0); 1164 && --chain_length != 0);
1165 1165
1166 if ((uInt)best_len <= s->lookahead) return (uInt)best_len; 1166 if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
1167 return s->lookahead; 1167 return s->lookahead;
1168} 1168}
1169#endif /* ASMV */ 1169#endif /* ASMV */
1170#endif /* FASTEST */ 1170#endif /* FASTEST */
1171 1171
1172/* --------------------------------------------------------------------------- 1172/* ---------------------------------------------------------------------------
1173 * Optimized version for level == 1 or strategy == Z_RLE only 1173 * Optimized version for level == 1 or strategy == Z_RLE only
1174 */ 1174 */
1175local uInt longest_match_fast(s, cur_match) 1175local uInt longest_match_fast(s, cur_match)
1176 deflate_state *s; 1176 deflate_state *s;
1177 IPos cur_match; /* current match */ 1177 IPos cur_match; /* current match */
1178{ 1178{
1179 register Bytef *scan = s->window + s->strstart; /* current string */ 1179 register Bytef *scan = s->window + s->strstart; /* current string */
1180 register Bytef *match; /* matched string */ 1180 register Bytef *match; /* matched string */
1181 register int len; /* length of current match */ 1181 register int len; /* length of current match */
1182 register Bytef *strend = s->window + s->strstart + MAX_MATCH; 1182 register Bytef *strend = s->window + s->strstart + MAX_MATCH;
1183 1183
1184 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. 1184 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
1185 * It is easy to get rid of this optimization if necessary. 1185 * It is easy to get rid of this optimization if necessary.
1186 */ 1186 */
1187 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); 1187 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
1188 1188
1189 Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); 1189 Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
1190 1190
1191 Assert(cur_match < s->strstart, "no future"); 1191 Assert(cur_match < s->strstart, "no future");
1192 1192
1193 match = s->window + cur_match; 1193 match = s->window + cur_match;
1194 1194
1195 /* Return failure if the match length is less than 2: 1195 /* Return failure if the match length is less than 2:
1196 */ 1196 */
1197 if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; 1197 if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1;
1198 1198
1199 /* The check at best_len-1 can be removed because it will be made 1199 /* The check at best_len-1 can be removed because it will be made
1200 * again later. (This heuristic is not always a win.) 1200 * again later. (This heuristic is not always a win.)
1201 * It is not necessary to compare scan[2] and match[2] since they 1201 * It is not necessary to compare scan[2] and match[2] since they
1202 * are always equal when the other bytes match, given that 1202 * are always equal when the other bytes match, given that
1203 * the hash keys are equal and that HASH_BITS >= 8. 1203 * the hash keys are equal and that HASH_BITS >= 8.
1204 */ 1204 */
1205 scan += 2, match += 2; 1205 scan += 2, match += 2;
1206 Assert(*scan == *match, "match[2]?"); 1206 Assert(*scan == *match, "match[2]?");
1207 1207
1208 /* We check for insufficient lookahead only every 8th comparison; 1208 /* We check for insufficient lookahead only every 8th comparison;
1209 * the 256th check will be made at strstart+258. 1209 * the 256th check will be made at strstart+258.
1210 */ 1210 */
1211 do { 1211 do {
1212 } while (*++scan == *++match && *++scan == *++match && 1212 } while (*++scan == *++match && *++scan == *++match &&
1213 *++scan == *++match && *++scan == *++match && 1213 *++scan == *++match && *++scan == *++match &&
1214 *++scan == *++match && *++scan == *++match && 1214 *++scan == *++match && *++scan == *++match &&
1215 *++scan == *++match && *++scan == *++match && 1215 *++scan == *++match && *++scan == *++match &&
1216 scan < strend); 1216 scan < strend);
1217 1217
1218 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); 1218 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
1219 1219
1220 len = MAX_MATCH - (int)(strend - scan); 1220 len = MAX_MATCH - (int)(strend - scan);
1221 1221
1222 if (len < MIN_MATCH) return MIN_MATCH - 1; 1222 if (len < MIN_MATCH) return MIN_MATCH - 1;
1223 1223
1224 s->match_start = cur_match; 1224 s->match_start = cur_match;
1225 return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead; 1225 return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
1226} 1226}
1227 1227
1228#ifdef DEBUG 1228#ifdef DEBUG
1229/* =========================================================================== 1229/* ===========================================================================
1230 * Check that the match at match_start is indeed a match. 1230 * Check that the match at match_start is indeed a match.
1231 */ 1231 */
1232local void check_match(s, start, match, length) 1232local void check_match(s, start, match, length)
1233 deflate_state *s; 1233 deflate_state *s;
1234 IPos start, match; 1234 IPos start, match;
1235 int length; 1235 int length;
1236{ 1236{
1237 /* check that the match is indeed a match */ 1237 /* check that the match is indeed a match */
1238 if (zmemcmp(s->window + match, 1238 if (zmemcmp(s->window + match,
1239 s->window + start, length) != EQUAL) { 1239 s->window + start, length) != EQUAL) {
1240 fprintf(stderr, " start %u, match %u, length %d\n", 1240 fprintf(stderr, " start %u, match %u, length %d\n",
1241 start, match, length); 1241 start, match, length);
1242 do { 1242 do {
1243 fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); 1243 fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
1244 } while (--length != 0); 1244 } while (--length != 0);
1245 z_error("invalid match"); 1245 z_error("invalid match");
1246 } 1246 }
1247 if (z_verbose > 1) { 1247 if (z_verbose > 1) {
1248 fprintf(stderr,"\\[%d,%d]", start-match, length); 1248 fprintf(stderr,"\\[%d,%d]", start-match, length);
1249 do { putc(s->window[start++], stderr); } while (--length != 0); 1249 do { putc(s->window[start++], stderr); } while (--length != 0);
1250 } 1250 }
1251} 1251}
1252#else 1252#else
1253# define check_match(s, start, match, length) 1253# define check_match(s, start, match, length)
1254#endif /* DEBUG */ 1254#endif /* DEBUG */
1255 1255
1256/* =========================================================================== 1256/* ===========================================================================
1257 * Fill the window when the lookahead becomes insufficient. 1257 * Fill the window when the lookahead becomes insufficient.
1258 * Updates strstart and lookahead. 1258 * Updates strstart and lookahead.
1259 * 1259 *
1260 * IN assertion: lookahead < MIN_LOOKAHEAD 1260 * IN assertion: lookahead < MIN_LOOKAHEAD
1261 * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD 1261 * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
1262 * At least one byte has been read, or avail_in == 0; reads are 1262 * At least one byte has been read, or avail_in == 0; reads are
1263 * performed for at least two bytes (required for the zip translate_eol 1263 * performed for at least two bytes (required for the zip translate_eol
1264 * option -- not supported here). 1264 * option -- not supported here).
1265 */ 1265 */
1266local void fill_window(s) 1266local void fill_window(s)
1267 deflate_state *s; 1267 deflate_state *s;
1268{ 1268{
1269 register unsigned n, m; 1269 register unsigned n, m;
1270 register Posf *p; 1270 register Posf *p;
1271 unsigned more; /* Amount of free space at the end of the window. */ 1271 unsigned more; /* Amount of free space at the end of the window. */
1272 uInt wsize = s->w_size; 1272 uInt wsize = s->w_size;
1273 1273
1274 do { 1274 do {
1275 more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); 1275 more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
1276 1276
1277 /* Deal with !@#$% 64K limit: */ 1277 /* Deal with !@#$% 64K limit: */
1278 if (sizeof(int) <= 2) { 1278 if (sizeof(int) <= 2) {
1279 if (more == 0 && s->strstart == 0 && s->lookahead == 0) { 1279 if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
1280 more = wsize; 1280 more = wsize;
1281 1281
1282 } else if (more == (unsigned)(-1)) { 1282 } else if (more == (unsigned)(-1)) {
1283 /* Very unlikely, but possible on 16 bit machine if 1283 /* Very unlikely, but possible on 16 bit machine if
1284 * strstart == 0 && lookahead == 1 (input done a byte at time) 1284 * strstart == 0 && lookahead == 1 (input done a byte at time)
1285 */ 1285 */
1286 more--; 1286 more--;
1287 } 1287 }
1288 } 1288 }
1289 1289
1290 /* If the window is almost full and there is insufficient lookahead, 1290 /* If the window is almost full and there is insufficient lookahead,
1291 * move the upper half to the lower one to make room in the upper half. 1291 * move the upper half to the lower one to make room in the upper half.
1292 */ 1292 */
1293 if (s->strstart >= wsize+MAX_DIST(s)) { 1293 if (s->strstart >= wsize+MAX_DIST(s)) {
1294 1294
1295 zmemcpy(s->window, s->window+wsize, (unsigned)wsize); 1295 zmemcpy(s->window, s->window+wsize, (unsigned)wsize);
1296 s->match_start -= wsize; 1296 s->match_start -= wsize;
1297 s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ 1297 s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
1298 s->block_start -= (long) wsize; 1298 s->block_start -= (long) wsize;
1299 1299
1300 /* Slide the hash table (could be avoided with 32 bit values 1300 /* Slide the hash table (could be avoided with 32 bit values
1301 at the expense of memory usage). We slide even when level == 0 1301 at the expense of memory usage). We slide even when level == 0
1302 to keep the hash table consistent if we switch back to level > 0 1302 to keep the hash table consistent if we switch back to level > 0
1303 later. (Using level 0 permanently is not an optimal usage of 1303 later. (Using level 0 permanently is not an optimal usage of
1304 zlib, so we don't care about this pathological case.) 1304 zlib, so we don't care about this pathological case.)
1305 */ 1305 */
1306 /* %%% avoid this when Z_RLE */ 1306 /* %%% avoid this when Z_RLE */
1307 n = s->hash_size; 1307 n = s->hash_size;
1308 p = &s->head[n]; 1308 p = &s->head[n];
1309 do { 1309 do {
1310 m = *--p; 1310 m = *--p;
1311 *p = (Pos)(m >= wsize ? m-wsize : NIL); 1311 *p = (Pos)(m >= wsize ? m-wsize : NIL);
1312 } while (--n); 1312 } while (--n);
1313 1313
1314 n = wsize; 1314 n = wsize;
1315#ifndef FASTEST 1315#ifndef FASTEST
1316 p = &s->prev[n]; 1316 p = &s->prev[n];
1317 do { 1317 do {
1318 m = *--p; 1318 m = *--p;
1319 *p = (Pos)(m >= wsize ? m-wsize : NIL); 1319 *p = (Pos)(m >= wsize ? m-wsize : NIL);
1320 /* If n is not on any hash chain, prev[n] is garbage but 1320 /* If n is not on any hash chain, prev[n] is garbage but
1321 * its value will never be used. 1321 * its value will never be used.
1322 */ 1322 */
1323 } while (--n); 1323 } while (--n);
1324#endif 1324#endif
1325 more += wsize; 1325 more += wsize;
1326 } 1326 }
1327 if (s->strm->avail_in == 0) return; 1327 if (s->strm->avail_in == 0) return;
1328 1328
1329 /* If there was no sliding: 1329 /* If there was no sliding:
1330 * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && 1330 * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
1331 * more == window_size - lookahead - strstart 1331 * more == window_size - lookahead - strstart
1332 * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) 1332 * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
1333 * => more >= window_size - 2*WSIZE + 2 1333 * => more >= window_size - 2*WSIZE + 2
1334 * In the BIG_MEM or MMAP case (not yet supported), 1334 * In the BIG_MEM or MMAP case (not yet supported),
1335 * window_size == input_size + MIN_LOOKAHEAD && 1335 * window_size == input_size + MIN_LOOKAHEAD &&
1336 * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. 1336 * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
1337 * Otherwise, window_size == 2*WSIZE so more >= 2. 1337 * Otherwise, window_size == 2*WSIZE so more >= 2.
1338 * If there was sliding, more >= WSIZE. So in all cases, more >= 2. 1338 * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
1339 */ 1339 */
1340 Assert(more >= 2, "more < 2"); 1340 Assert(more >= 2, "more < 2");
1341 1341
1342 n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); 1342 n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
1343 s->lookahead += n; 1343 s->lookahead += n;
1344 1344
1345 /* Initialize the hash value now that we have some input: */ 1345 /* Initialize the hash value now that we have some input: */
1346 if (s->lookahead >= MIN_MATCH) { 1346 if (s->lookahead >= MIN_MATCH) {
1347 s->ins_h = s->window[s->strstart]; 1347 s->ins_h = s->window[s->strstart];
1348 UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); 1348 UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
1349#if MIN_MATCH != 3 1349#if MIN_MATCH != 3
1350 Call UPDATE_HASH() MIN_MATCH-3 more times 1350 Call UPDATE_HASH() MIN_MATCH-3 more times
1351#endif 1351#endif
1352 } 1352 }
1353 /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, 1353 /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
1354 * but this is not important since only literal bytes will be emitted. 1354 * but this is not important since only literal bytes will be emitted.
1355 */ 1355 */
1356 1356
1357 } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); 1357 } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
1358} 1358}
1359 1359
1360/* =========================================================================== 1360/* ===========================================================================
1361 * Flush the current block, with given end-of-file flag. 1361 * Flush the current block, with given end-of-file flag.
1362 * IN assertion: strstart is set to the end of the current match. 1362 * IN assertion: strstart is set to the end of the current match.
1363 */ 1363 */
1364#define FLUSH_BLOCK_ONLY(s, eof) { \ 1364#define FLUSH_BLOCK_ONLY(s, eof) { \
1365 _tr_flush_block(s, (s->block_start >= 0L ? \ 1365 _tr_flush_block(s, (s->block_start >= 0L ? \
1366 (charf *)&s->window[(unsigned)s->block_start] : \ 1366 (charf *)&s->window[(unsigned)s->block_start] : \
1367 (charf *)Z_NULL), \ 1367 (charf *)Z_NULL), \
1368 (ulg)((long)s->strstart - s->block_start), \ 1368 (ulg)((long)s->strstart - s->block_start), \
1369 (eof)); \ 1369 (eof)); \
1370 s->block_start = s->strstart; \ 1370 s->block_start = s->strstart; \
1371 flush_pending(s->strm); \ 1371 flush_pending(s->strm); \
1372 Tracev((stderr,"[FLUSH]")); \ 1372 Tracev((stderr,"[FLUSH]")); \
1373} 1373}
1374 1374
1375/* Same but force premature exit if necessary. */ 1375/* Same but force premature exit if necessary. */
1376#define FLUSH_BLOCK(s, eof) { \ 1376#define FLUSH_BLOCK(s, eof) { \
1377 FLUSH_BLOCK_ONLY(s, eof); \ 1377 FLUSH_BLOCK_ONLY(s, eof); \
1378 if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \ 1378 if (s->strm->avail_out == 0) return (eof) ? finish_started : need_more; \
1379} 1379}
1380 1380
1381/* =========================================================================== 1381/* ===========================================================================
1382 * Copy without compression as much as possible from the input stream, return 1382 * Copy without compression as much as possible from the input stream, return
1383 * the current block state. 1383 * the current block state.
1384 * This function does not insert new strings in the dictionary since 1384 * This function does not insert new strings in the dictionary since
1385 * uncompressible data is probably not useful. This function is used 1385 * uncompressible data is probably not useful. This function is used
1386 * only for the level=0 compression option. 1386 * only for the level=0 compression option.
1387 * NOTE: this function should be optimized to avoid extra copying from 1387 * NOTE: this function should be optimized to avoid extra copying from
1388 * window to pending_buf. 1388 * window to pending_buf.
1389 */ 1389 */
1390local block_state deflate_stored(s, flush) 1390local block_state deflate_stored(s, flush)
1391 deflate_state *s; 1391 deflate_state *s;
1392 int flush; 1392 int flush;
1393{ 1393{
1394 /* Stored blocks are limited to 0xffff bytes, pending_buf is limited 1394 /* Stored blocks are limited to 0xffff bytes, pending_buf is limited
1395 * to pending_buf_size, and each stored block has a 5 byte header: 1395 * to pending_buf_size, and each stored block has a 5 byte header:
1396 */ 1396 */
1397 ulg max_block_size = 0xffff; 1397 ulg max_block_size = 0xffff;
1398 ulg max_start; 1398 ulg max_start;
1399 1399
1400 if (max_block_size > s->pending_buf_size - 5) { 1400 if (max_block_size > s->pending_buf_size - 5) {
1401 max_block_size = s->pending_buf_size - 5; 1401 max_block_size = s->pending_buf_size - 5;
1402 } 1402 }
1403 1403
1404 /* Copy as much as possible from input to output: */ 1404 /* Copy as much as possible from input to output: */
1405 for (;;) { 1405 for (;;) {
1406 /* Fill the window as much as possible: */ 1406 /* Fill the window as much as possible: */
1407 if (s->lookahead <= 1) { 1407 if (s->lookahead <= 1) {
1408 1408
1409 Assert(s->strstart < s->w_size+MAX_DIST(s) || 1409 Assert(s->strstart < s->w_size+MAX_DIST(s) ||
1410 s->block_start >= (long)s->w_size, "slide too late"); 1410 s->block_start >= (long)s->w_size, "slide too late");
1411 1411
1412 fill_window(s); 1412 fill_window(s);
1413 if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; 1413 if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more;
1414 1414
1415 if (s->lookahead == 0) break; /* flush the current block */ 1415 if (s->lookahead == 0) break; /* flush the current block */
1416 } 1416 }
1417 Assert(s->block_start >= 0L, "block gone"); 1417 Assert(s->block_start >= 0L, "block gone");
1418 1418
1419 s->strstart += s->lookahead; 1419 s->strstart += s->lookahead;
1420 s->lookahead = 0; 1420 s->lookahead = 0;
1421 1421
1422 /* Emit a stored block if pending_buf will be full: */ 1422 /* Emit a stored block if pending_buf will be full: */
1423 max_start = s->block_start + max_block_size; 1423 max_start = s->block_start + max_block_size;
1424 if (s->strstart == 0 || (ulg)s->strstart >= max_start) { 1424 if (s->strstart == 0 || (ulg)s->strstart >= max_start) {
1425 /* strstart == 0 is possible when wraparound on 16-bit machine */ 1425 /* strstart == 0 is possible when wraparound on 16-bit machine */
1426 s->lookahead = (uInt)(s->strstart - max_start); 1426 s->lookahead = (uInt)(s->strstart - max_start);
1427 s->strstart = (uInt)max_start; 1427 s->strstart = (uInt)max_start;
1428 FLUSH_BLOCK(s, 0); 1428 FLUSH_BLOCK(s, 0);
1429 } 1429 }
1430 /* Flush if we may have to slide, otherwise block_start may become 1430 /* Flush if we may have to slide, otherwise block_start may become
1431 * negative and the data will be gone: 1431 * negative and the data will be gone:
1432 */ 1432 */
1433 if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { 1433 if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) {
1434 FLUSH_BLOCK(s, 0); 1434 FLUSH_BLOCK(s, 0);
1435 } 1435 }
1436 } 1436 }
1437 FLUSH_BLOCK(s, flush == Z_FINISH); 1437 FLUSH_BLOCK(s, flush == Z_FINISH);
1438 return flush == Z_FINISH ? finish_done : block_done; 1438 return flush == Z_FINISH ? finish_done : block_done;
1439} 1439}
1440 1440
1441/* =========================================================================== 1441/* ===========================================================================
1442 * Compress as much as possible from the input stream, return the current 1442 * Compress as much as possible from the input stream, return the current
1443 * block state. 1443 * block state.
1444 * This function does not perform lazy evaluation of matches and inserts 1444 * This function does not perform lazy evaluation of matches and inserts
1445 * new strings in the dictionary only for unmatched strings or for short 1445 * new strings in the dictionary only for unmatched strings or for short
1446 * matches. It is used only for the fast compression options. 1446 * matches. It is used only for the fast compression options.
1447 */ 1447 */
1448local block_state deflate_fast(s, flush) 1448local block_state deflate_fast(s, flush)
1449 deflate_state *s; 1449 deflate_state *s;
1450 int flush; 1450 int flush;
1451{ 1451{
1452 IPos hash_head = NIL; /* head of the hash chain */ 1452 IPos hash_head = NIL; /* head of the hash chain */
1453 int bflush; /* set if current block must be flushed */ 1453 int bflush; /* set if current block must be flushed */
1454 1454
1455 for (;;) { 1455 for (;;) {
1456 /* Make sure that we always have enough lookahead, except 1456 /* Make sure that we always have enough lookahead, except
1457 * at the end of the input file. We need MAX_MATCH bytes 1457 * at the end of the input file. We need MAX_MATCH bytes
1458 * for the next match, plus MIN_MATCH bytes to insert the 1458 * for the next match, plus MIN_MATCH bytes to insert the
1459 * string following the next match. 1459 * string following the next match.
1460 */ 1460 */
1461 if (s->lookahead < MIN_LOOKAHEAD) { 1461 if (s->lookahead < MIN_LOOKAHEAD) {
1462 fill_window(s); 1462 fill_window(s);
1463 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { 1463 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
1464 return need_more; 1464 return need_more;
1465 } 1465 }
1466 if (s->lookahead == 0) break; /* flush the current block */ 1466 if (s->lookahead == 0) break; /* flush the current block */
1467 } 1467 }
1468 1468
1469 /* Insert the string window[strstart .. strstart+2] in the 1469 /* Insert the string window[strstart .. strstart+2] in the
1470 * dictionary, and set hash_head to the head of the hash chain: 1470 * dictionary, and set hash_head to the head of the hash chain:
1471 */ 1471 */
1472 if (s->lookahead >= MIN_MATCH) { 1472 if (s->lookahead >= MIN_MATCH) {
1473 INSERT_STRING(s, s->strstart, hash_head); 1473 INSERT_STRING(s, s->strstart, hash_head);
1474 } 1474 }
1475 1475
1476 /* Find the longest match, discarding those <= prev_length. 1476 /* Find the longest match, discarding those <= prev_length.
1477 * At this point we have always match_length < MIN_MATCH 1477 * At this point we have always match_length < MIN_MATCH
1478 */ 1478 */
1479 if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { 1479 if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
1480 /* To simplify the code, we prevent matches with the string 1480 /* To simplify the code, we prevent matches with the string
1481 * of window index 0 (in particular we have to avoid a match 1481 * of window index 0 (in particular we have to avoid a match
1482 * of the string with itself at the start of the input file). 1482 * of the string with itself at the start of the input file).
1483 */ 1483 */
1484#ifdef FASTEST 1484#ifdef FASTEST
1485 if ((s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) || 1485 if ((s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) ||
1486 (s->strategy == Z_RLE && s->strstart - hash_head == 1)) { 1486 (s->strategy == Z_RLE && s->strstart - hash_head == 1)) {
1487 s->match_length = longest_match_fast (s, hash_head); 1487 s->match_length = longest_match_fast (s, hash_head);
1488 } 1488 }
1489#else 1489#else
1490 if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) { 1490 if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {
1491 s->match_length = longest_match (s, hash_head); 1491 s->match_length = longest_match (s, hash_head);
1492 } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) { 1492 } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {
1493 s->match_length = longest_match_fast (s, hash_head); 1493 s->match_length = longest_match_fast (s, hash_head);
1494 } 1494 }
1495#endif 1495#endif
1496 /* longest_match() or longest_match_fast() sets match_start */ 1496 /* longest_match() or longest_match_fast() sets match_start */
1497 } 1497 }
1498 if (s->match_length >= MIN_MATCH) { 1498 if (s->match_length >= MIN_MATCH) {
1499 check_match(s, s->strstart, s->match_start, s->match_length); 1499 check_match(s, s->strstart, s->match_start, s->match_length);
1500 1500
1501 _tr_tally_dist(s, s->strstart - s->match_start, 1501 _tr_tally_dist(s, s->strstart - s->match_start,
1502 s->match_length - MIN_MATCH, bflush); 1502 s->match_length - MIN_MATCH, bflush);
1503 1503
1504 s->lookahead -= s->match_length; 1504 s->lookahead -= s->match_length;
1505 1505
1506 /* Insert new strings in the hash table only if the match length 1506 /* Insert new strings in the hash table only if the match length
1507 * is not too large. This saves time but degrades compression. 1507 * is not too large. This saves time but degrades compression.
1508 */ 1508 */
1509#ifndef FASTEST 1509#ifndef FASTEST
1510 if (s->match_length <= s->max_insert_length && 1510 if (s->match_length <= s->max_insert_length &&
1511 s->lookahead >= MIN_MATCH) { 1511 s->lookahead >= MIN_MATCH) {
1512 s->match_length--; /* string at strstart already in table */ 1512 s->match_length--; /* string at strstart already in table */
1513 do { 1513 do {
1514 s->strstart++; 1514 s->strstart++;
1515 INSERT_STRING(s, s->strstart, hash_head); 1515 INSERT_STRING(s, s->strstart, hash_head);
1516 /* strstart never exceeds WSIZE-MAX_MATCH, so there are 1516 /* strstart never exceeds WSIZE-MAX_MATCH, so there are
1517 * always MIN_MATCH bytes ahead. 1517 * always MIN_MATCH bytes ahead.
1518 */ 1518 */
1519 } while (--s->match_length != 0); 1519 } while (--s->match_length != 0);
1520 s->strstart++; 1520 s->strstart++;
1521 } else 1521 } else
1522#endif 1522#endif
1523 { 1523 {
1524 s->strstart += s->match_length; 1524 s->strstart += s->match_length;
1525 s->match_length = 0; 1525 s->match_length = 0;
1526 s->ins_h = s->window[s->strstart]; 1526 s->ins_h = s->window[s->strstart];
1527 UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); 1527 UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
1528#if MIN_MATCH != 3 1528#if MIN_MATCH != 3
1529 Call UPDATE_HASH() MIN_MATCH-3 more times 1529 Call UPDATE_HASH() MIN_MATCH-3 more times
1530#endif 1530#endif
1531 /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not 1531 /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
1532 * matter since it will be recomputed at next deflate call. 1532 * matter since it will be recomputed at next deflate call.
1533 */ 1533 */
1534 } 1534 }
1535 } else { 1535 } else {
1536 /* No match, output a literal byte */ 1536 /* No match, output a literal byte */
1537 Tracevv((stderr,"%c", s->window[s->strstart])); 1537 Tracevv((stderr,"%c", s->window[s->strstart]));
1538 _tr_tally_lit (s, s->window[s->strstart], bflush); 1538 _tr_tally_lit (s, s->window[s->strstart], bflush);
1539 s->lookahead--; 1539 s->lookahead--;
1540 s->strstart++; 1540 s->strstart++;
1541 } 1541 }
1542 if (bflush) FLUSH_BLOCK(s, 0); 1542 if (bflush) FLUSH_BLOCK(s, 0);
1543 } 1543 }
1544 FLUSH_BLOCK(s, flush == Z_FINISH); 1544 FLUSH_BLOCK(s, flush == Z_FINISH);
1545 return flush == Z_FINISH ? finish_done : block_done; 1545 return flush == Z_FINISH ? finish_done : block_done;
1546} 1546}
1547 1547
1548#ifndef FASTEST 1548#ifndef FASTEST
1549/* =========================================================================== 1549/* ===========================================================================
1550 * Same as above, but achieves better compression. We use a lazy 1550 * Same as above, but achieves better compression. We use a lazy
1551 * evaluation for matches: a match is finally adopted only if there is 1551 * evaluation for matches: a match is finally adopted only if there is
1552 * no better match at the next window position. 1552 * no better match at the next window position.
1553 */ 1553 */
1554local block_state deflate_slow(s, flush) 1554local block_state deflate_slow(s, flush)
1555 deflate_state *s; 1555 deflate_state *s;
1556 int flush; 1556 int flush;
1557{ 1557{
1558 IPos hash_head = NIL; /* head of hash chain */ 1558 IPos hash_head = NIL; /* head of hash chain */
1559 int bflush; /* set if current block must be flushed */ 1559 int bflush; /* set if current block must be flushed */
1560 1560
1561 /* Process the input block. */ 1561 /* Process the input block. */
1562 for (;;) { 1562 for (;;) {
1563 /* Make sure that we always have enough lookahead, except 1563 /* Make sure that we always have enough lookahead, except
1564 * at the end of the input file. We need MAX_MATCH bytes 1564 * at the end of the input file. We need MAX_MATCH bytes
1565 * for the next match, plus MIN_MATCH bytes to insert the 1565 * for the next match, plus MIN_MATCH bytes to insert the
1566 * string following the next match. 1566 * string following the next match.
1567 */ 1567 */
1568 if (s->lookahead < MIN_LOOKAHEAD) { 1568 if (s->lookahead < MIN_LOOKAHEAD) {
1569 fill_window(s); 1569 fill_window(s);
1570 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { 1570 if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
1571 return need_more; 1571 return need_more;
1572 } 1572 }
1573 if (s->lookahead == 0) break; /* flush the current block */ 1573 if (s->lookahead == 0) break; /* flush the current block */
1574 } 1574 }
1575 1575
1576 /* Insert the string window[strstart .. strstart+2] in the 1576 /* Insert the string window[strstart .. strstart+2] in the
1577 * dictionary, and set hash_head to the head of the hash chain: 1577 * dictionary, and set hash_head to the head of the hash chain:
1578 */ 1578 */
1579 if (s->lookahead >= MIN_MATCH) { 1579 if (s->lookahead >= MIN_MATCH) {
1580 INSERT_STRING(s, s->strstart, hash_head); 1580 INSERT_STRING(s, s->strstart, hash_head);
1581 } 1581 }
1582 1582
1583 /* Find the longest match, discarding those <= prev_length. 1583 /* Find the longest match, discarding those <= prev_length.
1584 */ 1584 */
1585 s->prev_length = s->match_length, s->prev_match = s->match_start; 1585 s->prev_length = s->match_length, s->prev_match = s->match_start;
1586 s->match_length = MIN_MATCH-1; 1586 s->match_length = MIN_MATCH-1;
1587 1587
1588 if (hash_head != NIL && s->prev_length < s->max_lazy_match && 1588 if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
1589 s->strstart - hash_head <= MAX_DIST(s)) { 1589 s->strstart - hash_head <= MAX_DIST(s)) {
1590 /* To simplify the code, we prevent matches with the string 1590 /* To simplify the code, we prevent matches with the string
1591 * of window index 0 (in particular we have to avoid a match 1591 * of window index 0 (in particular we have to avoid a match
1592 * of the string with itself at the start of the input file). 1592 * of the string with itself at the start of the input file).
1593 */ 1593 */
1594 if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) { 1594 if (s->strategy != Z_HUFFMAN_ONLY && s->strategy != Z_RLE) {
1595 s->match_length = longest_match (s, hash_head); 1595 s->match_length = longest_match (s, hash_head);
1596 } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) { 1596 } else if (s->strategy == Z_RLE && s->strstart - hash_head == 1) {
1597 s->match_length = longest_match_fast (s, hash_head); 1597 s->match_length = longest_match_fast (s, hash_head);
1598 } 1598 }
1599 /* longest_match() or longest_match_fast() sets match_start */ 1599 /* longest_match() or longest_match_fast() sets match_start */
1600 1600
1601 if (s->match_length <= 5 && (s->strategy == Z_FILTERED 1601 if (s->match_length <= 5 && (s->strategy == Z_FILTERED
1602#if TOO_FAR <= 32767 1602#if TOO_FAR <= 32767
1603 || (s->match_length == MIN_MATCH && 1603 || (s->match_length == MIN_MATCH &&
1604 s->strstart - s->match_start > TOO_FAR) 1604 s->strstart - s->match_start > TOO_FAR)
1605#endif 1605#endif
1606 )) { 1606 )) {
1607 1607
1608 /* If prev_match is also MIN_MATCH, match_start is garbage 1608 /* If prev_match is also MIN_MATCH, match_start is garbage
1609 * but we will ignore the current match anyway. 1609 * but we will ignore the current match anyway.
1610 */ 1610 */
1611 s->match_length = MIN_MATCH-1; 1611 s->match_length = MIN_MATCH-1;
1612 } 1612 }
1613 } 1613 }
1614 /* If there was a match at the previous step and the current 1614 /* If there was a match at the previous step and the current
1615 * match is not better, output the previous match: 1615 * match is not better, output the previous match:
1616 */ 1616 */
1617 if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { 1617 if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
1618 uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; 1618 uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
1619 /* Do not insert strings in hash table beyond this. */ 1619 /* Do not insert strings in hash table beyond this. */
1620 1620
1621 check_match(s, s->strstart-1, s->prev_match, s->prev_length); 1621 check_match(s, s->strstart-1, s->prev_match, s->prev_length);
1622 1622
1623 _tr_tally_dist(s, s->strstart -1 - s->prev_match, 1623 _tr_tally_dist(s, s->strstart -1 - s->prev_match,
1624 s->prev_length - MIN_MATCH, bflush); 1624 s->prev_length - MIN_MATCH, bflush);
1625 1625
1626 /* Insert in hash table all strings up to the end of the match. 1626 /* Insert in hash table all strings up to the end of the match.
1627 * strstart-1 and strstart are already inserted. If there is not 1627 * strstart-1 and strstart are already inserted. If there is not
1628 * enough lookahead, the last two strings are not inserted in 1628 * enough lookahead, the last two strings are not inserted in
1629 * the hash table. 1629 * the hash table.
1630 */ 1630 */
1631 s->lookahead -= s->prev_length-1; 1631 s->lookahead -= s->prev_length-1;
1632 s->prev_length -= 2; 1632 s->prev_length -= 2;
1633 do { 1633 do {
1634 if (++s->strstart <= max_insert) { 1634 if (++s->strstart <= max_insert) {
1635 INSERT_STRING(s, s->strstart, hash_head); 1635 INSERT_STRING(s, s->strstart, hash_head);
1636 } 1636 }
1637 } while (--s->prev_length != 0); 1637 } while (--s->prev_length != 0);
1638 s->match_available = 0; 1638 s->match_available = 0;
1639 s->match_length = MIN_MATCH-1; 1639 s->match_length = MIN_MATCH-1;
1640 s->strstart++; 1640 s->strstart++;
1641 1641
1642 if (bflush) FLUSH_BLOCK(s, 0); 1642 if (bflush) FLUSH_BLOCK(s, 0);
1643 1643
1644 } else if (s->match_available) { 1644 } else if (s->match_available) {
1645 /* If there was no match at the previous position, output a 1645 /* If there was no match at the previous position, output a
1646 * single literal. If there was a match but the current match 1646 * single literal. If there was a match but the current match
1647 * is longer, truncate the previous match to a single literal. 1647 * is longer, truncate the previous match to a single literal.
1648 */ 1648 */
1649 Tracevv((stderr,"%c", s->window[s->strstart-1])); 1649 Tracevv((stderr,"%c", s->window[s->strstart-1]));
1650 _tr_tally_lit(s, s->window[s->strstart-1], bflush); 1650 _tr_tally_lit(s, s->window[s->strstart-1], bflush);
1651 if (bflush) { 1651 if (bflush) {
1652 FLUSH_BLOCK_ONLY(s, 0); 1652 FLUSH_BLOCK_ONLY(s, 0);
1653 } 1653 }
1654 s->strstart++; 1654 s->strstart++;
1655 s->lookahead--; 1655 s->lookahead--;
1656 if (s->strm->avail_out == 0) return need_more; 1656 if (s->strm->avail_out == 0) return need_more;
1657 } else { 1657 } else {
1658 /* There is no previous match to compare with, wait for 1658 /* There is no previous match to compare with, wait for
1659 * the next step to decide. 1659 * the next step to decide.
1660 */ 1660 */
1661 s->match_available = 1; 1661 s->match_available = 1;
1662 s->strstart++; 1662 s->strstart++;
1663 s->lookahead--; 1663 s->lookahead--;
1664 } 1664 }
1665 } 1665 }
1666 Assert (flush != Z_NO_FLUSH, "no flush?"); 1666 Assert (flush != Z_NO_FLUSH, "no flush?");
1667 if (s->match_available) { 1667 if (s->match_available) {
1668 Tracevv((stderr,"%c", s->window[s->strstart-1])); 1668 Tracevv((stderr,"%c", s->window[s->strstart-1]));
1669 _tr_tally_lit(s, s->window[s->strstart-1], bflush); 1669 _tr_tally_lit(s, s->window[s->strstart-1], bflush);
1670 s->match_available = 0; 1670 s->match_available = 0;
1671 } 1671 }
1672 FLUSH_BLOCK(s, flush == Z_FINISH); 1672 FLUSH_BLOCK(s, flush == Z_FINISH);
1673 return flush == Z_FINISH ? finish_done : block_done; 1673 return flush == Z_FINISH ? finish_done : block_done;
1674} 1674}
1675#endif /* FASTEST */ 1675#endif /* FASTEST */
1676 1676
1677#if 0 1677#if 0
1678/* =========================================================================== 1678/* ===========================================================================
1679 * For Z_RLE, simply look for runs of bytes, generate matches only of distance 1679 * For Z_RLE, simply look for runs of bytes, generate matches only of distance
1680 * one. Do not maintain a hash table. (It will be regenerated if this run of 1680 * one. Do not maintain a hash table. (It will be regenerated if this run of
1681 * deflate switches away from Z_RLE.) 1681 * deflate switches away from Z_RLE.)
1682 */ 1682 */
1683local block_state deflate_rle(s, flush) 1683local block_state deflate_rle(s, flush)
1684 deflate_state *s; 1684 deflate_state *s;
1685 int flush; 1685 int flush;
1686{ 1686{
1687 int bflush; /* set if current block must be flushed */ 1687 int bflush; /* set if current block must be flushed */
1688 uInt run; /* length of run */ 1688 uInt run; /* length of run */
1689 uInt max; /* maximum length of run */ 1689 uInt max; /* maximum length of run */
1690 uInt prev; /* byte at distance one to match */ 1690 uInt prev; /* byte at distance one to match */
1691 Bytef *scan; /* scan for end of run */ 1691 Bytef *scan; /* scan for end of run */
1692 1692
1693 for (;;) { 1693 for (;;) {
1694 /* Make sure that we always have enough lookahead, except 1694 /* Make sure that we always have enough lookahead, except
1695 * at the end of the input file. We need MAX_MATCH bytes 1695 * at the end of the input file. We need MAX_MATCH bytes
1696 * for the longest encodable run. 1696 * for the longest encodable run.
1697 */ 1697 */
1698 if (s->lookahead < MAX_MATCH) { 1698 if (s->lookahead < MAX_MATCH) {
1699 fill_window(s); 1699 fill_window(s);
1700 if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) { 1700 if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
1701 return need_more; 1701 return need_more;
1702 } 1702 }
1703 if (s->lookahead == 0) break; /* flush the current block */ 1703 if (s->lookahead == 0) break; /* flush the current block */
1704 } 1704 }
1705 1705
1706 /* See how many times the previous byte repeats */ 1706 /* See how many times the previous byte repeats */
1707 run = 0; 1707 run = 0;
1708 if (s->strstart > 0) { /* if there is a previous byte, that is */ 1708 if (s->strstart > 0) { /* if there is a previous byte, that is */
1709 max = s->lookahead < MAX_MATCH ? s->lookahead : MAX_MATCH; 1709 max = s->lookahead < MAX_MATCH ? s->lookahead : MAX_MATCH;
1710 scan = s->window + s->strstart - 1; 1710 scan = s->window + s->strstart - 1;
1711 prev = *scan++; 1711 prev = *scan++;
1712 do { 1712 do {
1713 if (*scan++ != prev) 1713 if (*scan++ != prev)
1714 break; 1714 break;
1715 } while (++run < max); 1715 } while (++run < max);
1716 } 1716 }
1717 1717
1718 /* Emit match if have run of MIN_MATCH or longer, else emit literal */ 1718 /* Emit match if have run of MIN_MATCH or longer, else emit literal */
1719 if (run >= MIN_MATCH) { 1719 if (run >= MIN_MATCH) {
1720 check_match(s, s->strstart, s->strstart - 1, run); 1720 check_match(s, s->strstart, s->strstart - 1, run);
1721 _tr_tally_dist(s, 1, run - MIN_MATCH, bflush); 1721 _tr_tally_dist(s, 1, run - MIN_MATCH, bflush);
1722 s->lookahead -= run; 1722 s->lookahead -= run;
1723 s->strstart += run; 1723 s->strstart += run;
1724 } else { 1724 } else {
1725 /* No match, output a literal byte */ 1725 /* No match, output a literal byte */
1726 Tracevv((stderr,"%c", s->window[s->strstart])); 1726 Tracevv((stderr,"%c", s->window[s->strstart]));
1727 _tr_tally_lit (s, s->window[s->strstart], bflush); 1727 _tr_tally_lit (s, s->window[s->strstart], bflush);
1728 s->lookahead--; 1728 s->lookahead--;
1729 s->strstart++; 1729 s->strstart++;
1730 } 1730 }
1731 if (bflush) FLUSH_BLOCK(s, 0); 1731 if (bflush) FLUSH_BLOCK(s, 0);
1732 } 1732 }
1733 FLUSH_BLOCK(s, flush == Z_FINISH); 1733 FLUSH_BLOCK(s, flush == Z_FINISH);
1734 return flush == Z_FINISH ? finish_done : block_done; 1734 return flush == Z_FINISH ? finish_done : block_done;
1735} 1735}
1736#endif 1736#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-22 08:49:28 +0000