1 /* tinfl.c v1.11 - public domain inflate with zlib header parsing/adler32 checking (inflate-only subset of miniz.c) |
|
2 See "unlicense" statement at the end of this file. |
|
3 Rich Geldreich <richgel99@gmail.com>, last updated May 20, 2011 |
|
4 Implements RFC 1950: http://www.ietf.org/rfc/rfc1950.txt and RFC 1951: http://www.ietf.org/rfc/rfc1951.txt |
|
5 |
|
6 The entire decompressor coroutine is implemented in tinfl_decompress(). The other functions are optional high-level helpers. |
|
7 */ |
|
8 #ifndef TINFL_HEADER_INCLUDED |
|
9 #define TINFL_HEADER_INCLUDED |
|
10 |
|
11 typedef PHYSFS_uint8 mz_uint8; |
|
12 typedef PHYSFS_sint16 mz_int16; |
|
13 typedef PHYSFS_uint16 mz_uint16; |
|
14 typedef PHYSFS_uint32 mz_uint32; |
|
15 typedef unsigned int mz_uint; |
|
16 typedef PHYSFS_uint64 mz_uint64; |
|
17 |
|
18 /* For more compatibility with zlib, miniz.c uses unsigned long for some parameters/struct members. */ |
|
19 typedef unsigned long mz_ulong; |
|
20 |
|
21 /* Heap allocation callbacks. */ |
|
22 typedef void *(*mz_alloc_func)(void *opaque, unsigned int items, unsigned int size); |
|
23 typedef void (*mz_free_func)(void *opaque, void *address); |
|
24 |
|
25 #if defined(_M_IX86) || defined(_M_X64) |
|
26 /* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 if integer loads and stores to unaligned addresses are acceptable on the target platform (slightly faster). */ |
|
27 #define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1 |
|
28 /* Set MINIZ_LITTLE_ENDIAN to 1 if the processor is little endian. */ |
|
29 #define MINIZ_LITTLE_ENDIAN 1 |
|
30 #endif |
|
31 |
|
32 #if defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__) |
|
33 /* Set MINIZ_HAS_64BIT_REGISTERS to 1 if the processor has 64-bit general purpose registers (enables 64-bit bitbuffer in inflator) */ |
|
34 #define MINIZ_HAS_64BIT_REGISTERS 1 |
|
35 #endif |
|
36 |
|
37 /* Works around MSVC's spammy "warning C4127: conditional expression is constant" message. */ |
|
38 #ifdef _MSC_VER |
|
39 #define MZ_MACRO_END while (0, 0) |
|
40 #else |
|
41 #define MZ_MACRO_END while (0) |
|
42 #endif |
|
43 |
|
44 /* Decompression flags. */ |
|
45 enum |
|
46 { |
|
47 TINFL_FLAG_PARSE_ZLIB_HEADER = 1, |
|
48 TINFL_FLAG_HAS_MORE_INPUT = 2, |
|
49 TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4, |
|
50 TINFL_FLAG_COMPUTE_ADLER32 = 8 |
|
51 }; |
|
52 |
|
53 struct tinfl_decompressor_tag; typedef struct tinfl_decompressor_tag tinfl_decompressor; |
|
54 |
|
55 /* Max size of LZ dictionary. */ |
|
56 #define TINFL_LZ_DICT_SIZE 32768 |
|
57 |
|
58 /* Return status. */ |
|
59 typedef enum |
|
60 { |
|
61 TINFL_STATUS_BAD_PARAM = -3, |
|
62 TINFL_STATUS_ADLER32_MISMATCH = -2, |
|
63 TINFL_STATUS_FAILED = -1, |
|
64 TINFL_STATUS_DONE = 0, |
|
65 TINFL_STATUS_NEEDS_MORE_INPUT = 1, |
|
66 TINFL_STATUS_HAS_MORE_OUTPUT = 2 |
|
67 } tinfl_status; |
|
68 |
|
69 /* Initializes the decompressor to its initial state. */ |
|
70 #define tinfl_init(r) do { (r)->m_state = 0; } MZ_MACRO_END |
|
71 #define tinfl_get_adler32(r) (r)->m_check_adler32 |
|
72 |
|
73 /* Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability. */ |
|
74 /* This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output. */ |
|
75 static tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags); |
|
76 |
|
77 /* Internal/private bits follow. */ |
|
78 enum |
|
79 { |
|
80 TINFL_MAX_HUFF_TABLES = 3, TINFL_MAX_HUFF_SYMBOLS_0 = 288, TINFL_MAX_HUFF_SYMBOLS_1 = 32, TINFL_MAX_HUFF_SYMBOLS_2 = 19, |
|
81 TINFL_FAST_LOOKUP_BITS = 10, TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS |
|
82 }; |
|
83 |
|
84 typedef struct |
|
85 { |
|
86 mz_uint8 m_code_size[TINFL_MAX_HUFF_SYMBOLS_0]; |
|
87 mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE], m_tree[TINFL_MAX_HUFF_SYMBOLS_0 * 2]; |
|
88 } tinfl_huff_table; |
|
89 |
|
90 #if MINIZ_HAS_64BIT_REGISTERS |
|
91 #define TINFL_USE_64BIT_BITBUF 1 |
|
92 #endif |
|
93 |
|
94 #if TINFL_USE_64BIT_BITBUF |
|
95 typedef mz_uint64 tinfl_bit_buf_t; |
|
96 #define TINFL_BITBUF_SIZE (64) |
|
97 #else |
|
98 typedef mz_uint32 tinfl_bit_buf_t; |
|
99 #define TINFL_BITBUF_SIZE (32) |
|
100 #endif |
|
101 |
|
102 struct tinfl_decompressor_tag |
|
103 { |
|
104 mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, m_final, m_type, m_check_adler32, m_dist, m_counter, m_num_extra, m_table_sizes[TINFL_MAX_HUFF_TABLES]; |
|
105 tinfl_bit_buf_t m_bit_buf; |
|
106 size_t m_dist_from_out_buf_start; |
|
107 tinfl_huff_table m_tables[TINFL_MAX_HUFF_TABLES]; |
|
108 mz_uint8 m_raw_header[4], m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0 + TINFL_MAX_HUFF_SYMBOLS_1 + 137]; |
|
109 }; |
|
110 |
|
111 #endif /* #ifdef TINFL_HEADER_INCLUDED */ |
|
112 |
|
113 /* ------------------- End of Header: Implementation follows. (If you only want the header, define MINIZ_HEADER_FILE_ONLY.) */ |
|
114 |
|
115 #ifndef TINFL_HEADER_FILE_ONLY |
|
116 |
|
117 #define MZ_MAX(a,b) (((a)>(b))?(a):(b)) |
|
118 #define MZ_MIN(a,b) (((a)<(b))?(a):(b)) |
|
119 #define MZ_CLEAR_OBJ(obj) memset(&(obj), 0, sizeof(obj)) |
|
120 |
|
121 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN |
|
122 #define MZ_READ_LE16(p) *((const mz_uint16 *)(p)) |
|
123 #define MZ_READ_LE32(p) *((const mz_uint32 *)(p)) |
|
124 #else |
|
125 #define MZ_READ_LE16(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) |
|
126 #define MZ_READ_LE32(p) ((mz_uint32)(((const mz_uint8 *)(p))[0]) | ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) |
|
127 #endif |
|
128 |
|
129 #define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) |
|
130 #define TINFL_MEMSET(p, c, l) memset(p, c, l) |
|
131 |
|
132 #define TINFL_CR_BEGIN switch(r->m_state) { case 0: |
|
133 #define TINFL_CR_RETURN(state_index, result) do { status = result; r->m_state = state_index; goto common_exit; case state_index:; } MZ_MACRO_END |
|
134 #define TINFL_CR_RETURN_FOREVER(state_index, result) do { for ( ; ; ) { TINFL_CR_RETURN(state_index, result); } } MZ_MACRO_END |
|
135 #define TINFL_CR_FINISH } |
|
136 |
|
137 /* TODO: If the caller has indicated that there's no more input, and we attempt to read beyond the input buf, then something is wrong with the input because the inflator never */ |
|
138 /* reads ahead more than it needs to. Currently TINFL_GET_BYTE() pads the end of the stream with 0's in this scenario. */ |
|
139 #define TINFL_GET_BYTE(state_index, c) do { \ |
|
140 if (pIn_buf_cur >= pIn_buf_end) { \ |
|
141 for ( ; ; ) { \ |
|
142 if (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) { \ |
|
143 TINFL_CR_RETURN(state_index, TINFL_STATUS_NEEDS_MORE_INPUT); \ |
|
144 if (pIn_buf_cur < pIn_buf_end) { \ |
|
145 c = *pIn_buf_cur++; \ |
|
146 break; \ |
|
147 } \ |
|
148 } else { \ |
|
149 c = 0; \ |
|
150 break; \ |
|
151 } \ |
|
152 } \ |
|
153 } else c = *pIn_buf_cur++; } MZ_MACRO_END |
|
154 |
|
155 #define TINFL_NEED_BITS(state_index, n) do { mz_uint c; TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; } while (num_bits < (mz_uint)(n)) |
|
156 #define TINFL_SKIP_BITS(state_index, n) do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END |
|
157 #define TINFL_GET_BITS(state_index, b, n) do { if (num_bits < (mz_uint)(n)) { TINFL_NEED_BITS(state_index, n); } b = bit_buf & ((1 << (n)) - 1); bit_buf >>= (n); num_bits -= (n); } MZ_MACRO_END |
|
158 |
|
159 /* TINFL_HUFF_BITBUF_FILL() is only used rarely, when the number of bytes remaining in the input buffer falls below 2. */ |
|
160 /* It reads just enough bytes from the input stream that are needed to decode the next Huffman code (and absolutely no more). It works by trying to fully decode a */ |
|
161 /* Huffman code by using whatever bits are currently present in the bit buffer. If this fails, it reads another byte, and tries again until it succeeds or until the */ |
|
162 /* bit buffer contains >=15 bits (deflate's max. Huffman code size). */ |
|
163 #define TINFL_HUFF_BITBUF_FILL(state_index, pHuff) \ |
|
164 do { \ |
|
165 temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ |
|
166 if (temp >= 0) { \ |
|
167 code_len = temp >> 9; \ |
|
168 if ((code_len) && (num_bits >= code_len)) \ |
|
169 break; \ |
|
170 } else if (num_bits > TINFL_FAST_LOOKUP_BITS) { \ |
|
171 code_len = TINFL_FAST_LOOKUP_BITS; \ |
|
172 do { \ |
|
173 temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \ |
|
174 } while ((temp < 0) && (num_bits >= (code_len + 1))); if (temp >= 0) break; \ |
|
175 } TINFL_GET_BYTE(state_index, c); bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); num_bits += 8; \ |
|
176 } while (num_bits < 15); |
|
177 |
|
178 /* TINFL_HUFF_DECODE() decodes the next Huffman coded symbol. It's more complex than you would initially expect because the zlib API expects the decompressor to never read */ |
|
179 /* beyond the final byte of the deflate stream. (In other words, when this macro wants to read another byte from the input, it REALLY needs another byte in order to fully */ |
|
180 /* decode the next Huffman code.) Handling this properly is particularly important on raw deflate (non-zlib) streams, which aren't followed by a byte aligned adler-32. */ |
|
181 /* The slow path is only executed at the very end of the input buffer. */ |
|
182 #define TINFL_HUFF_DECODE(state_index, sym, pHuff) do { \ |
|
183 int temp; mz_uint code_len, c; \ |
|
184 if (num_bits < 15) { \ |
|
185 if ((pIn_buf_end - pIn_buf_cur) < 2) { \ |
|
186 TINFL_HUFF_BITBUF_FILL(state_index, pHuff); \ |
|
187 } else { \ |
|
188 bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); pIn_buf_cur += 2; num_bits += 16; \ |
|
189 } \ |
|
190 } \ |
|
191 if ((temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ |
|
192 code_len = temp >> 9, temp &= 511; \ |
|
193 else { \ |
|
194 code_len = TINFL_FAST_LOOKUP_BITS; do { temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; } while (temp < 0); \ |
|
195 } sym = temp; bit_buf >>= code_len; num_bits -= code_len; } MZ_MACRO_END |
|
196 |
|
197 static tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags) |
|
198 { |
|
199 static const int s_length_base[31] = { 3,4,5,6,7,8,9,10,11,13, 15,17,19,23,27,31,35,43,51,59, 67,83,99,115,131,163,195,227,258,0,0 }; |
|
200 static const int s_length_extra[31]= { 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; |
|
201 static const int s_dist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, 257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; |
|
202 static const int s_dist_extra[32] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; |
|
203 static const mz_uint8 s_length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; |
|
204 static const int s_min_table_sizes[3] = { 257, 1, 4 }; |
|
205 |
|
206 tinfl_status status = TINFL_STATUS_FAILED; mz_uint32 num_bits, dist, counter, num_extra; tinfl_bit_buf_t bit_buf; |
|
207 const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size; |
|
208 mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next + *pOut_buf_size; |
|
209 size_t out_buf_size_mask = (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ? (size_t)-1 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, dist_from_out_buf_start; |
|
210 |
|
211 /* Ensure the output buffer's size is a power of 2, unless the output buffer is large enough to hold the entire output file (in which case it doesn't matter). */ |
|
212 if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start)) { *pIn_buf_size = *pOut_buf_size = 0; return TINFL_STATUS_BAD_PARAM; } |
|
213 |
|
214 num_bits = r->m_num_bits; bit_buf = r->m_bit_buf; dist = r->m_dist; counter = r->m_counter; num_extra = r->m_num_extra; dist_from_out_buf_start = r->m_dist_from_out_buf_start; |
|
215 TINFL_CR_BEGIN |
|
216 |
|
217 bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0; r->m_z_adler32 = r->m_check_adler32 = 1; |
|
218 if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) |
|
219 { |
|
220 TINFL_GET_BYTE(1, r->m_zhdr0); TINFL_GET_BYTE(2, r->m_zhdr1); |
|
221 counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8)); |
|
222 if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)(1U << (8U + (r->m_zhdr0 >> 4))))); |
|
223 if (counter) { TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED); } |
|
224 } |
|
225 |
|
226 do |
|
227 { |
|
228 TINFL_GET_BITS(3, r->m_final, 3); r->m_type = r->m_final >> 1; |
|
229 if (r->m_type == 0) |
|
230 { |
|
231 TINFL_SKIP_BITS(5, num_bits & 7); |
|
232 for (counter = 0; counter < 4; ++counter) { if (num_bits) TINFL_GET_BITS(6, r->m_raw_header[counter], 8); else TINFL_GET_BYTE(7, r->m_raw_header[counter]); } |
|
233 if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != (mz_uint)(0xFFFF ^ (r->m_raw_header[2] | (r->m_raw_header[3] << 8)))) { TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED); } |
|
234 while ((counter) && (num_bits)) |
|
235 { |
|
236 TINFL_GET_BITS(51, dist, 8); |
|
237 while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT); } |
|
238 *pOut_buf_cur++ = (mz_uint8)dist; |
|
239 counter--; |
|
240 } |
|
241 while (counter) |
|
242 { |
|
243 size_t n; while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT); } |
|
244 while (pIn_buf_cur >= pIn_buf_end) |
|
245 { |
|
246 if (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) |
|
247 { |
|
248 TINFL_CR_RETURN(38, TINFL_STATUS_NEEDS_MORE_INPUT); |
|
249 } |
|
250 else |
|
251 { |
|
252 TINFL_CR_RETURN_FOREVER(40, TINFL_STATUS_FAILED); |
|
253 } |
|
254 } |
|
255 n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), (size_t)(pIn_buf_end - pIn_buf_cur)), counter); |
|
256 TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n); pIn_buf_cur += n; pOut_buf_cur += n; counter -= (mz_uint)n; |
|
257 } |
|
258 } |
|
259 else if (r->m_type == 3) |
|
260 { |
|
261 TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED); |
|
262 } |
|
263 else |
|
264 { |
|
265 if (r->m_type == 1) |
|
266 { |
|
267 mz_uint8 *p = r->m_tables[0].m_code_size; mz_uint i; |
|
268 r->m_table_sizes[0] = 288; r->m_table_sizes[1] = 32; TINFL_MEMSET(r->m_tables[1].m_code_size, 5, 32); |
|
269 for ( i = 0; i <= 143; ++i) *p++ = 8; for ( ; i <= 255; ++i) *p++ = 9; for ( ; i <= 279; ++i) *p++ = 7; for ( ; i <= 287; ++i) *p++ = 8; |
|
270 } |
|
271 else |
|
272 { |
|
273 for (counter = 0; counter < 3; counter++) { TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); r->m_table_sizes[counter] += s_min_table_sizes[counter]; } |
|
274 MZ_CLEAR_OBJ(r->m_tables[2].m_code_size); for (counter = 0; counter < r->m_table_sizes[2]; counter++) { mz_uint s; TINFL_GET_BITS(14, s, 3); r->m_tables[2].m_code_size[s_length_dezigzag[counter]] = (mz_uint8)s; } |
|
275 r->m_table_sizes[2] = 19; |
|
276 } |
|
277 for ( ; (int)r->m_type >= 0; r->m_type--) |
|
278 { |
|
279 int tree_next, tree_cur; tinfl_huff_table *pTable; |
|
280 mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16]; pTable = &r->m_tables[r->m_type]; MZ_CLEAR_OBJ(total_syms); MZ_CLEAR_OBJ(pTable->m_look_up); MZ_CLEAR_OBJ(pTable->m_tree); |
|
281 for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) total_syms[pTable->m_code_size[i]]++; |
|
282 used_syms = 0, total = 0; next_code[0] = next_code[1] = 0; |
|
283 for (i = 1; i <= 15; ++i) { used_syms += total_syms[i]; next_code[i + 1] = (total = ((total + total_syms[i]) << 1)); } |
|
284 if ((65536 != total) && (used_syms > 1)) |
|
285 { |
|
286 TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED); |
|
287 } |
|
288 for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index) |
|
289 { |
|
290 mz_uint rev_code = 0, l, cur_code, code_size = pTable->m_code_size[sym_index]; if (!code_size) continue; |
|
291 cur_code = next_code[code_size]++; for (l = code_size; l > 0; l--, cur_code >>= 1) rev_code = (rev_code << 1) | (cur_code & 1); |
|
292 if (code_size <= TINFL_FAST_LOOKUP_BITS) { mz_int16 k = (mz_int16)((code_size << 9) | sym_index); while (rev_code < TINFL_FAST_LOOKUP_SIZE) { pTable->m_look_up[rev_code] = k; rev_code += (1 << code_size); } continue; } |
|
293 if (0 == (tree_cur = pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) { pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next; tree_cur = tree_next; tree_next -= 2; } |
|
294 rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1); |
|
295 for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--) |
|
296 { |
|
297 tree_cur -= ((rev_code >>= 1) & 1); |
|
298 if (!pTable->m_tree[-tree_cur - 1]) { pTable->m_tree[-tree_cur - 1] = (mz_int16)tree_next; tree_cur = tree_next; tree_next -= 2; } else tree_cur = pTable->m_tree[-tree_cur - 1]; |
|
299 } |
|
300 tree_cur -= ((rev_code >>= 1) & 1); pTable->m_tree[-tree_cur - 1] = (mz_int16)sym_index; |
|
301 } |
|
302 if (r->m_type == 2) |
|
303 { |
|
304 for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]); ) |
|
305 { |
|
306 mz_uint s; TINFL_HUFF_DECODE(16, dist, &r->m_tables[2]); if (dist < 16) { r->m_len_codes[counter++] = (mz_uint8)dist; continue; } |
|
307 if ((dist == 16) && (!counter)) |
|
308 { |
|
309 TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED); |
|
310 } |
|
311 num_extra = "\02\03\07"[dist - 16]; TINFL_GET_BITS(18, s, num_extra); s += "\03\03\013"[dist - 16]; |
|
312 TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s); counter += s; |
|
313 } |
|
314 if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter) |
|
315 { |
|
316 TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED); |
|
317 } |
|
318 TINFL_MEMCPY(r->m_tables[0].m_code_size, r->m_len_codes, r->m_table_sizes[0]); TINFL_MEMCPY(r->m_tables[1].m_code_size, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]); |
|
319 } |
|
320 } |
|
321 for ( ; ; ) |
|
322 { |
|
323 mz_uint8 *pSrc; |
|
324 for ( ; ; ) |
|
325 { |
|
326 if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2)) |
|
327 { |
|
328 TINFL_HUFF_DECODE(23, counter, &r->m_tables[0]); |
|
329 if (counter >= 256) |
|
330 break; |
|
331 while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT); } |
|
332 *pOut_buf_cur++ = (mz_uint8)counter; |
|
333 } |
|
334 else |
|
335 { |
|
336 int sym2; mz_uint code_len; |
|
337 #if TINFL_USE_64BIT_BITBUF |
|
338 if (num_bits < 30) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits); pIn_buf_cur += 4; num_bits += 32; } |
|
339 #else |
|
340 if (num_bits < 15) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); pIn_buf_cur += 2; num_bits += 16; } |
|
341 #endif |
|
342 if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) |
|
343 code_len = sym2 >> 9; |
|
344 else |
|
345 { |
|
346 code_len = TINFL_FAST_LOOKUP_BITS; do { sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)]; } while (sym2 < 0); |
|
347 } |
|
348 counter = sym2; bit_buf >>= code_len; num_bits -= code_len; |
|
349 if (counter & 256) |
|
350 break; |
|
351 |
|
352 #if !TINFL_USE_64BIT_BITBUF |
|
353 if (num_bits < 15) { bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); pIn_buf_cur += 2; num_bits += 16; } |
|
354 #endif |
|
355 if ((sym2 = r->m_tables[0].m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) |
|
356 code_len = sym2 >> 9; |
|
357 else |
|
358 { |
|
359 code_len = TINFL_FAST_LOOKUP_BITS; do { sym2 = r->m_tables[0].m_tree[~sym2 + ((bit_buf >> code_len++) & 1)]; } while (sym2 < 0); |
|
360 } |
|
361 bit_buf >>= code_len; num_bits -= code_len; |
|
362 |
|
363 pOut_buf_cur[0] = (mz_uint8)counter; |
|
364 if (sym2 & 256) |
|
365 { |
|
366 pOut_buf_cur++; |
|
367 counter = sym2; |
|
368 break; |
|
369 } |
|
370 pOut_buf_cur[1] = (mz_uint8)sym2; |
|
371 pOut_buf_cur += 2; |
|
372 } |
|
373 } |
|
374 if ((counter &= 511) == 256) break; |
|
375 |
|
376 num_extra = s_length_extra[counter - 257]; counter = s_length_base[counter - 257]; |
|
377 if (num_extra) { mz_uint extra_bits; TINFL_GET_BITS(25, extra_bits, num_extra); counter += extra_bits; } |
|
378 |
|
379 TINFL_HUFF_DECODE(26, dist, &r->m_tables[1]); |
|
380 num_extra = s_dist_extra[dist]; dist = s_dist_base[dist]; |
|
381 if (num_extra) { mz_uint extra_bits; TINFL_GET_BITS(27, extra_bits, num_extra); dist += extra_bits; } |
|
382 |
|
383 dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start; |
|
384 if ((dist > dist_from_out_buf_start) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) |
|
385 { |
|
386 TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED); |
|
387 } |
|
388 |
|
389 pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask); |
|
390 |
|
391 if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end) |
|
392 { |
|
393 while (counter--) |
|
394 { |
|
395 while (pOut_buf_cur >= pOut_buf_end) { TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT); } |
|
396 *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask]; |
|
397 } |
|
398 continue; |
|
399 } |
|
400 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES |
|
401 else if ((counter >= 9) && (counter <= dist)) |
|
402 { |
|
403 const mz_uint8 *pSrc_end = pSrc + (counter & ~7); |
|
404 do |
|
405 { |
|
406 ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0]; |
|
407 ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1]; |
|
408 pOut_buf_cur += 8; |
|
409 } while ((pSrc += 8) < pSrc_end); |
|
410 if ((counter &= 7) < 3) |
|
411 { |
|
412 if (counter) |
|
413 { |
|
414 pOut_buf_cur[0] = pSrc[0]; |
|
415 if (counter > 1) |
|
416 pOut_buf_cur[1] = pSrc[1]; |
|
417 pOut_buf_cur += counter; |
|
418 } |
|
419 continue; |
|
420 } |
|
421 } |
|
422 #endif |
|
423 do |
|
424 { |
|
425 pOut_buf_cur[0] = pSrc[0]; |
|
426 pOut_buf_cur[1] = pSrc[1]; |
|
427 pOut_buf_cur[2] = pSrc[2]; |
|
428 pOut_buf_cur += 3; pSrc += 3; |
|
429 } while ((int)(counter -= 3) > 2); |
|
430 if ((int)counter > 0) |
|
431 { |
|
432 pOut_buf_cur[0] = pSrc[0]; |
|
433 if ((int)counter > 1) |
|
434 pOut_buf_cur[1] = pSrc[1]; |
|
435 pOut_buf_cur += counter; |
|
436 } |
|
437 } |
|
438 } |
|
439 } while (!(r->m_final & 1)); |
|
440 if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) |
|
441 { |
|
442 TINFL_SKIP_BITS(32, num_bits & 7); for (counter = 0; counter < 4; ++counter) { mz_uint s; if (num_bits) TINFL_GET_BITS(41, s, 8); else TINFL_GET_BYTE(42, s); r->m_z_adler32 = (r->m_z_adler32 << 8) | s; } |
|
443 } |
|
444 TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE); |
|
445 TINFL_CR_FINISH |
|
446 |
|
447 common_exit: |
|
448 r->m_num_bits = num_bits; r->m_bit_buf = bit_buf; r->m_dist = dist; r->m_counter = counter; r->m_num_extra = num_extra; r->m_dist_from_out_buf_start = dist_from_out_buf_start; |
|
449 *pIn_buf_size = pIn_buf_cur - pIn_buf_next; *pOut_buf_size = pOut_buf_cur - pOut_buf_next; |
|
450 if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0)) |
|
451 { |
|
452 const mz_uint8 *ptr = pOut_buf_next; size_t buf_len = *pOut_buf_size; |
|
453 mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16; size_t block_len = buf_len % 5552; |
|
454 while (buf_len) |
|
455 { |
|
456 for (i = 0; i + 7 < block_len; i += 8, ptr += 8) |
|
457 { |
|
458 s1 += ptr[0], s2 += s1; s1 += ptr[1], s2 += s1; s1 += ptr[2], s2 += s1; s1 += ptr[3], s2 += s1; |
|
459 s1 += ptr[4], s2 += s1; s1 += ptr[5], s2 += s1; s1 += ptr[6], s2 += s1; s1 += ptr[7], s2 += s1; |
|
460 } |
|
461 for ( ; i < block_len; ++i) s1 += *ptr++, s2 += s1; |
|
462 s1 %= 65521U, s2 %= 65521U; buf_len -= block_len; block_len = 5552; |
|
463 } |
|
464 r->m_check_adler32 = (s2 << 16) + s1; if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32)) status = TINFL_STATUS_ADLER32_MISMATCH; |
|
465 } |
|
466 return status; |
|
467 } |
|
468 |
|
469 /* Flush values. For typical usage you only need MZ_NO_FLUSH and MZ_FINISH. The other stuff is for advanced use. */ |
|
470 enum { MZ_NO_FLUSH = 0, MZ_PARTIAL_FLUSH = 1, MZ_SYNC_FLUSH = 2, MZ_FULL_FLUSH = 3, MZ_FINISH = 4, MZ_BLOCK = 5 }; |
|
471 |
|
472 /* Return status codes. MZ_PARAM_ERROR is non-standard. */ |
|
473 enum { MZ_OK = 0, MZ_STREAM_END = 1, MZ_NEED_DICT = 2, MZ_ERRNO = -1, MZ_STREAM_ERROR = -2, MZ_DATA_ERROR = -3, MZ_MEM_ERROR = -4, MZ_BUF_ERROR = -5, MZ_VERSION_ERROR = -6, MZ_PARAM_ERROR = -10000 }; |
|
474 |
|
475 /* Compression levels. */ |
|
476 enum { MZ_NO_COMPRESSION = 0, MZ_BEST_SPEED = 1, MZ_BEST_COMPRESSION = 9, MZ_DEFAULT_COMPRESSION = -1 }; |
|
477 |
|
478 /* Window bits */ |
|
479 #define MZ_DEFAULT_WINDOW_BITS 15 |
|
480 |
|
481 struct mz_internal_state; |
|
482 |
|
483 /* Compression/decompression stream struct. */ |
|
484 typedef struct mz_stream_s |
|
485 { |
|
486 const unsigned char *next_in; /* pointer to next byte to read */ |
|
487 unsigned int avail_in; /* number of bytes available at next_in */ |
|
488 mz_ulong total_in; /* total number of bytes consumed so far */ |
|
489 |
|
490 unsigned char *next_out; /* pointer to next byte to write */ |
|
491 unsigned int avail_out; /* number of bytes that can be written to next_out */ |
|
492 mz_ulong total_out; /* total number of bytes produced so far */ |
|
493 |
|
494 char *msg; /* error msg (unused) */ |
|
495 struct mz_internal_state *state; /* internal state, allocated by zalloc/zfree */ |
|
496 |
|
497 mz_alloc_func zalloc; /* optional heap allocation function (defaults to malloc) */ |
|
498 mz_free_func zfree; /* optional heap free function (defaults to free) */ |
|
499 void *opaque; /* heap alloc function user pointer */ |
|
500 |
|
501 int data_type; /* data_type (unused) */ |
|
502 mz_ulong adler; /* adler32 of the source or uncompressed data */ |
|
503 mz_ulong reserved; /* not used */ |
|
504 } mz_stream; |
|
505 |
|
506 typedef mz_stream *mz_streamp; |
|
507 |
|
508 |
|
509 typedef struct |
|
510 { |
|
511 tinfl_decompressor m_decomp; |
|
512 mz_uint m_dict_ofs, m_dict_avail, m_first_call, m_has_flushed; int m_window_bits; |
|
513 mz_uint8 m_dict[TINFL_LZ_DICT_SIZE]; |
|
514 tinfl_status m_last_status; |
|
515 } inflate_state; |
|
516 |
|
517 static int mz_inflateInit2(mz_streamp pStream, int window_bits) |
|
518 { |
|
519 inflate_state *pDecomp; |
|
520 if (!pStream) return MZ_STREAM_ERROR; |
|
521 if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)) return MZ_PARAM_ERROR; |
|
522 |
|
523 pStream->data_type = 0; |
|
524 pStream->adler = 0; |
|
525 pStream->msg = NULL; |
|
526 pStream->total_in = 0; |
|
527 pStream->total_out = 0; |
|
528 pStream->reserved = 0; |
|
529 /* if (!pStream->zalloc) pStream->zalloc = def_alloc_func; */ |
|
530 /* if (!pStream->zfree) pStream->zfree = def_free_func; */ |
|
531 |
|
532 pDecomp = (inflate_state*)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state)); |
|
533 if (!pDecomp) return MZ_MEM_ERROR; |
|
534 |
|
535 pStream->state = (struct mz_internal_state *)pDecomp; |
|
536 |
|
537 tinfl_init(&pDecomp->m_decomp); |
|
538 pDecomp->m_dict_ofs = 0; |
|
539 pDecomp->m_dict_avail = 0; |
|
540 pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT; |
|
541 pDecomp->m_first_call = 1; |
|
542 pDecomp->m_has_flushed = 0; |
|
543 pDecomp->m_window_bits = window_bits; |
|
544 |
|
545 return MZ_OK; |
|
546 } |
|
547 |
|
548 static int mz_inflate(mz_streamp pStream, int flush) |
|
549 { |
|
550 inflate_state* pState; |
|
551 mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32; |
|
552 size_t in_bytes, out_bytes, orig_avail_in; |
|
553 tinfl_status status; |
|
554 |
|
555 if ((!pStream) || (!pStream->state)) return MZ_STREAM_ERROR; |
|
556 if (flush == MZ_PARTIAL_FLUSH) flush = MZ_SYNC_FLUSH; |
|
557 if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH)) return MZ_STREAM_ERROR; |
|
558 |
|
559 pState = (inflate_state*)pStream->state; |
|
560 if (pState->m_window_bits > 0) decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER; |
|
561 orig_avail_in = pStream->avail_in; |
|
562 |
|
563 first_call = pState->m_first_call; pState->m_first_call = 0; |
|
564 if (pState->m_last_status < 0) return MZ_DATA_ERROR; |
|
565 |
|
566 if (pState->m_has_flushed && (flush != MZ_FINISH)) return MZ_STREAM_ERROR; |
|
567 pState->m_has_flushed |= (flush == MZ_FINISH); |
|
568 |
|
569 if ((flush == MZ_FINISH) && (first_call)) |
|
570 { |
|
571 /* MZ_FINISH on the first call implies that the input and output buffers are large enough to hold the entire compressed/decompressed file. */ |
|
572 decomp_flags |= TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF; |
|
573 in_bytes = pStream->avail_in; out_bytes = pStream->avail_out; |
|
574 status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pStream->next_out, pStream->next_out, &out_bytes, decomp_flags); |
|
575 pState->m_last_status = status; |
|
576 pStream->next_in += (mz_uint)in_bytes; pStream->avail_in -= (mz_uint)in_bytes; pStream->total_in += (mz_uint)in_bytes; |
|
577 pStream->adler = tinfl_get_adler32(&pState->m_decomp); |
|
578 pStream->next_out += (mz_uint)out_bytes; pStream->avail_out -= (mz_uint)out_bytes; pStream->total_out += (mz_uint)out_bytes; |
|
579 |
|
580 if (status < 0) |
|
581 return MZ_DATA_ERROR; |
|
582 else if (status != TINFL_STATUS_DONE) |
|
583 { |
|
584 pState->m_last_status = TINFL_STATUS_FAILED; |
|
585 return MZ_BUF_ERROR; |
|
586 } |
|
587 return MZ_STREAM_END; |
|
588 } |
|
589 /* flush != MZ_FINISH then we must assume there's more input. */ |
|
590 if (flush != MZ_FINISH) decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT; |
|
591 |
|
592 if (pState->m_dict_avail) |
|
593 { |
|
594 n = MZ_MIN(pState->m_dict_avail, pStream->avail_out); |
|
595 memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n); |
|
596 pStream->next_out += n; pStream->avail_out -= n; pStream->total_out += n; |
|
597 pState->m_dict_avail -= n; pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1); |
|
598 return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; |
|
599 } |
|
600 |
|
601 for ( ; ; ) |
|
602 { |
|
603 in_bytes = pStream->avail_in; |
|
604 out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs; |
|
605 |
|
606 status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pState->m_dict, pState->m_dict + pState->m_dict_ofs, &out_bytes, decomp_flags); |
|
607 pState->m_last_status = status; |
|
608 |
|
609 pStream->next_in += (mz_uint)in_bytes; pStream->avail_in -= (mz_uint)in_bytes; |
|
610 pStream->total_in += (mz_uint)in_bytes; pStream->adler = tinfl_get_adler32(&pState->m_decomp); |
|
611 |
|
612 pState->m_dict_avail = (mz_uint)out_bytes; |
|
613 |
|
614 n = MZ_MIN(pState->m_dict_avail, pStream->avail_out); |
|
615 memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n); |
|
616 pStream->next_out += n; pStream->avail_out -= n; pStream->total_out += n; |
|
617 pState->m_dict_avail -= n; pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1); |
|
618 |
|
619 if (status < 0) |
|
620 return MZ_DATA_ERROR; /* Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well). */ |
|
621 else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in)) |
|
622 return MZ_BUF_ERROR; /* Signal caller that we can't make forward progress without supplying more input or by setting flush to MZ_FINISH. */ |
|
623 else if (flush == MZ_FINISH) |
|
624 { |
|
625 /* The output buffer MUST be large to hold the remaining uncompressed data when flush==MZ_FINISH. */ |
|
626 if (status == TINFL_STATUS_DONE) |
|
627 return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END; |
|
628 /* status here must be TINFL_STATUS_HAS_MORE_OUTPUT, which means there's at least 1 more byte on the way. If there's no more room left in the output buffer then something is wrong. */ |
|
629 else if (!pStream->avail_out) |
|
630 return MZ_BUF_ERROR; |
|
631 } |
|
632 else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail)) |
|
633 break; |
|
634 } |
|
635 |
|
636 return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; |
|
637 } |
|
638 |
|
639 static int mz_inflateEnd(mz_streamp pStream) |
|
640 { |
|
641 if (!pStream) |
|
642 return MZ_STREAM_ERROR; |
|
643 if (pStream->state) |
|
644 { |
|
645 pStream->zfree(pStream->opaque, pStream->state); |
|
646 pStream->state = NULL; |
|
647 } |
|
648 return MZ_OK; |
|
649 } |
|
650 |
|
651 /* make this a drop-in replacement for zlib... */ |
|
652 #define voidpf void* |
|
653 #define uInt unsigned int |
|
654 #define z_stream mz_stream |
|
655 #define inflateInit2 mz_inflateInit2 |
|
656 #define inflate mz_inflate |
|
657 #define inflateEnd mz_inflateEnd |
|
658 #define Z_SYNC_FLUSH MZ_SYNC_FLUSH |
|
659 #define Z_FINISH MZ_FINISH |
|
660 #define Z_OK MZ_OK |
|
661 #define Z_STREAM_END MZ_STREAM_END |
|
662 #define Z_NEED_DICT MZ_NEED_DICT |
|
663 #define Z_ERRNO MZ_ERRNO |
|
664 #define Z_STREAM_ERROR MZ_STREAM_ERROR |
|
665 #define Z_DATA_ERROR MZ_DATA_ERROR |
|
666 #define Z_MEM_ERROR MZ_MEM_ERROR |
|
667 #define Z_BUF_ERROR MZ_BUF_ERROR |
|
668 #define Z_VERSION_ERROR MZ_VERSION_ERROR |
|
669 #define MAX_WBITS 15 |
|
670 |
|
671 #endif /* #ifndef TINFL_HEADER_FILE_ONLY */ |
|
672 |
|
673 /* |
|
674 This is free and unencumbered software released into the public domain. |
|
675 |
|
676 Anyone is free to copy, modify, publish, use, compile, sell, or |
|
677 distribute this software, either in source code form or as a compiled |
|
678 binary, for any purpose, commercial or non-commercial, and by any |
|
679 means. |
|
680 |
|
681 In jurisdictions that recognize copyright laws, the author or authors |
|
682 of this software dedicate any and all copyright interest in the |
|
683 software to the public domain. We make this dedication for the benefit |
|
684 of the public at large and to the detriment of our heirs and |
|
685 successors. We intend this dedication to be an overt act of |
|
686 relinquishment in perpetuity of all present and future rights to this |
|
687 software under copyright law. |
|
688 |
|
689 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
690 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
691 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
|
692 IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
|
693 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
|
694 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
|
695 OTHER DEALINGS IN THE SOFTWARE. |
|
696 |
|
697 For more information, please refer to <http://unlicense.org/> |
|
698 */ |
|