diff options
author | Richard Purdie <richard@openedhand.com> | 2006-07-21 10:10:31 +0000 |
---|---|---|
committer | Richard Purdie <richard@openedhand.com> | 2006-07-21 10:10:31 +0000 |
commit | b2f192faabe412adce79534e22efe9fb69ee40e2 (patch) | |
tree | 7076c49d4286f8a1733650bd8fbc7161af200d57 /meta/packages/zlib/files | |
parent | 2cf0eadf9f730027833af802d7e6c90b44248f80 (diff) | |
download | poky-b2f192faabe412adce79534e22efe9fb69ee40e2.tar.gz |
Rename /openembedded/ -> /meta/
git-svn-id: https://svn.o-hand.com/repos/poky/trunk@530 311d38ba-8fff-0310-9ca6-ca027cbcb966
Diffstat (limited to 'meta/packages/zlib/files')
-rw-r--r-- | meta/packages/zlib/files/visibility.patch | 1022 | ||||
-rw-r--r-- | meta/packages/zlib/files/zlib_1.2.2-8.diff.gz | bin | 0 -> 15553 bytes |
2 files changed, 1022 insertions, 0 deletions
diff --git a/meta/packages/zlib/files/visibility.patch b/meta/packages/zlib/files/visibility.patch new file mode 100644 index 0000000000..ba1a2a6fef --- /dev/null +++ b/meta/packages/zlib/files/visibility.patch | |||
@@ -0,0 +1,1022 @@ | |||
1 | --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/adler32.c 2003-11-17 15:24:27.000000000 -0600 | ||
2 | +++ zlib-1.2.2/adler32.c 2005-02-28 19:04:09.000000000 -0600 | ||
3 | @@ -44,7 +44,7 @@ | ||
4 | #endif | ||
5 | |||
6 | /* ========================================================================= */ | ||
7 | -uLong ZEXPORT adler32(adler, buf, len) | ||
8 | +ZEXPORT uLong adler32(adler, buf, len) | ||
9 | uLong adler; | ||
10 | const Bytef *buf; | ||
11 | uInt len; | ||
12 | --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/compress.c 2003-07-07 00:37:56.000000000 -0500 | ||
13 | +++ zlib-1.2.2/compress.c 2005-02-28 19:04:09.000000000 -0600 | ||
14 | @@ -19,7 +19,7 @@ | ||
15 | memory, Z_BUF_ERROR if there was not enough room in the output buffer, | ||
16 | Z_STREAM_ERROR if the level parameter is invalid. | ||
17 | */ | ||
18 | -int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) | ||
19 | +ZEXPORT int compress2 (dest, destLen, source, sourceLen, level) | ||
20 | Bytef *dest; | ||
21 | uLongf *destLen; | ||
22 | const Bytef *source; | ||
23 | @@ -59,7 +59,7 @@ | ||
24 | |||
25 | /* =========================================================================== | ||
26 | */ | ||
27 | -int ZEXPORT compress (dest, destLen, source, sourceLen) | ||
28 | +ZEXPORT int compress (dest, destLen, source, sourceLen) | ||
29 | Bytef *dest; | ||
30 | uLongf *destLen; | ||
31 | const Bytef *source; | ||
32 | @@ -72,7 +72,7 @@ | ||
33 | If the default memLevel or windowBits for deflateInit() is changed, then | ||
34 | this function needs to be updated. | ||
35 | */ | ||
36 | -uLong ZEXPORT compressBound (sourceLen) | ||
37 | +ZEXPORT uLong compressBound (sourceLen) | ||
38 | uLong sourceLen; | ||
39 | { | ||
40 | return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11; | ||
41 | --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/crc32.c 2004-10-03 21:29:30.000000000 -0500 | ||
42 | +++ zlib-1.2.2/crc32.c 2005-02-28 19:04:09.000000000 -0600 | ||
43 | @@ -198,7 +198,7 @@ | ||
44 | /* ========================================================================= | ||
45 | * This function can be used by asm versions of crc32() | ||
46 | */ | ||
47 | -const unsigned long FAR * ZEXPORT get_crc_table() | ||
48 | +ZEXPORT const unsigned long FAR * get_crc_table() | ||
49 | { | ||
50 | #ifdef DYNAMIC_CRC_TABLE | ||
51 | if (crc_table_empty) | ||
52 | @@ -212,7 +212,7 @@ | ||
53 | #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 | ||
54 | |||
55 | /* ========================================================================= */ | ||
56 | -unsigned long ZEXPORT crc32(crc, buf, len) | ||
57 | +ZEXPORT unsigned long crc32(crc, buf, len) | ||
58 | unsigned long crc; | ||
59 | const unsigned char FAR *buf; | ||
60 | unsigned len; | ||
61 | --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/deflate.c 2004-09-15 09:28:14.000000000 -0500 | ||
62 | +++ zlib-1.2.2/deflate.c 2005-02-28 19:04:09.000000000 -0600 | ||
63 | @@ -201,7 +201,7 @@ | ||
64 | zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); | ||
65 | |||
66 | /* ========================================================================= */ | ||
67 | -int ZEXPORT deflateInit_(strm, level, version, stream_size) | ||
68 | +ZEXPORT int deflateInit_(strm, level, version, stream_size) | ||
69 | z_streamp strm; | ||
70 | int level; | ||
71 | const char *version; | ||
72 | @@ -213,7 +213,7 @@ | ||
73 | } | ||
74 | |||
75 | /* ========================================================================= */ | ||
76 | -int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, | ||
77 | +ZEXPORT int deflateInit2_(strm, level, method, windowBits, memLevel, strategy, | ||
78 | version, stream_size) | ||
79 | z_streamp strm; | ||
80 | int level; | ||
81 | @@ -311,7 +311,7 @@ | ||
82 | } | ||
83 | |||
84 | /* ========================================================================= */ | ||
85 | -int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) | ||
86 | +ZEXPORT int deflateSetDictionary (strm, dictionary, dictLength) | ||
87 | z_streamp strm; | ||
88 | const Bytef *dictionary; | ||
89 | uInt dictLength; | ||
90 | @@ -355,7 +355,7 @@ | ||
91 | } | ||
92 | |||
93 | /* ========================================================================= */ | ||
94 | -int ZEXPORT deflateReset (strm) | ||
95 | +ZEXPORT int deflateReset (strm) | ||
96 | z_streamp strm; | ||
97 | { | ||
98 | deflate_state *s; | ||
99 | @@ -391,7 +391,7 @@ | ||
100 | } | ||
101 | |||
102 | /* ========================================================================= */ | ||
103 | -int ZEXPORT deflatePrime (strm, bits, value) | ||
104 | +ZEXPORT int deflatePrime (strm, bits, value) | ||
105 | z_streamp strm; | ||
106 | int bits; | ||
107 | int value; | ||
108 | @@ -403,7 +403,7 @@ | ||
109 | } | ||
110 | |||
111 | /* ========================================================================= */ | ||
112 | -int ZEXPORT deflateParams(strm, level, strategy) | ||
113 | +ZEXPORT int deflateParams(strm, level, strategy) | ||
114 | z_streamp strm; | ||
115 | int level; | ||
116 | int strategy; | ||
117 | @@ -457,7 +457,7 @@ | ||
118 | * But even the conservative upper bound of about 14% expansion does not | ||
119 | * seem onerous for output buffer allocation. | ||
120 | */ | ||
121 | -uLong ZEXPORT deflateBound(strm, sourceLen) | ||
122 | +ZEXPORT uLong deflateBound(strm, sourceLen) | ||
123 | z_streamp strm; | ||
124 | uLong sourceLen; | ||
125 | { | ||
126 | @@ -520,7 +520,7 @@ | ||
127 | } | ||
128 | |||
129 | /* ========================================================================= */ | ||
130 | -int ZEXPORT deflate (strm, flush) | ||
131 | +ZEXPORT int deflate (strm, flush) | ||
132 | z_streamp strm; | ||
133 | int flush; | ||
134 | { | ||
135 | @@ -696,7 +696,7 @@ | ||
136 | } | ||
137 | |||
138 | /* ========================================================================= */ | ||
139 | -int ZEXPORT deflateEnd (strm) | ||
140 | +ZEXPORT int deflateEnd (strm) | ||
141 | z_streamp strm; | ||
142 | { | ||
143 | int status; | ||
144 | @@ -726,7 +726,7 @@ | ||
145 | * To simplify the source, this is not supported for 16-bit MSDOS (which | ||
146 | * doesn't have enough memory anyway to duplicate compression states). | ||
147 | */ | ||
148 | -int ZEXPORT deflateCopy (dest, source) | ||
149 | +ZEXPORT int deflateCopy (dest, source) | ||
150 | z_streamp dest; | ||
151 | z_streamp source; | ||
152 | { | ||
153 | --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/gzio.c 2004-10-03 21:30:37.000000000 -0500 | ||
154 | +++ zlib-1.2.2/gzio.c 2005-02-28 19:06:11.000000000 -0600 | ||
155 | @@ -205,7 +205,7 @@ | ||
156 | /* =========================================================================== | ||
157 | Opens a gzip (.gz) file for reading or writing. | ||
158 | */ | ||
159 | -gzFile ZEXPORT gzopen (path, mode) | ||
160 | +ZEXPORT gzFile gzopen (path, mode) | ||
161 | const char *path; | ||
162 | const char *mode; | ||
163 | { | ||
164 | @@ -216,7 +216,7 @@ | ||
165 | Associate a gzFile with the file descriptor fd. fd is not dup'ed here | ||
166 | to mimic the behavio(u)r of fdopen. | ||
167 | */ | ||
168 | -gzFile ZEXPORT gzdopen (fd, mode) | ||
169 | +ZEXPORT gzFile gzdopen (fd, mode) | ||
170 | int fd; | ||
171 | const char *mode; | ||
172 | { | ||
173 | @@ -231,7 +231,7 @@ | ||
174 | /* =========================================================================== | ||
175 | * Update the compression level and strategy | ||
176 | */ | ||
177 | -int ZEXPORT gzsetparams (file, level, strategy) | ||
178 | +ZEXPORT int gzsetparams (file, level, strategy) | ||
179 | gzFile file; | ||
180 | int level; | ||
181 | int strategy; | ||
182 | @@ -391,7 +391,7 @@ | ||
183 | Reads the given number of uncompressed bytes from the compressed file. | ||
184 | gzread returns the number of bytes actually read (0 for end of file). | ||
185 | */ | ||
186 | -int ZEXPORT gzread (file, buf, len) | ||
187 | +ZEXPORT int gzread (file, buf, len) | ||
188 | gzFile file; | ||
189 | voidp buf; | ||
190 | unsigned len; | ||
191 | @@ -500,7 +500,7 @@ | ||
192 | Reads one byte from the compressed file. gzgetc returns this byte | ||
193 | or -1 in case of end of file or error. | ||
194 | */ | ||
195 | -int ZEXPORT gzgetc(file) | ||
196 | +ZEXPORT int gzgetc(file) | ||
197 | gzFile file; | ||
198 | { | ||
199 | unsigned char c; | ||
200 | @@ -512,7 +512,7 @@ | ||
201 | /* =========================================================================== | ||
202 | Push one byte back onto the stream. | ||
203 | */ | ||
204 | -int ZEXPORT gzungetc(c, file) | ||
205 | +ZEXPORT int gzungetc(c, file) | ||
206 | int c; | ||
207 | gzFile file; | ||
208 | { | ||
209 | @@ -537,7 +537,7 @@ | ||
210 | |||
211 | The current implementation is not optimized at all. | ||
212 | */ | ||
213 | -char * ZEXPORT gzgets(file, buf, len) | ||
214 | +ZEXPORT char * gzgets(file, buf, len) | ||
215 | gzFile file; | ||
216 | char *buf; | ||
217 | int len; | ||
218 | @@ -556,7 +556,7 @@ | ||
219 | Writes the given number of uncompressed bytes into the compressed file. | ||
220 | gzwrite returns the number of bytes actually written (0 in case of error). | ||
221 | */ | ||
222 | -int ZEXPORT gzwrite (file, buf, len) | ||
223 | +ZEXPORT int gzwrite (file, buf, len) | ||
224 | gzFile file; | ||
225 | voidpc buf; | ||
226 | unsigned len; | ||
227 | @@ -600,7 +600,7 @@ | ||
228 | #ifdef STDC | ||
229 | #include <stdarg.h> | ||
230 | |||
231 | -int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...) | ||
232 | +ZEXPORTVA int gzprintf (gzFile file, const char *format, /* args */ ...) | ||
233 | { | ||
234 | char buf[Z_PRINTF_BUFSIZE]; | ||
235 | va_list va; | ||
236 | @@ -634,7 +634,7 @@ | ||
237 | } | ||
238 | #else /* not ANSI C */ | ||
239 | |||
240 | -int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, | ||
241 | +ZEXPORT intVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, | ||
242 | a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) | ||
243 | gzFile file; | ||
244 | const char *format; | ||
245 | @@ -675,7 +675,7 @@ | ||
246 | Writes c, converted to an unsigned char, into the compressed file. | ||
247 | gzputc returns the value that was written, or -1 in case of error. | ||
248 | */ | ||
249 | -int ZEXPORT gzputc(file, c) | ||
250 | +ZEXPORT int gzputc(file, c) | ||
251 | gzFile file; | ||
252 | int c; | ||
253 | { | ||
254 | @@ -690,7 +690,7 @@ | ||
255 | the terminating null character. | ||
256 | gzputs returns the number of characters written, or -1 in case of error. | ||
257 | */ | ||
258 | -int ZEXPORT gzputs(file, s) | ||
259 | +ZEXPORT int gzputs(file, s) | ||
260 | gzFile file; | ||
261 | const char *s; | ||
262 | { | ||
263 | @@ -743,7 +743,7 @@ | ||
264 | return s->z_err == Z_STREAM_END ? Z_OK : s->z_err; | ||
265 | } | ||
266 | |||
267 | -int ZEXPORT gzflush (file, flush) | ||
268 | +ZEXPORT int gzflush (file, flush) | ||
269 | gzFile file; | ||
270 | int flush; | ||
271 | { | ||
272 | @@ -764,7 +764,7 @@ | ||
273 | SEEK_END is not implemented, returns error. | ||
274 | In this version of the library, gzseek can be extremely slow. | ||
275 | */ | ||
276 | -z_off_t ZEXPORT gzseek (file, offset, whence) | ||
277 | +ZEXPORT z_off_t gzseek (file, offset, whence) | ||
278 | gzFile file; | ||
279 | z_off_t offset; | ||
280 | int whence; | ||
281 | @@ -854,7 +854,7 @@ | ||
282 | /* =========================================================================== | ||
283 | Rewinds input file. | ||
284 | */ | ||
285 | -int ZEXPORT gzrewind (file) | ||
286 | +ZEXPORT int gzrewind (file) | ||
287 | gzFile file; | ||
288 | { | ||
289 | gz_stream *s = (gz_stream*)file; | ||
290 | @@ -878,7 +878,7 @@ | ||
291 | given compressed file. This position represents a number of bytes in the | ||
292 | uncompressed data stream. | ||
293 | */ | ||
294 | -z_off_t ZEXPORT gztell (file) | ||
295 | +ZEXPORT z_off_t gztell (file) | ||
296 | gzFile file; | ||
297 | { | ||
298 | return gzseek(file, 0L, SEEK_CUR); | ||
299 | @@ -888,7 +888,7 @@ | ||
300 | Returns 1 when EOF has previously been detected reading the given | ||
301 | input stream, otherwise zero. | ||
302 | */ | ||
303 | -int ZEXPORT gzeof (file) | ||
304 | +ZEXPORT int gzeof (file) | ||
305 | gzFile file; | ||
306 | { | ||
307 | gz_stream *s = (gz_stream*)file; | ||
308 | @@ -938,7 +938,7 @@ | ||
309 | Flushes all pending output if necessary, closes the compressed file | ||
310 | and deallocates all the (de)compression state. | ||
311 | */ | ||
312 | -int ZEXPORT gzclose (file) | ||
313 | +ZEXPORT int gzclose (file) | ||
314 | gzFile file; | ||
315 | { | ||
316 | int err; | ||
317 | @@ -967,7 +967,7 @@ | ||
318 | errnum is set to Z_ERRNO and the application may consult errno | ||
319 | to get the exact error code. | ||
320 | */ | ||
321 | -const char * ZEXPORT gzerror (file, errnum) | ||
322 | +ZEXPORT const char * gzerror (file, errnum) | ||
323 | gzFile file; | ||
324 | int *errnum; | ||
325 | { | ||
326 | @@ -997,7 +997,7 @@ | ||
327 | /* =========================================================================== | ||
328 | Clear the error and end-of-file flags, and do the same for the real file. | ||
329 | */ | ||
330 | -void ZEXPORT gzclearerr (file) | ||
331 | +ZEXPORT void gzclearerr (file) | ||
332 | gzFile file; | ||
333 | { | ||
334 | gz_stream *s = (gz_stream*)file; | ||
335 | --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/infback.c 2004-10-03 21:31:20.000000000 -0500 | ||
336 | +++ zlib-1.2.2/infback.c 2005-02-28 19:04:09.000000000 -0600 | ||
337 | @@ -25,7 +25,7 @@ | ||
338 | windowBits is in the range 8..15, and window is a user-supplied | ||
339 | window and output buffer that is 2**windowBits bytes. | ||
340 | */ | ||
341 | -int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size) | ||
342 | +ZEXPORT int inflateBackInit_(strm, windowBits, window, version, stream_size) | ||
343 | z_stream FAR *strm; | ||
344 | int windowBits; | ||
345 | unsigned char FAR *window; | ||
346 | @@ -237,7 +237,7 @@ | ||
347 | inflateBack() can also return Z_STREAM_ERROR if the input parameters | ||
348 | are not correct, i.e. strm is Z_NULL or the state was not initialized. | ||
349 | */ | ||
350 | -int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc) | ||
351 | +ZEXPORT int inflateBack(strm, in, in_desc, out, out_desc) | ||
352 | z_stream FAR *strm; | ||
353 | in_func in; | ||
354 | void FAR *in_desc; | ||
355 | @@ -610,7 +610,7 @@ | ||
356 | return ret; | ||
357 | } | ||
358 | |||
359 | -int ZEXPORT inflateBackEnd(strm) | ||
360 | +ZEXPORT int inflateBackEnd(strm) | ||
361 | z_stream FAR *strm; | ||
362 | { | ||
363 | if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) | ||
364 | --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/inflate.c 2004-10-03 21:33:51.000000000 -0500 | ||
365 | +++ zlib-1.2.2/inflate.c 2005-02-28 19:04:09.000000000 -0600 | ||
366 | @@ -100,7 +100,7 @@ | ||
367 | local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, | ||
368 | unsigned len)); | ||
369 | |||
370 | -int ZEXPORT inflateReset(strm) | ||
371 | +ZEXPORT int inflateReset(strm) | ||
372 | z_streamp strm; | ||
373 | { | ||
374 | struct inflate_state FAR *state; | ||
375 | @@ -122,7 +122,7 @@ | ||
376 | return Z_OK; | ||
377 | } | ||
378 | |||
379 | -int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) | ||
380 | +ZEXPORT int inflateInit2_(strm, windowBits, version, stream_size) | ||
381 | z_streamp strm; | ||
382 | int windowBits; | ||
383 | const char *version; | ||
384 | @@ -165,7 +165,7 @@ | ||
385 | return inflateReset(strm); | ||
386 | } | ||
387 | |||
388 | -int ZEXPORT inflateInit_(strm, version, stream_size) | ||
389 | +ZEXPORT int inflateInit_(strm, version, stream_size) | ||
390 | z_streamp strm; | ||
391 | const char *version; | ||
392 | int stream_size; | ||
393 | @@ -532,7 +532,7 @@ | ||
394 | will return Z_BUF_ERROR if it has not reached the end of the stream. | ||
395 | */ | ||
396 | |||
397 | -int ZEXPORT inflate(strm, flush) | ||
398 | +ZEXPORT int inflate(strm, flush) | ||
399 | z_streamp strm; | ||
400 | int flush; | ||
401 | { | ||
402 | @@ -1085,7 +1085,7 @@ | ||
403 | return ret; | ||
404 | } | ||
405 | |||
406 | -int ZEXPORT inflateEnd(strm) | ||
407 | +ZEXPORT int inflateEnd(strm) | ||
408 | z_streamp strm; | ||
409 | { | ||
410 | struct inflate_state FAR *state; | ||
411 | @@ -1099,7 +1099,7 @@ | ||
412 | return Z_OK; | ||
413 | } | ||
414 | |||
415 | -int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) | ||
416 | +ZEXPORT int inflateSetDictionary(strm, dictionary, dictLength) | ||
417 | z_streamp strm; | ||
418 | const Bytef *dictionary; | ||
419 | uInt dictLength; | ||
420 | @@ -1171,7 +1171,7 @@ | ||
421 | return next; | ||
422 | } | ||
423 | |||
424 | -int ZEXPORT inflateSync(strm) | ||
425 | +ZEXPORT int inflateSync(strm) | ||
426 | z_streamp strm; | ||
427 | { | ||
428 | unsigned len; /* number of bytes to look at or looked at */ | ||
429 | @@ -1222,7 +1222,7 @@ | ||
430 | block. When decompressing, PPP checks that at the end of input packet, | ||
431 | inflate is waiting for these length bytes. | ||
432 | */ | ||
433 | -int ZEXPORT inflateSyncPoint(strm) | ||
434 | +ZEXPORT int inflateSyncPoint(strm) | ||
435 | z_streamp strm; | ||
436 | { | ||
437 | struct inflate_state FAR *state; | ||
438 | @@ -1232,7 +1232,7 @@ | ||
439 | return state->mode == STORED && state->bits == 0; | ||
440 | } | ||
441 | |||
442 | -int ZEXPORT inflateCopy(dest, source) | ||
443 | +ZEXPORT int inflateCopy(dest, source) | ||
444 | z_streamp dest; | ||
445 | z_streamp source; | ||
446 | { | ||
447 | --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/uncompr.c 2003-07-07 00:36:56.000000000 -0500 | ||
448 | +++ zlib-1.2.2/uncompr.c 2005-02-28 19:04:09.000000000 -0600 | ||
449 | @@ -23,7 +23,7 @@ | ||
450 | enough memory, Z_BUF_ERROR if there was not enough room in the output | ||
451 | buffer, or Z_DATA_ERROR if the input data was corrupted. | ||
452 | */ | ||
453 | -int ZEXPORT uncompress (dest, destLen, source, sourceLen) | ||
454 | +ZEXPORT int uncompress (dest, destLen, source, sourceLen) | ||
455 | Bytef *dest; | ||
456 | uLongf *destLen; | ||
457 | const Bytef *source; | ||
458 | --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/zconf.in.h 2004-05-30 15:38:00.000000000 -0500 | ||
459 | +++ zlib-1.2.2/zconf.in.h 2005-02-28 19:04:09.000000000 -0600 | ||
460 | @@ -198,11 +198,9 @@ | ||
461 | */ | ||
462 | # ifdef ZLIB_DLL | ||
463 | # if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) | ||
464 | -# ifdef ZLIB_INTERNAL | ||
465 | -# define ZEXTERN extern __declspec(dllexport) | ||
466 | -# else | ||
467 | -# define ZEXTERN extern __declspec(dllimport) | ||
468 | -# endif | ||
469 | +# define ZDLLLOCAL __declspec(dllimport) | ||
470 | +# define ZDLLPUBLIC __declspec(dllexport) | ||
471 | +# define ZEXTERN extern | ||
472 | # endif | ||
473 | # endif /* ZLIB_DLL */ | ||
474 | /* If building or using zlib with the WINAPI/WINAPIV calling convention, | ||
475 | @@ -223,30 +221,45 @@ | ||
476 | # define ZEXPORTVA FAR CDECL | ||
477 | # endif | ||
478 | # endif | ||
479 | -#endif | ||
480 | - | ||
481 | -#if defined (__BEOS__) | ||
482 | +#elif defined (__BEOS__) | ||
483 | # ifdef ZLIB_DLL | ||
484 | -# ifdef ZLIB_INTERNAL | ||
485 | -# define ZEXPORT __declspec(dllexport) | ||
486 | -# define ZEXPORTVA __declspec(dllexport) | ||
487 | -# else | ||
488 | -# define ZEXPORT __declspec(dllimport) | ||
489 | -# define ZEXPORTVA __declspec(dllimport) | ||
490 | -# endif | ||
491 | +# define ZDLLIMPORT __declspec(dllimport) | ||
492 | +# define ZDLLPUBLIC __declspec(dllexport) | ||
493 | +# define ZDLLLOCAL | ||
494 | +# endif | ||
495 | +#else | ||
496 | +# define ZDLLIMPORT | ||
497 | +# ifdef GCC_HASCLASSVISIBILITY | ||
498 | +# define ZDLLLOCAL __attribute__ ((visibility("hidden"))) | ||
499 | +# define ZDLLPUBLIC __attribute__ ((visibility("default"))) | ||
500 | +# else | ||
501 | +# define ZDLLLOCAL | ||
502 | +# define ZDLLPUBLIC | ||
503 | # endif | ||
504 | #endif | ||
505 | |||
506 | #ifndef ZEXTERN | ||
507 | # define ZEXTERN extern | ||
508 | #endif | ||
509 | -#ifndef ZEXPORT | ||
510 | -# define ZEXPORT | ||
511 | -#endif | ||
512 | -#ifndef ZEXPORTVA | ||
513 | -# define ZEXPORTVA | ||
514 | +#ifdef ZLIB_INTERNAL | ||
515 | +# ifndef ZLIB_DLL | ||
516 | +# define ZEXPORT | ||
517 | +# define ZEXPORTVA | ||
518 | +# endif | ||
519 | +# ifndef ZEXPORT | ||
520 | +# define ZEXPORT ZDLLPUBLIC | ||
521 | +# endif | ||
522 | +# ifndef ZEXPORTVA | ||
523 | +# define ZEXPORTVA ZDLLPUBLIC | ||
524 | +# endif | ||
525 | +#else | ||
526 | +# ifndef ZEXPORT | ||
527 | +# define ZEXPORT ZDLLIMPORT | ||
528 | +# endif | ||
529 | +# ifndef ZEXPORTVA | ||
530 | +# define ZEXPORTVA ZDLLIMPORT | ||
531 | +# endif | ||
532 | #endif | ||
533 | - | ||
534 | #ifndef FAR | ||
535 | # define FAR | ||
536 | #endif | ||
537 | --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/zlib.h 2004-10-03 21:57:26.000000000 -0500 | ||
538 | +++ zlib-1.2.2/zlib.h 2005-02-28 19:04:09.000000000 -0600 | ||
539 | @@ -184,7 +184,7 @@ | ||
540 | |||
541 | /* basic functions */ | ||
542 | |||
543 | -ZEXTERN const char * ZEXPORT zlibVersion OF((void)); | ||
544 | +ZEXTERN ZEXPORT const char * zlibVersion OF((void)); | ||
545 | /* The application can compare zlibVersion and ZLIB_VERSION for consistency. | ||
546 | If the first character differs, the library code actually used is | ||
547 | not compatible with the zlib.h header file used by the application. | ||
548 | @@ -192,7 +192,7 @@ | ||
549 | */ | ||
550 | |||
551 | /* | ||
552 | -ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); | ||
553 | +ZEXTERN ZEXPORT int deflateInit OF((z_streamp strm, int level)); | ||
554 | |||
555 | Initializes the internal stream state for compression. The fields | ||
556 | zalloc, zfree and opaque must be initialized before by the caller. | ||
557 | @@ -214,7 +214,7 @@ | ||
558 | */ | ||
559 | |||
560 | |||
561 | -ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); | ||
562 | +ZEXTERN ZEXPORT int deflate OF((z_streamp strm, int flush)); | ||
563 | /* | ||
564 | deflate compresses as much data as possible, and stops when the input | ||
565 | buffer becomes empty or the output buffer becomes full. It may introduce some | ||
566 | @@ -296,7 +296,7 @@ | ||
567 | */ | ||
568 | |||
569 | |||
570 | -ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); | ||
571 | +ZEXTERN ZEXPORT int deflateEnd OF((z_streamp strm)); | ||
572 | /* | ||
573 | All dynamically allocated data structures for this stream are freed. | ||
574 | This function discards any unprocessed input and does not flush any | ||
575 | @@ -311,7 +311,7 @@ | ||
576 | |||
577 | |||
578 | /* | ||
579 | -ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); | ||
580 | +ZEXTERN ZEXPORT int inflateInit OF((z_streamp strm)); | ||
581 | |||
582 | Initializes the internal stream state for decompression. The fields | ||
583 | next_in, avail_in, zalloc, zfree and opaque must be initialized before by | ||
584 | @@ -331,7 +331,7 @@ | ||
585 | */ | ||
586 | |||
587 | |||
588 | -ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); | ||
589 | +ZEXTERN ZEXPORT int inflate OF((z_streamp strm, int flush)); | ||
590 | /* | ||
591 | inflate decompresses as much data as possible, and stops when the input | ||
592 | buffer becomes empty or the output buffer becomes full. It may introduce | ||
593 | @@ -430,7 +430,7 @@ | ||
594 | */ | ||
595 | |||
596 | |||
597 | -ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); | ||
598 | +ZEXTERN ZEXPORT int inflateEnd OF((z_streamp strm)); | ||
599 | /* | ||
600 | All dynamically allocated data structures for this stream are freed. | ||
601 | This function discards any unprocessed input and does not flush any | ||
602 | @@ -448,7 +448,7 @@ | ||
603 | */ | ||
604 | |||
605 | /* | ||
606 | -ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, | ||
607 | +ZEXTERN ZEXPORT int deflateInit2 OF((z_streamp strm, | ||
608 | int level, | ||
609 | int method, | ||
610 | int windowBits, | ||
611 | @@ -504,7 +504,7 @@ | ||
612 | not perform any compression: this will be done by deflate(). | ||
613 | */ | ||
614 | |||
615 | -ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, | ||
616 | +ZEXTERN ZEXPORT int deflateSetDictionary OF((z_streamp strm, | ||
617 | const Bytef *dictionary, | ||
618 | uInt dictLength)); | ||
619 | /* | ||
620 | @@ -541,7 +541,7 @@ | ||
621 | perform any compression: this will be done by deflate(). | ||
622 | */ | ||
623 | |||
624 | -ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, | ||
625 | +ZEXTERN ZEXPORT int deflateCopy OF((z_streamp dest, | ||
626 | z_streamp source)); | ||
627 | /* | ||
628 | Sets the destination stream as a complete copy of the source stream. | ||
629 | @@ -559,7 +559,7 @@ | ||
630 | destination. | ||
631 | */ | ||
632 | |||
633 | -ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); | ||
634 | +ZEXTERN ZEXPORT int deflateReset OF((z_streamp strm)); | ||
635 | /* | ||
636 | This function is equivalent to deflateEnd followed by deflateInit, | ||
637 | but does not free and reallocate all the internal compression state. | ||
638 | @@ -570,7 +570,7 @@ | ||
639 | stream state was inconsistent (such as zalloc or state being NULL). | ||
640 | */ | ||
641 | |||
642 | -ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, | ||
643 | +ZEXTERN ZEXPORT int deflateParams OF((z_streamp strm, | ||
644 | int level, | ||
645 | int strategy)); | ||
646 | /* | ||
647 | @@ -591,7 +591,7 @@ | ||
648 | if strm->avail_out was zero. | ||
649 | */ | ||
650 | |||
651 | -ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, | ||
652 | +ZEXTERN ZEXPORT uLong deflateBound OF((z_streamp strm, | ||
653 | uLong sourceLen)); | ||
654 | /* | ||
655 | deflateBound() returns an upper bound on the compressed size after | ||
656 | @@ -600,7 +600,7 @@ | ||
657 | for deflation in a single pass, and so would be called before deflate(). | ||
658 | */ | ||
659 | |||
660 | -ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, | ||
661 | +ZEXTERN ZEXPORT int deflatePrime OF((z_streamp strm, | ||
662 | int bits, | ||
663 | int value)); | ||
664 | /* | ||
665 | @@ -617,7 +617,7 @@ | ||
666 | */ | ||
667 | |||
668 | /* | ||
669 | -ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, | ||
670 | +ZEXTERN ZEXPORT int inflateInit2 OF((z_streamp strm, | ||
671 | int windowBits)); | ||
672 | |||
673 | This is another version of inflateInit with an extra parameter. The | ||
674 | @@ -659,7 +659,7 @@ | ||
675 | modified, but next_out and avail_out are unchanged.) | ||
676 | */ | ||
677 | |||
678 | -ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, | ||
679 | +ZEXTERN ZEXPORT int inflateSetDictionary OF((z_streamp strm, | ||
680 | const Bytef *dictionary, | ||
681 | uInt dictLength)); | ||
682 | /* | ||
683 | @@ -678,7 +678,7 @@ | ||
684 | inflate(). | ||
685 | */ | ||
686 | |||
687 | -ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); | ||
688 | +ZEXTERN ZEXPORT int inflateSync OF((z_streamp strm)); | ||
689 | /* | ||
690 | Skips invalid compressed data until a full flush point (see above the | ||
691 | description of deflate with Z_FULL_FLUSH) can be found, or until all | ||
692 | @@ -693,7 +693,7 @@ | ||
693 | until success or end of the input data. | ||
694 | */ | ||
695 | |||
696 | -ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, | ||
697 | +ZEXTERN ZEXPORT int inflateCopy OF((z_streamp dest, | ||
698 | z_streamp source)); | ||
699 | /* | ||
700 | Sets the destination stream as a complete copy of the source stream. | ||
701 | @@ -709,7 +709,7 @@ | ||
702 | destination. | ||
703 | */ | ||
704 | |||
705 | -ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); | ||
706 | +ZEXTERN ZEXPORT int inflateReset OF((z_streamp strm)); | ||
707 | /* | ||
708 | This function is equivalent to inflateEnd followed by inflateInit, | ||
709 | but does not free and reallocate all the internal decompression state. | ||
710 | @@ -720,7 +720,7 @@ | ||
711 | */ | ||
712 | |||
713 | /* | ||
714 | -ZEXTERN int ZEXPORT inflateBackInit OF((z_stream FAR *strm, int windowBits, | ||
715 | +ZEXTERN ZEXPORT int inflateBackInit OF((z_stream FAR *strm, int windowBits, | ||
716 | unsigned char FAR *window)); | ||
717 | |||
718 | Initialize the internal stream state for decompression using inflateBack() | ||
719 | @@ -744,7 +744,7 @@ | ||
720 | typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); | ||
721 | typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); | ||
722 | |||
723 | -ZEXTERN int ZEXPORT inflateBack OF((z_stream FAR *strm, | ||
724 | +ZEXTERN ZEXPORT int inflateBack OF((z_stream FAR *strm, | ||
725 | in_func in, void FAR *in_desc, | ||
726 | out_func out, void FAR *out_desc)); | ||
727 | /* | ||
728 | @@ -813,7 +813,7 @@ | ||
729 | that inflateBack() cannot return Z_OK. | ||
730 | */ | ||
731 | |||
732 | -ZEXTERN int ZEXPORT inflateBackEnd OF((z_stream FAR *strm)); | ||
733 | +ZEXTERN ZEXPORT int inflateBackEnd OF((z_stream FAR *strm)); | ||
734 | /* | ||
735 | All memory allocated by inflateBackInit() is freed. | ||
736 | |||
737 | @@ -821,7 +821,7 @@ | ||
738 | state was inconsistent. | ||
739 | */ | ||
740 | |||
741 | -ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); | ||
742 | +ZEXTERN ZEXPORT uLong zlibCompileFlags OF((void)); | ||
743 | /* Return flags indicating compile-time options. | ||
744 | |||
745 | Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: | ||
746 | @@ -873,7 +873,7 @@ | ||
747 | utility functions can easily be modified if you need special options. | ||
748 | */ | ||
749 | |||
750 | -ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, | ||
751 | +ZEXTERN ZEXPORT int compress OF((Bytef *dest, uLongf *destLen, | ||
752 | const Bytef *source, uLong sourceLen)); | ||
753 | /* | ||
754 | Compresses the source buffer into the destination buffer. sourceLen is | ||
755 | @@ -888,7 +888,7 @@ | ||
756 | buffer. | ||
757 | */ | ||
758 | |||
759 | -ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, | ||
760 | +ZEXTERN ZEXPORT int compress2 OF((Bytef *dest, uLongf *destLen, | ||
761 | const Bytef *source, uLong sourceLen, | ||
762 | int level)); | ||
763 | /* | ||
764 | @@ -904,14 +904,14 @@ | ||
765 | Z_STREAM_ERROR if the level parameter is invalid. | ||
766 | */ | ||
767 | |||
768 | -ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); | ||
769 | +ZEXTERN ZEXPORT uLong compressBound OF((uLong sourceLen)); | ||
770 | /* | ||
771 | compressBound() returns an upper bound on the compressed size after | ||
772 | compress() or compress2() on sourceLen bytes. It would be used before | ||
773 | a compress() or compress2() call to allocate the destination buffer. | ||
774 | */ | ||
775 | |||
776 | -ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, | ||
777 | +ZEXTERN ZEXPORT int uncompress OF((Bytef *dest, uLongf *destLen, | ||
778 | const Bytef *source, uLong sourceLen)); | ||
779 | /* | ||
780 | Decompresses the source buffer into the destination buffer. sourceLen is | ||
781 | @@ -932,7 +932,7 @@ | ||
782 | |||
783 | typedef voidp gzFile; | ||
784 | |||
785 | -ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); | ||
786 | +ZEXTERN ZEXPORT gzFile gzopen OF((const char *path, const char *mode)); | ||
787 | /* | ||
788 | Opens a gzip (.gz) file for reading or writing. The mode parameter | ||
789 | is as in fopen ("rb" or "wb") but can also include a compression level | ||
790 | @@ -949,7 +949,7 @@ | ||
791 | can be checked to distinguish the two cases (if errno is zero, the | ||
792 | zlib error is Z_MEM_ERROR). */ | ||
793 | |||
794 | -ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); | ||
795 | +ZEXTERN ZEXPORT gzFile gzdopen OF((int fd, const char *mode)); | ||
796 | /* | ||
797 | gzdopen() associates a gzFile with the file descriptor fd. File | ||
798 | descriptors are obtained from calls like open, dup, creat, pipe or | ||
799 | @@ -962,7 +962,7 @@ | ||
800 | the (de)compression state. | ||
801 | */ | ||
802 | |||
803 | -ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); | ||
804 | +ZEXTERN ZEXPORT int gzsetparams OF((gzFile file, int level, int strategy)); | ||
805 | /* | ||
806 | Dynamically update the compression level or strategy. See the description | ||
807 | of deflateInit2 for the meaning of these parameters. | ||
808 | @@ -970,7 +970,7 @@ | ||
809 | opened for writing. | ||
810 | */ | ||
811 | |||
812 | -ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); | ||
813 | +ZEXTERN ZEXPORT int gzread OF((gzFile file, voidp buf, unsigned len)); | ||
814 | /* | ||
815 | Reads the given number of uncompressed bytes from the compressed file. | ||
816 | If the input file was not in gzip format, gzread copies the given number | ||
817 | @@ -978,7 +978,7 @@ | ||
818 | gzread returns the number of uncompressed bytes actually read (0 for | ||
819 | end of file, -1 for error). */ | ||
820 | |||
821 | -ZEXTERN int ZEXPORT gzwrite OF((gzFile file, | ||
822 | +ZEXTERN ZEXPORT int gzwrite OF((gzFile file, | ||
823 | voidpc buf, unsigned len)); | ||
824 | /* | ||
825 | Writes the given number of uncompressed bytes into the compressed file. | ||
826 | @@ -986,7 +986,7 @@ | ||
827 | (0 in case of error). | ||
828 | */ | ||
829 | |||
830 | -ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); | ||
831 | +ZEXTERN ZEXPORTVA int gzprintf OF((gzFile file, const char *format, ...)); | ||
832 | /* | ||
833 | Converts, formats, and writes the args to the compressed file under | ||
834 | control of the format string, as in fprintf. gzprintf returns the number of | ||
835 | @@ -999,14 +999,14 @@ | ||
836 | because the secure snprintf() or vsnprintf() functions were not available. | ||
837 | */ | ||
838 | |||
839 | -ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); | ||
840 | +ZEXTERN ZEXPORT int gzputs OF((gzFile file, const char *s)); | ||
841 | /* | ||
842 | Writes the given null-terminated string to the compressed file, excluding | ||
843 | the terminating null character. | ||
844 | gzputs returns the number of characters written, or -1 in case of error. | ||
845 | */ | ||
846 | |||
847 | -ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); | ||
848 | +ZEXTERN ZEXPORT char * gzgets OF((gzFile file, char *buf, int len)); | ||
849 | /* | ||
850 | Reads bytes from the compressed file until len-1 characters are read, or | ||
851 | a newline character is read and transferred to buf, or an end-of-file | ||
852 | @@ -1015,19 +1015,19 @@ | ||
853 | gzgets returns buf, or Z_NULL in case of error. | ||
854 | */ | ||
855 | |||
856 | -ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); | ||
857 | +ZEXTERN ZEXPORT int gzputc OF((gzFile file, int c)); | ||
858 | /* | ||
859 | Writes c, converted to an unsigned char, into the compressed file. | ||
860 | gzputc returns the value that was written, or -1 in case of error. | ||
861 | */ | ||
862 | |||
863 | -ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); | ||
864 | +ZEXTERN ZEXPORT int gzgetc OF((gzFile file)); | ||
865 | /* | ||
866 | Reads one byte from the compressed file. gzgetc returns this byte | ||
867 | or -1 in case of end of file or error. | ||
868 | */ | ||
869 | |||
870 | -ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); | ||
871 | +ZEXTERN ZEXPORT int gzungetc OF((int c, gzFile file)); | ||
872 | /* | ||
873 | Push one character back onto the stream to be read again later. | ||
874 | Only one character of push-back is allowed. gzungetc() returns the | ||
875 | @@ -1037,7 +1037,7 @@ | ||
876 | or gzrewind(). | ||
877 | */ | ||
878 | |||
879 | -ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); | ||
880 | +ZEXTERN ZEXPORT int gzflush OF((gzFile file, int flush)); | ||
881 | /* | ||
882 | Flushes all pending output into the compressed file. The parameter | ||
883 | flush is as in the deflate() function. The return value is the zlib | ||
884 | @@ -1047,7 +1047,7 @@ | ||
885 | degrade compression. | ||
886 | */ | ||
887 | |||
888 | -ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, | ||
889 | +ZEXTERN ZEXPORT z_off_t gzseek OF((gzFile file, | ||
890 | z_off_t offset, int whence)); | ||
891 | /* | ||
892 | Sets the starting position for the next gzread or gzwrite on the | ||
893 | @@ -1065,14 +1065,14 @@ | ||
894 | would be before the current position. | ||
895 | */ | ||
896 | |||
897 | -ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); | ||
898 | +ZEXTERN ZEXPORT int gzrewind OF((gzFile file)); | ||
899 | /* | ||
900 | Rewinds the given file. This function is supported only for reading. | ||
901 | |||
902 | gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) | ||
903 | */ | ||
904 | |||
905 | -ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); | ||
906 | +ZEXTERN ZEXPORT z_off_t gztell OF((gzFile file)); | ||
907 | /* | ||
908 | Returns the starting position for the next gzread or gzwrite on the | ||
909 | given compressed file. This position represents a number of bytes in the | ||
910 | @@ -1081,20 +1081,20 @@ | ||
911 | gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) | ||
912 | */ | ||
913 | |||
914 | -ZEXTERN int ZEXPORT gzeof OF((gzFile file)); | ||
915 | +ZEXTERN ZEXPORT int gzeof OF((gzFile file)); | ||
916 | /* | ||
917 | Returns 1 when EOF has previously been detected reading the given | ||
918 | input stream, otherwise zero. | ||
919 | */ | ||
920 | |||
921 | -ZEXTERN int ZEXPORT gzclose OF((gzFile file)); | ||
922 | +ZEXTERN ZEXPORT int gzclose OF((gzFile file)); | ||
923 | /* | ||
924 | Flushes all pending output if necessary, closes the compressed file | ||
925 | and deallocates all the (de)compression state. The return value is the zlib | ||
926 | error number (see function gzerror below). | ||
927 | */ | ||
928 | |||
929 | -ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); | ||
930 | +ZEXTERN ZEXPORT const char * gzerror OF((gzFile file, int *errnum)); | ||
931 | /* | ||
932 | Returns the error message for the last error which occurred on the | ||
933 | given compressed file. errnum is set to zlib error number. If an | ||
934 | @@ -1103,7 +1103,7 @@ | ||
935 | to get the exact error code. | ||
936 | */ | ||
937 | |||
938 | -ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); | ||
939 | +ZEXTERN ZEXPORT void gzclearerr OF((gzFile file)); | ||
940 | /* | ||
941 | Clears the error and end-of-file flags for file. This is analogous to the | ||
942 | clearerr() function in stdio. This is useful for continuing to read a gzip | ||
943 | @@ -1118,7 +1118,7 @@ | ||
944 | compression library. | ||
945 | */ | ||
946 | |||
947 | -ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); | ||
948 | +ZEXTERN ZEXPORT uLong adler32 OF((uLong adler, const Bytef *buf, uInt len)); | ||
949 | |||
950 | /* | ||
951 | Update a running Adler-32 checksum with the bytes buf[0..len-1] and | ||
952 | @@ -1135,7 +1135,7 @@ | ||
953 | if (adler != original_adler) error(); | ||
954 | */ | ||
955 | |||
956 | -ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); | ||
957 | +ZEXTERN ZEXPORT uLong crc32 OF((uLong crc, const Bytef *buf, uInt len)); | ||
958 | /* | ||
959 | Update a running crc with the bytes buf[0..len-1] and return the updated | ||
960 | crc. If buf is NULL, this function returns the required initial value | ||
961 | @@ -1157,17 +1157,17 @@ | ||
962 | /* deflateInit and inflateInit are macros to allow checking the zlib version | ||
963 | * and the compiler's view of z_stream: | ||
964 | */ | ||
965 | -ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, | ||
966 | +ZEXTERN ZEXPORT int deflateInit_ OF((z_streamp strm, int level, | ||
967 | const char *version, int stream_size)); | ||
968 | -ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, | ||
969 | +ZEXTERN ZEXPORT int inflateInit_ OF((z_streamp strm, | ||
970 | const char *version, int stream_size)); | ||
971 | -ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, | ||
972 | +ZEXTERN ZEXPORT int deflateInit2_ OF((z_streamp strm, int level, int method, | ||
973 | int windowBits, int memLevel, | ||
974 | int strategy, const char *version, | ||
975 | int stream_size)); | ||
976 | -ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, | ||
977 | +ZEXTERN ZEXPORT int inflateInit2_ OF((z_streamp strm, int windowBits, | ||
978 | const char *version, int stream_size)); | ||
979 | -ZEXTERN int ZEXPORT inflateBackInit_ OF((z_stream FAR *strm, int windowBits, | ||
980 | +ZEXTERN ZEXPORT int inflateBackInit_ OF((z_stream FAR *strm, int windowBits, | ||
981 | unsigned char FAR *window, | ||
982 | const char *version, | ||
983 | int stream_size)); | ||
984 | @@ -1189,9 +1189,9 @@ | ||
985 | struct internal_state {int dummy;}; /* hack for buggy compilers */ | ||
986 | #endif | ||
987 | |||
988 | -ZEXTERN const char * ZEXPORT zError OF((int)); | ||
989 | -ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); | ||
990 | -ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); | ||
991 | +ZEXTERN ZEXPORT const char * zError OF((int)); | ||
992 | +ZEXTERN ZEXPORT int inflateSyncPoint OF((z_streamp z)); | ||
993 | +ZEXTERN ZEXPORT const uLongf * get_crc_table OF((void)); | ||
994 | |||
995 | #ifdef __cplusplus | ||
996 | } | ||
997 | --- tmp/work/arm-linux-uclibc/zlib-1.2.2-r5/zlib-1.2.2/zutil.c 2003-08-27 21:34:34.000000000 -0500 | ||
998 | +++ zlib-1.2.2/zutil.c 2005-02-28 19:04:09.000000000 -0600 | ||
999 | @@ -28,12 +28,12 @@ | ||
1000 | ""}; | ||
1001 | |||
1002 | |||
1003 | -const char * ZEXPORT zlibVersion() | ||
1004 | +ZEXPORT const char * zlibVersion() | ||
1005 | { | ||
1006 | return ZLIB_VERSION; | ||
1007 | } | ||
1008 | |||
1009 | -uLong ZEXPORT zlibCompileFlags() | ||
1010 | +ZEXPORT uLong zlibCompileFlags() | ||
1011 | { | ||
1012 | uLong flags; | ||
1013 | |||
1014 | @@ -134,7 +134,7 @@ | ||
1015 | /* exported to allow conversion of error code to string for compress() and | ||
1016 | * uncompress() | ||
1017 | */ | ||
1018 | -const char * ZEXPORT zError(err) | ||
1019 | +ZEXPORT const char * zError(err) | ||
1020 | int err; | ||
1021 | { | ||
1022 | return ERR_MSG(err); | ||
diff --git a/meta/packages/zlib/files/zlib_1.2.2-8.diff.gz b/meta/packages/zlib/files/zlib_1.2.2-8.diff.gz new file mode 100644 index 0000000000..c850141973 --- /dev/null +++ b/meta/packages/zlib/files/zlib_1.2.2-8.diff.gz | |||
Binary files differ | |||