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