| Geant4 Cross Reference |
1 /* deflate.h -- internal compression state 1 /* deflate.h -- internal compression state
2 * Copyright (C) 1995-2018 Jean-loup Gailly << 2 * Copyright (C) 1995-2016 Jean-loup Gailly
3 * For conditions of distribution and use, see 3 * For conditions of distribution and use, see copyright notice in zlib.h
4 */ 4 */
5 5
6 /* WARNING: this file should *not* be used by 6 /* WARNING: this file should *not* be used by applications. It is
7 part of the implementation of the compressi 7 part of the implementation of the compression library and is
8 subject to change. Applications should only 8 subject to change. Applications should only use zlib.h.
9 */ 9 */
10 10
11 /* @(#) $Id$ */ <<
12 11
13 #ifndef DEFLATE_H 12 #ifndef DEFLATE_H
14 #define DEFLATE_H 13 #define DEFLATE_H
15 14
16 #include "zutil.h" 15 #include "zutil.h"
17 16
18 /* define NO_GZIP when compiling if you want t 17 /* define NO_GZIP when compiling if you want to disable gzip header and
19 trailer creation by deflate(). NO_GZIP wou 18 trailer creation by deflate(). NO_GZIP would be used to avoid linking in
20 the crc code when it is not needed. For sh 19 the crc code when it is not needed. For shared libraries, gzip encoding
21 should be left enabled. */ 20 should be left enabled. */
22 #ifndef NO_GZIP 21 #ifndef NO_GZIP
23 # define GZIP 22 # define GZIP
24 #endif 23 #endif
25 24
26 /* =========================================== 25 /* ===========================================================================
27 * Internal compression state. 26 * Internal compression state.
28 */ 27 */
29 28
30 #define LENGTH_CODES 29 29 #define LENGTH_CODES 29
31 /* number of length codes, not counting the sp 30 /* number of length codes, not counting the special END_BLOCK code */
32 31
33 #define LITERALS 256 32 #define LITERALS 256
34 /* number of literal bytes 0..255 */ 33 /* number of literal bytes 0..255 */
35 34
36 #define L_CODES (LITERALS+1+LENGTH_CODES) 35 #define L_CODES (LITERALS+1+LENGTH_CODES)
37 /* number of Literal or Length codes, includin 36 /* number of Literal or Length codes, including the END_BLOCK code */
38 37
39 #define D_CODES 30 38 #define D_CODES 30
40 /* number of distance codes */ 39 /* number of distance codes */
41 40
42 #define BL_CODES 19 41 #define BL_CODES 19
43 /* number of codes used to transfer the bit le 42 /* number of codes used to transfer the bit lengths */
44 43
45 #define HEAP_SIZE (2*L_CODES+1) 44 #define HEAP_SIZE (2*L_CODES+1)
46 /* maximum heap size */ 45 /* maximum heap size */
47 46
48 #define MAX_BITS 15 47 #define MAX_BITS 15
49 /* All codes must not exceed MAX_BITS bits */ 48 /* All codes must not exceed MAX_BITS bits */
50 49
51 #define Buf_size 16 50 #define Buf_size 16
52 /* size of bit buffer in bi_buf */ 51 /* size of bit buffer in bi_buf */
53 52
54 #define INIT_STATE 42 /* zlib header -> 53 #define INIT_STATE 42 /* zlib header -> BUSY_STATE */
55 #ifdef GZIP 54 #ifdef GZIP
56 # define GZIP_STATE 57 /* gzip header -> 55 # define GZIP_STATE 57 /* gzip header -> BUSY_STATE | EXTRA_STATE */
57 #endif 56 #endif
58 #define EXTRA_STATE 69 /* gzip extra bloc 57 #define EXTRA_STATE 69 /* gzip extra block -> NAME_STATE */
59 #define NAME_STATE 73 /* gzip file name 58 #define NAME_STATE 73 /* gzip file name -> COMMENT_STATE */
60 #define COMMENT_STATE 91 /* gzip comment -> 59 #define COMMENT_STATE 91 /* gzip comment -> HCRC_STATE */
61 #define HCRC_STATE 103 /* gzip header CRC 60 #define HCRC_STATE 103 /* gzip header CRC -> BUSY_STATE */
62 #define BUSY_STATE 113 /* deflate -> FINI 61 #define BUSY_STATE 113 /* deflate -> FINISH_STATE */
63 #define FINISH_STATE 666 /* stream complete 62 #define FINISH_STATE 666 /* stream complete */
64 /* Stream status */ 63 /* Stream status */
65 64
66 65
67 /* Data structure describing a single value an 66 /* Data structure describing a single value and its code string. */
68 typedef struct ct_data_s { 67 typedef struct ct_data_s {
69 union { 68 union {
70 ush freq; /* frequency count */ 69 ush freq; /* frequency count */
71 ush code; /* bit string */ 70 ush code; /* bit string */
72 } fc; 71 } fc;
73 union { 72 union {
74 ush dad; /* father node in Huf 73 ush dad; /* father node in Huffman tree */
75 ush len; /* length of bit stri 74 ush len; /* length of bit string */
76 } dl; 75 } dl;
77 } FAR ct_data; 76 } FAR ct_data;
78 77
79 #define Freq fc.freq 78 #define Freq fc.freq
80 #define Code fc.code 79 #define Code fc.code
81 #define Dad dl.dad 80 #define Dad dl.dad
82 #define Len dl.len 81 #define Len dl.len
83 82
84 typedef struct static_tree_desc_s static_tree 83 typedef struct static_tree_desc_s static_tree_desc;
85 84
86 typedef struct tree_desc_s { 85 typedef struct tree_desc_s {
87 ct_data *dyn_tree; /* the dynami 86 ct_data *dyn_tree; /* the dynamic tree */
88 int max_code; /* largest co 87 int max_code; /* largest code with non zero frequency */
89 const static_tree_desc *stat_desc; /* the 88 const static_tree_desc *stat_desc; /* the corresponding static tree */
90 } FAR tree_desc; 89 } FAR tree_desc;
91 90
92 typedef ush Pos; 91 typedef ush Pos;
93 typedef Pos FAR Posf; 92 typedef Pos FAR Posf;
94 typedef unsigned IPos; 93 typedef unsigned IPos;
95 94
96 /* A Pos is an index in the character window. 95 /* A Pos is an index in the character window. We use short instead of int to
97 * save space in the various tables. IPos is u 96 * save space in the various tables. IPos is used only for parameter passing.
98 */ 97 */
99 98
100 typedef struct internal_state { 99 typedef struct internal_state {
101 z_streamp strm; /* pointer back to th 100 z_streamp strm; /* pointer back to this zlib stream */
102 int status; /* as the name implie 101 int status; /* as the name implies */
103 Bytef *pending_buf; /* output still pendi 102 Bytef *pending_buf; /* output still pending */
104 ulg pending_buf_size; /* size of pending 103 ulg pending_buf_size; /* size of pending_buf */
105 Bytef *pending_out; /* next pending byte 104 Bytef *pending_out; /* next pending byte to output to the stream */
106 ulg pending; /* nb of bytes in the 105 ulg pending; /* nb of bytes in the pending buffer */
107 int wrap; /* bit 0 true for zli 106 int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
108 gz_headerp gzhead; /* gzip header inform 107 gz_headerp gzhead; /* gzip header information to write */
109 ulg gzindex; /* where in extra, na 108 ulg gzindex; /* where in extra, name, or comment */
110 Byte method; /* can only be DEFLAT 109 Byte method; /* can only be DEFLATED */
111 int last_flush; /* value of flush par 110 int last_flush; /* value of flush param for previous deflate call */
112 111
113 /* used by deflate.c: */ 112 /* used by deflate.c: */
114 113
115 uInt w_size; /* LZ77 window size ( 114 uInt w_size; /* LZ77 window size (32K by default) */
116 uInt w_bits; /* log2(w_size) (8.. 115 uInt w_bits; /* log2(w_size) (8..16) */
117 uInt w_mask; /* w_size - 1 */ 116 uInt w_mask; /* w_size - 1 */
118 117
119 Bytef *window; 118 Bytef *window;
120 /* Sliding window. Input bytes are read in 119 /* Sliding window. Input bytes are read into the second half of the window,
121 * and move to the first half later to kee 120 * and move to the first half later to keep a dictionary of at least wSize
122 * bytes. With this organization, matches 121 * bytes. With this organization, matches are limited to a distance of
123 * wSize-MAX_MATCH bytes, but this ensures 122 * wSize-MAX_MATCH bytes, but this ensures that IO is always
124 * performed with a length multiple of the 123 * performed with a length multiple of the block size. Also, it limits
125 * the window size to 64K, which is quite 124 * the window size to 64K, which is quite useful on MSDOS.
126 * To do: use the user input buffer as sli 125 * To do: use the user input buffer as sliding window.
127 */ 126 */
128 127
129 ulg window_size; 128 ulg window_size;
130 /* Actual size of window: 2*wSize, except 129 /* Actual size of window: 2*wSize, except when the user input buffer
131 * is directly used as sliding window. 130 * is directly used as sliding window.
132 */ 131 */
133 132
134 Posf *prev; 133 Posf *prev;
135 /* Link to older string with same hash ind 134 /* Link to older string with same hash index. To limit the size of this
136 * array to 64K, this link is maintained o 135 * array to 64K, this link is maintained only for the last 32K strings.
137 * An index in this array is thus a window 136 * An index in this array is thus a window index modulo 32K.
138 */ 137 */
139 138
140 Posf *head; /* Heads of the hash chains or 139 Posf *head; /* Heads of the hash chains or NIL. */
141 140
142 uInt ins_h; /* hash index of str 141 uInt ins_h; /* hash index of string to be inserted */
143 uInt hash_size; /* number of element 142 uInt hash_size; /* number of elements in hash table */
144 uInt hash_bits; /* log2(hash_size) * 143 uInt hash_bits; /* log2(hash_size) */
145 uInt hash_mask; /* hash_size-1 */ 144 uInt hash_mask; /* hash_size-1 */
146 145
147 uInt hash_shift; 146 uInt hash_shift;
148 /* Number of bits by which ins_h must be s 147 /* Number of bits by which ins_h must be shifted at each input
149 * step. It must be such that after MIN_MA 148 * step. It must be such that after MIN_MATCH steps, the oldest
150 * byte no longer takes part in the hash k 149 * byte no longer takes part in the hash key, that is:
151 * hash_shift * MIN_MATCH >= hash_bits 150 * hash_shift * MIN_MATCH >= hash_bits
152 */ 151 */
153 152
154 long block_start; 153 long block_start;
155 /* Window position at the beginning of the 154 /* Window position at the beginning of the current output block. Gets
156 * negative when the window is moved backw 155 * negative when the window is moved backwards.
157 */ 156 */
158 157
159 uInt match_length; /* length of 158 uInt match_length; /* length of best match */
160 IPos prev_match; /* previous m 159 IPos prev_match; /* previous match */
161 int match_available; /* set if pre 160 int match_available; /* set if previous match exists */
162 uInt strstart; /* start of s 161 uInt strstart; /* start of string to insert */
163 uInt match_start; /* start of m 162 uInt match_start; /* start of matching string */
164 uInt lookahead; /* number of 163 uInt lookahead; /* number of valid bytes ahead in window */
165 164
166 uInt prev_length; 165 uInt prev_length;
167 /* Length of the best match at previous st 166 /* Length of the best match at previous step. Matches not greater than this
168 * are discarded. This is used in the lazy 167 * are discarded. This is used in the lazy match evaluation.
169 */ 168 */
170 169
171 uInt max_chain_length; 170 uInt max_chain_length;
172 /* To speed up deflation, hash chains are 171 /* To speed up deflation, hash chains are never searched beyond this
173 * length. A higher limit improves compre 172 * length. A higher limit improves compression ratio but degrades the
174 * speed. 173 * speed.
175 */ 174 */
176 175
177 uInt max_lazy_match; 176 uInt max_lazy_match;
178 /* Attempt to find a better match only whe 177 /* Attempt to find a better match only when the current match is strictly
179 * smaller than this value. This mechanism 178 * smaller than this value. This mechanism is used only for compression
180 * levels >= 4. 179 * levels >= 4.
181 */ 180 */
182 # define max_insert_length max_lazy_match 181 # define max_insert_length max_lazy_match
183 /* Insert new strings in the hash table on 182 /* Insert new strings in the hash table only if the match length is not
184 * greater than this length. This saves ti 183 * greater than this length. This saves time but degrades compression.
185 * max_insert_length is used only for comp 184 * max_insert_length is used only for compression levels <= 3.
186 */ 185 */
187 186
188 int level; /* compression level (1..9) 187 int level; /* compression level (1..9) */
189 int strategy; /* favor or force Huffman co 188 int strategy; /* favor or force Huffman coding*/
190 189
191 uInt good_match; 190 uInt good_match;
192 /* Use a faster search when the previous m 191 /* Use a faster search when the previous match is longer than this */
193 192
194 int nice_match; /* Stop searching when cur 193 int nice_match; /* Stop searching when current match exceeds this */
195 194
196 /* used by trees.c: */ 195 /* used by trees.c: */
197 /* Didn't use ct_data typedef below to sup 196 /* Didn't use ct_data typedef below to suppress compiler warning */
198 struct ct_data_s dyn_ltree[HEAP_SIZE]; / 197 struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
199 struct ct_data_s dyn_dtree[2*D_CODES+1]; / 198 struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
200 struct ct_data_s bl_tree[2*BL_CODES+1]; / 199 struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */
201 200
202 struct tree_desc_s l_desc; / 201 struct tree_desc_s l_desc; /* desc. for literal tree */
203 struct tree_desc_s d_desc; / 202 struct tree_desc_s d_desc; /* desc. for distance tree */
204 struct tree_desc_s bl_desc; / 203 struct tree_desc_s bl_desc; /* desc. for bit length tree */
205 204
206 ush bl_count[MAX_BITS+1]; 205 ush bl_count[MAX_BITS+1];
207 /* number of codes at each bit length for 206 /* number of codes at each bit length for an optimal tree */
208 207
209 int heap[2*L_CODES+1]; /* heap used t 208 int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
210 int heap_len; /* number of e 209 int heap_len; /* number of elements in the heap */
211 int heap_max; /* element of 210 int heap_max; /* element of largest frequency */
212 /* The sons of heap[n] are heap[2*n] and h 211 /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
213 * The same heap array is used to build al 212 * The same heap array is used to build all trees.
214 */ 213 */
215 214
216 uch depth[2*L_CODES+1]; 215 uch depth[2*L_CODES+1];
217 /* Depth of each subtree used as tie break 216 /* Depth of each subtree used as tie breaker for trees of equal frequency
218 */ 217 */
219 218
220 uchf *sym_buf; /* buffer for distan << 219 uchf *l_buf; /* buffer for literals or lengths */
221 220
222 uInt lit_bufsize; 221 uInt lit_bufsize;
223 /* Size of match buffer for literals/lengt 222 /* Size of match buffer for literals/lengths. There are 4 reasons for
224 * limiting lit_bufsize to 64K: 223 * limiting lit_bufsize to 64K:
225 * - frequencies can be kept in 16 bit c 224 * - frequencies can be kept in 16 bit counters
226 * - if compression is not successful fo 225 * - if compression is not successful for the first block, all input
227 * data is still in the window so we c 226 * data is still in the window so we can still emit a stored block even
228 * when input comes from standard inpu 227 * when input comes from standard input. (This can also be done for
229 * all blocks if lit_bufsize is not gr 228 * all blocks if lit_bufsize is not greater than 32K.)
230 * - if compression is not successful fo 229 * - if compression is not successful for a file smaller than 64K, we can
231 * even emit a stored file instead of 230 * even emit a stored file instead of a stored block (saving 5 bytes).
232 * This is applicable only for zip (no 231 * This is applicable only for zip (not gzip or zlib).
233 * - creating new Huffman trees less fre 232 * - creating new Huffman trees less frequently may not provide fast
234 * adaptation to changes in the input 233 * adaptation to changes in the input data statistics. (Take for
235 * example a binary file with poorly c 234 * example a binary file with poorly compressible code followed by
236 * a highly compressible string table. 235 * a highly compressible string table.) Smaller buffer sizes give
237 * fast adaptation but have of course 236 * fast adaptation but have of course the overhead of transmitting
238 * trees more frequently. 237 * trees more frequently.
239 * - I can't count above 4 238 * - I can't count above 4
240 */ 239 */
241 240
242 uInt sym_next; /* running index in sy << 241 uInt last_lit; /* running index in l_buf */
243 uInt sym_end; /* symbol table full w << 242
>> 243 ushf *d_buf;
>> 244 /* Buffer for distances. To simplify the code, d_buf and l_buf have
>> 245 * the same number of elements. To use different lengths, an extra flag
>> 246 * array would be necessary.
>> 247 */
244 248
245 ulg opt_len; /* bit length of curre 249 ulg opt_len; /* bit length of current block with optimal trees */
246 ulg static_len; /* bit length of curre 250 ulg static_len; /* bit length of current block with static trees */
247 uInt matches; /* number of string ma 251 uInt matches; /* number of string matches in current block */
248 uInt insert; /* bytes at end of win 252 uInt insert; /* bytes at end of window left to insert */
249 253
250 #ifdef ZLIB_DEBUG 254 #ifdef ZLIB_DEBUG
251 ulg compressed_len; /* total bit length of 255 ulg compressed_len; /* total bit length of compressed file mod 2^32 */
252 ulg bits_sent; /* bit length of compr 256 ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
253 #endif 257 #endif
254 258
255 ush bi_buf; 259 ush bi_buf;
256 /* Output buffer. bits are inserted starti 260 /* Output buffer. bits are inserted starting at the bottom (least
257 * significant bits). 261 * significant bits).
258 */ 262 */
259 int bi_valid; 263 int bi_valid;
260 /* Number of valid bits in bi_buf. All bi 264 /* Number of valid bits in bi_buf. All bits above the last valid bit
261 * are always zero. 265 * are always zero.
262 */ 266 */
263 267
264 ulg high_water; 268 ulg high_water;
265 /* High water mark offset in window for in 269 /* High water mark offset in window for initialized bytes -- bytes above
266 * this are set to zero in order to avoid 270 * this are set to zero in order to avoid memory check warnings when
267 * longest match routines access bytes pas 271 * longest match routines access bytes past the input. This is then
268 * updated to the new high water mark. 272 * updated to the new high water mark.
269 */ 273 */
270 274
271 } FAR deflate_state; 275 } FAR deflate_state;
272 276
273 /* Output a byte on the stream. 277 /* Output a byte on the stream.
274 * IN assertion: there is enough room in pendi 278 * IN assertion: there is enough room in pending_buf.
275 */ 279 */
276 #define put_byte(s, c) {s->pending_buf[s->pend 280 #define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);}
277 281
278 282
279 #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) 283 #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
280 /* Minimum amount of lookahead, except at the 284 /* Minimum amount of lookahead, except at the end of the input file.
281 * See deflate.c for comments about the MIN_MA 285 * See deflate.c for comments about the MIN_MATCH+1.
282 */ 286 */
283 287
284 #define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEA 288 #define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD)
285 /* In order to simplify the code, particularly 289 /* In order to simplify the code, particularly on 16 bit machines, match
286 * distances are limited to MAX_DIST instead o 290 * distances are limited to MAX_DIST instead of WSIZE.
287 */ 291 */
288 292
289 #define WIN_INIT MAX_MATCH 293 #define WIN_INIT MAX_MATCH
290 /* Number of bytes after end of data in window 294 /* Number of bytes after end of data in window to initialize in order to avoid
291 memory checker errors from longest match ro 295 memory checker errors from longest match routines */
292 296
293 /* in trees.c */ 297 /* in trees.c */
294 void ZLIB_INTERNAL _tr_init OF((deflate_state 298 void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
295 int ZLIB_INTERNAL _tr_tally OF((deflate_state 299 int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
296 void ZLIB_INTERNAL _tr_flush_block OF((deflate 300 void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
297 ulg stored_len, int la 301 ulg stored_len, int last));
298 void ZLIB_INTERNAL _tr_flush_bits OF((deflate_ 302 void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
299 void ZLIB_INTERNAL _tr_align OF((deflate_state 303 void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
300 void ZLIB_INTERNAL _tr_stored_block OF((deflat 304 void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
301 ulg stored_len, int la 305 ulg stored_len, int last));
302 306
303 #define d_code(dist) \ 307 #define d_code(dist) \
304 ((dist) < 256 ? _dist_code[dist] : _dist_co 308 ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
305 /* Mapping from a distance to a distance code. 309 /* Mapping from a distance to a distance code. dist is the distance - 1 and
306 * must not have side effects. _dist_code[256] 310 * must not have side effects. _dist_code[256] and _dist_code[257] are never
307 * used. 311 * used.
308 */ 312 */
309 313
310 #ifndef ZLIB_DEBUG 314 #ifndef ZLIB_DEBUG
311 /* Inline versions of _tr_tally for speed: */ 315 /* Inline versions of _tr_tally for speed: */
312 316
313 #if defined(GEN_TREES_H) || !defined(STDC) 317 #if defined(GEN_TREES_H) || !defined(STDC)
314 extern uch ZLIB_INTERNAL _length_code[]; 318 extern uch ZLIB_INTERNAL _length_code[];
315 extern uch ZLIB_INTERNAL _dist_code[]; 319 extern uch ZLIB_INTERNAL _dist_code[];
316 #else 320 #else
317 extern const uch ZLIB_INTERNAL _length_code[ 321 extern const uch ZLIB_INTERNAL _length_code[];
318 extern const uch ZLIB_INTERNAL _dist_code[]; 322 extern const uch ZLIB_INTERNAL _dist_code[];
319 #endif 323 #endif
320 324
321 # define _tr_tally_lit(s, c, flush) \ 325 # define _tr_tally_lit(s, c, flush) \
322 { uch cc = (c); \ 326 { uch cc = (c); \
323 s->sym_buf[s->sym_next++] = 0; \ << 327 s->d_buf[s->last_lit] = 0; \
324 s->sym_buf[s->sym_next++] = 0; \ << 328 s->l_buf[s->last_lit++] = cc; \
325 s->sym_buf[s->sym_next++] = cc; \ <<
326 s->dyn_ltree[cc].Freq++; \ 329 s->dyn_ltree[cc].Freq++; \
327 flush = (s->sym_next == s->sym_end); \ << 330 flush = (s->last_lit == s->lit_bufsize-1); \
328 } 331 }
329 # define _tr_tally_dist(s, distance, length, f 332 # define _tr_tally_dist(s, distance, length, flush) \
330 { uch len = (uch)(length); \ 333 { uch len = (uch)(length); \
331 ush dist = (ush)(distance); \ 334 ush dist = (ush)(distance); \
332 s->sym_buf[s->sym_next++] = (uch)dist; \ << 335 s->d_buf[s->last_lit] = dist; \
333 s->sym_buf[s->sym_next++] = (uch)(dist >> << 336 s->l_buf[s->last_lit++] = len; \
334 s->sym_buf[s->sym_next++] = len; \ <<
335 dist--; \ 337 dist--; \
336 s->dyn_ltree[_length_code[len]+LITERALS+1] 338 s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
337 s->dyn_dtree[d_code(dist)].Freq++; \ 339 s->dyn_dtree[d_code(dist)].Freq++; \
338 flush = (s->sym_next == s->sym_end); \ << 340 flush = (s->last_lit == s->lit_bufsize-1); \
339 } 341 }
340 #else 342 #else
341 # define _tr_tally_lit(s, c, flush) flush = _t 343 # define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
342 # define _tr_tally_dist(s, distance, length, f 344 # define _tr_tally_dist(s, distance, length, flush) \
343 flush = _tr_tally(s, distance, l 345 flush = _tr_tally(s, distance, length)
344 #endif 346 #endif
345 347
346 #endif /* DEFLATE_H */ 348 #endif /* DEFLATE_H */
347 349